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 System.Security.Permissions;
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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
public class HitboxScript : MonoBehaviour
{
	private static ManualLogSource Logger = Plugin.Logger;

	private static int debugLogLevel = -1;

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

	public EnemyAI mainScript;

	public HitboxScript[] allHitboxes;

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

	public HitboxScript managerHitbox;

	[Space]
	public int attackPower;

	public Vector3 attackForce;

	public int deathAnimIndex;

	[Space]
	public bool canHitPlayers;

	public bool canHitEnemies;

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

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

	private void Start()
	{
		if (debugLogLevel == -1)
		{
			debugLogLevel = 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_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_019a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0261: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		if (canHitPlayers && ((Component)other).CompareTag("Player"))
		{
			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} | deathAnimIndex {deathAnimIndex}");
			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 ((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);
				}
			}
			if (!component.isPlayerDead)
			{
				component.externalForceAutoFade = val2 * 2f;
			}
		}
		else
		{
			if (attackPower <= 0 || !canHitEnemies || !((Component)other).CompareTag("Enemy"))
			{
				return;
			}
			EnemyAICollisionDetect component2 = ((Component)other).GetComponent<EnemyAICollisionDetect>();
			if (!PerformHitEnemyCheck(component2) || !((NetworkBehaviour)mainScript).IsOwner)
			{
				return;
			}
			int num = attackPower / 10;
			Log($"{((Object)this).name} PerformAttack({other}) // hitEnemy: {component2.mainScript} | enemyAttackPower {num}");
			if (!((Object)(object)mainScript != (Object)null))
			{
				_ = ((Component)this).transform;
			}
			else
			{
				_ = ((Component)mainScript).transform;
			}
			if (num > 0)
			{
				component2.mainScript.HitEnemyOnLocalClient(num, default(Vector3), (PlayerControllerB)null, true, -1);
				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 obj2 = mainScript as TheBoxerAI;
					obj2.PlaySFX(obj2.punchSFX);
				}
			}
		}
	}

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

	private bool PerformHitEnemyCheck(EnemyAICollisionDetect hitEnemy)
	{
		if ((Object)(object)mainScript == (Object)null || (Object)(object)hitEnemy == (Object)null || (Object)(object)hitEnemy.mainScript == (Object)null)
		{
			return false;
		}
		EnemyAI val = hitEnemy.mainScript;
		if ((Object)(object)mainScript == (Object)(object)val || val.isEnemyDead || mainScript.isOutside != val.isOutside)
		{
			return false;
		}
		int enemyIndexInRoundManager = Plugin.GetEnemyIndexInRoundManager(val);
		bool num = !hitEnemyIDs.Contains(enemyIndexInRoundManager);
		if (num)
		{
			hitEnemyIDs.Add(enemyIndexInRoundManager);
			if (!managerHitbox.hitEnemyIDs.Contains(enemyIndexInRoundManager))
			{
				managerHitbox.hitEnemyIDs.Add(enemyIndexInRoundManager);
			}
		}
		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;
		}
		bool flag = Plugin.ConvertToBool(setInSpecialAnimationTo);
		LogAI($"{((Object)this).name}: SetEnemyInSpecialAnimTo({flag}) on {mainScript} #{((NetworkBehaviour)mainScript).NetworkObjectId}");
		if (mainScript is TheBeatAI)
		{
			(mainScript as TheBeatAI).SetEnemyInSpecialAnimation(flag);
		}
		else if (mainScript is TheBoxerAI)
		{
			(mainScript as TheBoxerAI).SetEnemyInSpecialAnimation(flag);
		}
	}

	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();
		managerHitbox.hitEnemyIDs.Clear();
		HitboxScript[] array = allHitboxes;
		foreach (HitboxScript hitboxScript in array)
		{
			LogAI($"clearing hitIDs on {hitboxScript}");
			hitboxScript.hitPlayerIDs.Clear();
			hitboxScript.hitEnemyIDs.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_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: 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_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		//IL_020f: 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, 7.5f, 1f, false, (PlayerControllerB)null, (PlayerControllerB)null, 0f);
				mainScript.enemyType.canBeStunned = true;
				break;
			case 4:
			{
				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.1f) + Vector3.up * 33f;
				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);
			return;
		}
		bool flag = false;
		if (mainScript is TheBeatAI)
		{
			_ = mainScript;
		}
		else if (mainScript is TheBoxerAI)
		{
			TheBoxerAI theBoxerAI = mainScript as TheBoxerAI;
			if ((Object)(object)theBoxerAI != (Object)null && ((NetworkBehaviour)theBoxerAI).IsOwner)
			{
				Log($"{theBoxerAI} hit {managerHitbox.hitPlayerIDs.Count} PLAYERS and {managerHitbox.hitEnemyIDs.Count} ENEMIES", 1);
				if (managerHitbox.hitPlayerIDs.Count != 0)
				{
					flag = theBoxerAI.OnHitSuccessful(managerHitbox.hitPlayerIDs.ToArray(), forPlayers: true);
				}
				if (!flag && hitEnemyIDs.Count != 0)
				{
					flag = theBoxerAI.OnHitSuccessful(managerHitbox.hitEnemyIDs.ToArray(), forPlayers: false);
				}
			}
		}
		if (flag)
		{
			managerHitbox.hitPlayerIDs.Clear();
			managerHitbox.hitEnemyIDs.Clear();
		}
	}

	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)
	{
		bool flag = false;
		if (!(enemyScript is TheBeatAI) && enemyScript is TheBoxerAI)
		{
			TheBoxerAI theBoxerAI = enemyScript as TheBoxerAI;
			if ((Object)(object)theBoxerAI != (Object)null && ((NetworkBehaviour)theBoxerAI).IsOwner)
			{
				Log($"{theBoxerAI} hit {hitPlayerIDs.Count} PLAYERS and {hitEnemyIDs.Count} ENEMIES", 1);
				if (hitPlayerIDs.Count != 0)
				{
					flag = theBoxerAI.OnHitSuccessful(hitPlayerIDs.ToArray(), forPlayers: true);
				}
				if (!flag && hitEnemyIDs.Count != 0)
				{
					flag = theBoxerAI.OnHitSuccessful(hitEnemyIDs.ToArray(), forPlayers: false);
				}
			}
		}
		if (flag)
		{
			hitPlayerIDs.Clear();
			hitEnemyIDs.Clear();
		}
	}

	private void Log(string message, int type = 0)
	{
		if (debugLogLevel >= 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 (debugLogLevel >= 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;
			}
		}
	}
}
public class TheBeatAI : EnemyAI
{
	private static ManualLogSource Logger = Plugin.Logger;

	private static int debugLogLevel = -1;

	private float tempTimer;

	private bool setItemLocally;

	private bool reachedHideSpot;

	private bool everyoneOutside;

	private bool seenDuringThisAmbush;

	private int timesStartedAmbush;

	private bool fakeAudioThisAmbush;

	private bool enraged;

	private bool attemptingItemRetrieve;

	private int hpAmbushStart;

	private float timeLastCollisionLocalPlayer;

	private float timeLastVoiceChatLocalPlayer;

	private float timeLastLookingAt;

	private Transform fleeToWhileCalculating;

	private Vector3 lookingAt;

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

	public float hideSpeed;

	public float chaseSpeed;

	public float enragedSpeed;

	public AISearchRoutine roamingSearch;

	[Tooltip("Low numbers are closer to the enemy transform, high numbers are closer to the point it finds for players/entrances.")]
	[Range(0f, 1f)]
	public float lerpMidpoint;

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

	public float seeWidth;

	public int[] awarenessDistancePerState;

	public float noiseThreshold;

	public float noiseLookThreshold;

	public float noiseDistanceDropoffPower;

	public Transform turnCompass;

	public Collider killBox;

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

	public AudioClip intimidateSFX;

	public AudioClip punchHitSFX;

	public AudioClip punchMissSFX;

	public AudioClip caughtSFX;

	public AudioClip reelSFX;

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

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

	public PlayAudioAnimationEvent animationAudio;

	[Header("Audience")]
	public AudioSource crowdVoices;

	public static AudioSource beatAudience;

	public AudioClip successCheer;

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

	public BeatAudioItem linkedItem;

	public Transform holdItemParentObject;

	public Coroutine pickItemPositionCoroutine;

	[Space(3f)]
	[Header("PARAMETERS")]
	public float maxSearchDistance;

	public float minDistanceBetweenFarawayNodes;

	public float maxDistanceBetweenFarawayNodes;

	public float verticalOffsetDropoffDivider;

	public float maxPlayerDistanceToPath;

	public float maxItemSpawnTime;

	public float maxHideSpotTime;

	public float minNodesNecessary;

	public float collisionCooldown;

	public int turnPlayerIterations;

	public override void Start()
	{
		((EnemyAI)this).Start();
		hpAmbushStart = base.enemyHP;
		if ((Object)(object)beatAudience == (Object)null)
		{
			((Component)crowdVoices).transform.SetParent(RoundManager.Instance.spawnedScrapContainer);
			beatAudience = crowdVoices;
		}
		if (debugLogLevel == -1)
		{
			debugLogLevel = Plugin.DebugLogLevel();
			base.DebugEnemy = debugLogLevel >= 1;
			base.debugEnemyAI = debugLogLevel >= 2;
		}
		if (((NetworkBehaviour)this).IsServer)
		{
			SpawnItemServerRpc(holdItemAfterSpawn: true);
		}
	}

	public override void Update()
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: 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_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).Update();
		if (base.isEnemyDead || !base.ventAnimationFinished)
		{
			return;
		}
		if ((Object)(object)base.inSpecialAnimationWithPlayer != (Object)null)
		{
			DetectNewSighting(((Component)base.inSpecialAnimationWithPlayer).transform.position);
		}
		if (Time.realtimeSinceStartup - timeLastLookingAt < 1f)
		{
			turnCompass.LookAt(lookingAt);
			((Component)this).transform.eulerAngles = new Vector3(((Component)this).transform.eulerAngles.x, turnCompass.eulerAngles.y, ((Component)this).transform.eulerAngles.z);
		}
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			base.syncMovementSpeed = 0.42f;
			animationAudio.playAudibleNoise = false;
			break;
		case 1:
			base.syncMovementSpeed = 0.13f;
			animationAudio.playAudibleNoise = false;
			if (StartOfRound.Instance.localPlayerController.HasLineOfSightToPosition(base.eye.position, 45f, 60, -1f, -1))
			{
				StartOfRound.Instance.localPlayerController.IncreaseFearLevelOverTime(0.4f, 0.5f);
			}
			break;
		case 2:
			base.syncMovementSpeed = 0.19f;
			animationAudio.playAudibleNoise = true;
			break;
		}
		if (((NetworkBehaviour)this).IsOwner && (base.currentBehaviourStateIndex == 1 || (setItemLocally && (!reachedHideSpot || everyoneOutside)) || (base.currentBehaviourStateIndex == 2 && (Object)(object)base.targetPlayer == (Object)null)))
		{
			tempTimer += Time.deltaTime;
		}
	}

	public override void DoAIInterval()
	{
		//IL_0288: Unknown result type (might be due to invalid IL or missing references)
		//IL_028e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0290: Unknown result type (might be due to invalid IL or missing references)
		//IL_0354: Unknown result type (might be due to invalid IL or missing references)
		//IL_0372: 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_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_089c: Unknown result type (might be due to invalid IL or missing references)
		//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_050e: Unknown result type (might be due to invalid IL or missing references)
		//IL_051e: Unknown result type (might be due to invalid IL or missing references)
		//IL_063a: Unknown result type (might be due to invalid IL or missing references)
		//IL_064c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0657: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).DoAIInterval();
		if (base.isEnemyDead || !base.ventAnimationFinished || StartOfRound.Instance.allPlayersDead)
		{
			return;
		}
		if (tempTimer == 99f)
		{
			ResetVariables(moveToAmbush: true);
			return;
		}
		base.useSecondaryAudiosOnAnimatedObjects = base.currentBehaviourStateIndex == 2;
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			if (setItemLocally)
			{
				if (roamingSearch.inProgress)
				{
					Log("STOP search // ROAM (0)");
					((EnemyAI)this).StopSearch(roamingSearch, true);
				}
				if (!reachedHideSpot)
				{
					if ((Object)(object)base.favoriteSpot != (Object)null)
					{
						LogAI("going to HIDE");
						((EnemyAI)this).SetDestinationToPosition(base.favoriteSpot.position, false);
						base.agent.speed = hideSpeed;
						if (tempTimer > maxHideSpotTime)
						{
							Log("TIMER: Unable to reach favoriteSpot, pausing", 3);
							OnReachHideSpot();
							tempTimer = 0f;
						}
						else if (Vector3.Distance(((Component)this).transform.position, base.favoriteSpot.position) < 1f)
						{
							Log("reached hide spot, starting sound");
							OnReachHideSpot();
						}
					}
					break;
				}
				if (PlayersOutside(onlyTargetPlayer: false, unlimitedAwareness: true))
				{
					if (tempTimer > 10f)
					{
						Log($"currentBehaviourStateIndex: {base.currentBehaviourStateIndex} | reachedHideSpot: {reachedHideSpot} | tempTimer: {tempTimer}");
						ResetVariables();
						break;
					}
				}
				else
				{
					tempTimer = 0f;
				}
				PlayerControllerB val = AnyPlayerHasLineOfSight();
				if ((Object)(object)val != (Object)null)
				{
					Log($"playerSeeing: {val} | reachedHideSpot: {reachedHideSpot} | targetPlayer & moving: {base.targetPlayer} | {base.movingTowardsTargetPlayer}");
					base.targetPlayer = val;
					GoIntoChase();
				}
				else
				{
					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)
					{
						Log("distance between Enemy and ClosestPlayer below 5, moving to chase");
						base.targetPlayer = closestPlayer;
						GoIntoChase();
					}
				}
			}
			else if (!roamingSearch.inProgress)
			{
				Log("START search // ROAM (0)");
				((EnemyAI)this).StartSearch(GetMidpoint(), roamingSearch);
				SetAnimation("WalkHunched");
				base.agent.speed = roamSpeed;
				ToggleAudioServerRpc(footstepsVolume, roamSpeed);
			}
			else
			{
				PlayerControllerB val2 = ((EnemyAI)this).CheckLineOfSightForPlayer(seeWidth, seeDistance, -1);
				if ((Object)(object)val2 != (Object)null)
				{
					Log("enemy spotted player, moving to state 1");
					MoveToAmbush(val2);
				}
			}
			break;
		case 1:
		{
			if (roamingSearch.inProgress)
			{
				Log("STOP search // ROAM (1)");
				((EnemyAI)this).StopSearch(roamingSearch, true);
			}
			if (base.inSpecialAnimation)
			{
				base.agent.speed = 0f;
				break;
			}
			PlayerControllerB val3 = AnyPlayerHasLineOfSight(null, ((Component)this).transform.position);
			if ((Object)(object)val3 != (Object)null)
			{
				DetectNewSighting(((Component)val3).transform.position, lookImmediately: true);
				Log($"playerSeeingInHide {val3}");
				base.agent.speed = (base.inSpecialAnimation ? 0f : chaseSpeed);
				if (!seenDuringThisAmbush && !enraged)
				{
					seenDuringThisAmbush = true;
					enraged = true;
					((EnemyAI)this).SetMovingTowardsTargetPlayer(base.targetPlayer);
					Log("CHASE PLAYER UNTIL OUT OF SIGHT!!!", 3);
					ToggleAudioServerRpc(runningVolume, base.agent.speed);
					base.agent.speed = 0f;
					SetAnimation("Intimidate");
					SetAnimation(null, sync: true, "WalkUprightSpeedMultiplier", 3f);
					break;
				}
			}
			else if (enraged)
			{
				Log("player lost sight during ambush chase");
				enraged = false;
				ToggleAudioServerRpc(0f, hideSpeed);
				SetAnimation(null, sync: true, "WalkUprightSpeedMultiplier", 5f);
			}
			if (!enraged && realAudio.volume > 0f)
			{
				ToggleAudioServerRpc(0f, hideSpeed);
			}
			if (attemptingItemRetrieve && !enraged)
			{
				if (!GetValidItemRetrieve())
				{
					Log("GetValidItemRetrieve() interrupted attemptingItemRetrieve!!! setting up for new item!", 1);
					SeverItemLinkServerRpc();
					attemptingItemRetrieve = false;
					break;
				}
				LogAI($"Trying to retrieve item {linkedItem}!");
				((EnemyAI)this).SetDestinationToPosition(((Component)linkedItem).transform.position, false);
				if (Vector3.Distance(holdItemParentObject.position, ((Component)linkedItem).transform.position) < 4f)
				{
					Log($"owner grabbing {linkedItem} #{((NetworkBehaviour)linkedItem).NetworkObjectId}", 1);
					GrabLinkedItem();
					attemptingItemRetrieve = false;
				}
			}
			if ((Object)(object)base.targetNode == (Object)null)
			{
				if (pickItemPositionCoroutine == null)
				{
					pickItemPositionCoroutine = ((MonoBehaviour)this).StartCoroutine(PickItemPosition());
				}
				base.agent.speed = hideSpeed;
				if (!attemptingItemRetrieve)
				{
					if ((Object)(object)fleeToWhileCalculating == (Object)null)
					{
						fleeToWhileCalculating = GetFleeToWhileCalculating(val3);
					}
					else if (!enraged)
					{
						LogAI("trying to hide out of sight");
						base.agent.speed = hideSpeed;
						((EnemyAI)this).SetDestinationToPosition(fleeToWhileCalculating.position, false);
					}
				}
			}
			else
			{
				if (enraged || attemptingItemRetrieve)
				{
					break;
				}
				if (!fakeAudioThisAmbush)
				{
					Log("spawn by: MODULO", 2);
					SpawnItemAndHide();
					break;
				}
				((EnemyAI)this).SetDestinationToPosition(base.targetNode.position, true);
				if (Vector3.Distance(((Component)this).transform.position, base.targetNode.position) < 1f)
				{
					Log("spawn by: DISTANCE");
					SpawnItemAndHide();
				}
				else if (tempTimer > maxItemSpawnTime)
				{
					Log("spawn by: TIMER", 3);
					SpawnItemAndHide();
				}
			}
			break;
		}
		case 2:
		{
			if (roamingSearch.inProgress)
			{
				Log("STOP search // ROAM (2)");
				((EnemyAI)this).StopSearch(roamingSearch, true);
			}
			PlayerControllerB validPlayerHoldingItem = GetValidPlayerHoldingItem();
			bool unlimitedAwareness = enraged || (Object)(object)validPlayerHoldingItem != (Object)null;
			if (PlayersOutside(onlyTargetPlayer: true, unlimitedAwareness) && tempTimer > 5f)
			{
				ResetVariables();
				break;
			}
			if (!base.inSpecialAnimation)
			{
				if (base.stunNormalizedTimer > 0f)
				{
					base.agent.speed = 0f;
					if (realAudio.volume != 0f)
					{
						ToggleAudioServerRpc(0f, 0f);
					}
					if ((Object)(object)base.stunnedByPlayer != (Object)null)
					{
						base.targetPlayer = base.stunnedByPlayer;
					}
					Log($"stunned: volume: {realAudio.volume} | targetPlayer {base.targetPlayer}");
					break;
				}
				base.agent.speed = (enraged ? enragedSpeed : chaseSpeed);
				if ((Object)(object)base.targetPlayer == (Object)null || ((Object)(object)validPlayerHoldingItem != (Object)null && (Object)(object)base.targetPlayer != (Object)(object)validPlayerHoldingItem))
				{
					if ((Object)(object)validPlayerHoldingItem != (Object)null)
					{
						base.targetPlayer = validPlayerHoldingItem;
					}
					else
					{
						base.targetPlayer = ((EnemyAI)this).GetClosestPlayer(true, false, false);
					}
				}
				else if (PlayersOutside(onlyTargetPlayer: true, unlimitedAwareness))
				{
					tempTimer = 0f;
					base.targetPlayer = null;
					base.movingTowardsTargetPlayer = false;
				}
				Log($"going to PLAYER ({base.targetPlayer})");
				ChaseNewPlayer(base.targetPlayer);
				if (realAudio.volume != runningVolume)
				{
					ToggleAudioServerRpc(runningVolume, base.agent.speed);
				}
			}
			else
			{
				base.agent.speed = 0f;
			}
			if ((Object)(object)base.targetPlayer == (Object)(object)StartOfRound.Instance.localPlayerController && Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < realAudio.maxDistance * 0.7f)
			{
				base.targetPlayer.JumpToFearLevel(0.7f, true);
			}
			break;
		}
		}
	}

	public override void FinishedCurrentSearchRoutine()
	{
		((EnemyAI)this).FinishedCurrentSearchRoutine();
		if (roamingSearch.inProgress)
		{
			Log("STOP search // ROAM (finished)");
			((EnemyAI)this).StopSearch(roamingSearch, true);
		}
	}

	private IEnumerator PickItemPosition()
	{
		Log("STARTING COROUTINE PickItemPosition()!!!", 3);
		LogAI($"allAINodes.Length = {base.allAINodes.Length}", 1);
		Vector3 startPos = ((Component)this).transform.position;
		List<GameObject> possibleHideNodes2 = new List<GameObject>();
		PlayerControllerB fromPlayer = (((Object)(object)base.targetPlayer != (Object)null) ? base.targetPlayer : ((EnemyAI)this).GetClosestPlayer(false, false, false));
		for (int a2 = 0; a2 < base.allAINodes.Length; a2++)
		{
			yield return null;
			GameObject val = base.allAINodes[a2];
			Light val2 = null;
			Color color = Color.red;
			LogAI($"A) checking node {val} {val.transform.position}");
			bool flag = false;
			float num = Vector3.Distance(startPos, val.transform.position);
			NavMeshPath val3 = new NavMeshPath();
			if (num > maxSearchDistance)
			{
				flag = true;
				color = Color.yellow;
				LogAI("nodeOutOfReach: maxSearchDistance");
			}
			else if (!base.agent.CalculatePath(val.transform.position, val3))
			{
				flag = true;
				color = Color.yellow;
				LogAI("nodeOutOfReach: CalculatePatch()");
			}
			else if (Vector3.Distance(val3.corners[val3.corners.Length - 1], RoundManager.Instance.GetNavMeshPosition(val.transform.position, RoundManager.Instance.navHit, 2.7f, -1)) > 1f)
			{
				flag = true;
				color = Color.yellow;
				LogAI("nodeOutOfReach: GetNavMeshPosition()");
			}
			LogAI($"ownDistance: {num} | outOfReach: {flag}", 1);
			float num2 = 999f;
			if (!flag)
			{
				for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
				{
					PlayerControllerB val4 = StartOfRound.Instance.allPlayerScripts[i];
					if ((Object)(object)val4 == (Object)null || !val4.isPlayerControlled || !val4.isInsideFactory)
					{
						continue;
					}
					LogAI($"checking player {val4}");
					if ((Object)(object)AnyPlayerHasLineOfSight(val4, val.transform.position) != (Object)null)
					{
						LogAI($"!!!Player can see node at {val.transform.position}, skipping!!!", 2);
						flag = true;
						continue;
					}
					float num3 = Vector3.Distance(((Component)val4).transform.position, val.transform.position);
					if ((Object)(object)val4 != (Object)(object)fromPlayer)
					{
						num3 *= (float)(StartOfRound.Instance.connectedPlayersAmount + 1);
					}
					else if (TargetPlayerCloserAlongPath(val3, fromPlayer))
					{
						LogAI($"!!!Node at {val.transform.position} at end of path too close to targetPlayer, skipping???", 2);
						flag = true;
						continue;
					}
					LogAI($"playerDistance = {num3}", 1);
					if (num3 < num2)
					{
						num2 = num3;
					}
				}
			}
			if (!flag && num < num2)
			{
				LogAI($"node eligible, adding (distance: {num} VS {num2})", 2);
				possibleHideNodes2.Add(val);
				color = Color.green;
			}
			if ((Object)(object)val2 != (Object)null)
			{
				val2.color = color;
			}
		}
		LogAI($"finished search [A] of allAINodes with Count {possibleHideNodes2.Count}", 3);
		if ((float)possibleHideNodes2.Count < minNodesNecessary)
		{
			Log($"counted enemy having access to too little of level (<{minNodesNecessary} = {(float)possibleHideNodes2.Count < minNodesNecessary}), going straight into chase", 3);
			GoIntoChase();
			yield break;
		}
		GameObject secondNode = null;
		possibleHideNodes2 = possibleHideNodes2.OrderBy((GameObject g) => Vector3.Distance(startPos, g.transform.position)).ToList();
		GameObject farthestNode = possibleHideNodes2[possibleHideNodes2.Count - 1];
		Log($"picked farthest node {farthestNode} at distance {Vector3.Distance(startPos, farthestNode.transform.position)}");
		for (int a2 = 0; a2 < possibleHideNodes2.Count; a2++)
		{
			yield return null;
			LogAI($"B) searching at [{a2}]", 1);
			GameObject val5 = possibleHideNodes2[a2];
			if ((Object)(object)val5 == (Object)(object)farthestNode)
			{
				continue;
			}
			float num4 = Vector3.Distance(val5.transform.position, farthestNode.transform.position);
			LogAI($"distanceFromFarthestNode = {num4}");
			if (num4 < minDistanceBetweenFarawayNodes || num4 > maxDistanceBetweenFarawayNodes)
			{
				LogAI("too far");
				continue;
			}
			LogAI($"calculating for secondNode {val5} {val5.transform.position} || secondNode == null? {(Object)(object)secondNode == (Object)null}");
			bool flag2 = false;
			float num5 = Mathf.Abs(farthestNode.transform.position.y - val5.transform.position.y) / verticalOffsetDropoffDivider;
			LogAI($"verticalOffset = {num5}");
			if (num5 + num4 > maxDistanceBetweenFarawayNodes)
			{
				LogAI("VerticalOffsetMode.DecreaseWithDivider", 2);
				flag2 = true;
			}
			if (!flag2 && !Physics.Linecast(val5.transform.position + Vector3.up * 0.5f, farthestNode.transform.position + Vector3.up * 1f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				LogAI("no colliders in Linecast between farthest node and this checked second node, meaning hasLOS, skipping secondNode", 2);
				flag2 = true;
			}
			if (!flag2 || (Object)(object)secondNode == (Object)null)
			{
				secondNode = val5;
				LogAI($"picked new secondNode {secondNode.transform.position}", 1);
			}
		}
		LogAI($"finished search [B] with secondNode: {secondNode}");
		if ((Object)(object)secondNode == (Object)null)
		{
			Log("failed to find targetNode, returning ChooseFarthestNodeFromPosition", 3);
			secondNode = ((Component)((EnemyAI)this).ChooseFarthestNodeFromPosition(startPos, true, 0, false, (int)maxSearchDistance, 0)).gameObject;
		}
		else
		{
			Log($"picked second node {secondNode} at distance {Vector3.Distance(startPos, secondNode.transform.position)} and distance from farthest node: {Vector3.Distance(farthestNode.transform.position, secondNode.transform.position)}");
		}
		base.targetNode = secondNode.transform;
		Log($"set targetNode to (second): {base.targetNode.position}", 3);
		base.favoriteSpot = farthestNode.transform;
		Log($"favoriteSpot (farthest): {base.favoriteSpot.position}", 2);
		pickItemPositionCoroutine = null;
	}

	private void StopPickItemPositionCoroutine()
	{
		if (pickItemPositionCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(pickItemPositionCoroutine);
			pickItemPositionCoroutine = null;
		}
	}

	private Transform GetFleeToWhileCalculating(PlayerControllerB fleeFrom = null)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		Log("Getting fleeToWhileCalculating!!!", 3);
		Transform val = ((Component)this).transform;
		Transform val2 = ((EnemyAI)this).ChooseFarthestNodeFromPosition(((Component)this).transform.position, false, 0, false, (int)maxSearchDistance, 0);
		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, 0);
				LogAI($"getting new farthestNode {val2}");
			}
			else
			{
				LogAI($"managed to finish first path to farthestNode {val2}", 1);
			}
			val = val2;
		}
		else
		{
			Log("failed to get toReturn!", 3);
		}
		Log($"sending toReturn {val} fleeToWhileCalculating {val.position}", 1);
		return val;
	}

	private Vector3 GetMidpoint(Vector3 startPos = default(Vector3))
	{
		//IL_0012: 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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0167: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		Log("Getting midpoint!!!", 3);
		Vector3 val = ((Component)this).transform.position;
		Vector3 val2 = Vector3.zero;
		Vector3 zero = Vector3.zero;
		PlayerControllerB val3 = null;
		if (startPos == default(Vector3))
		{
			Log("calculating from nearest player or entrance", 1);
			val3 = (((Object)(object)base.targetPlayer != (Object)null) ? base.targetPlayer : ((EnemyAI)this).GetClosestPlayer(false, false, false));
			if ((Object)(object)val3 != (Object)null)
			{
				val2 = ((Component)val3).transform.position;
			}
			else
			{
				Vector3 val4 = RoundManager.FindMainEntrancePosition(false, false);
				Log($"had to search for entrance and found {val4}");
				if (val4 != Vector3.zero)
				{
					val2 = val4;
				}
			}
		}
		else
		{
			val2 = startPos;
		}
		if (val2 == Vector3.zero)
		{
			Log("point to calculate midpoint from is zero, returning own transform");
			return val;
		}
		zero = ((EnemyAI)this).ChooseClosestNodeToPosition(Vector3.Lerp(((Component)this).transform.position, val2, lerpMidpoint), false, 0).position;
		if (!base.agent.CalculatePath(zero, base.path1))
		{
			LogAI("CalculatePath()", 2);
		}
		else if (Vector3.Distance(base.path1.corners[base.path1.corners.Length - 1], RoundManager.Instance.GetNavMeshPosition(zero, RoundManager.Instance.navHit, 2.7f, -1)) > 1f)
		{
			LogAI("GetNavMeshPosition()", 2);
		}
		else
		{
			val = zero;
			Log($"success! player: {val3} | calculateMidpointFrom {val2} | toReturn {val}", 2);
		}
		Log($"GetMidpoint() sending toReturn {val}", 1);
		return val;
	}

	private bool TargetPlayerCloserAlongPath(NavMeshPath path, PlayerControllerB fleeFrom = null)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00a2: 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);
			if ((Object)(object)fleeFrom == (Object)null)
			{
				return false;
			}
		}
		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 < maxPlayerDistanceToPath)
			{
				LogAI($"player {num2} closer than I {num} to corner [{i}] {val}", 2);
				return true;
			}
		}
		return false;
	}

	private PlayerControllerB AnyPlayerHasLineOfSight(PlayerControllerB checkFromPlayer = null, 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_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (pos == default(Vector3))
		{
			pos = base.eye.position;
		}
		if ((Object)(object)checkFromPlayer == (Object)null)
		{
			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, -1))
				{
					return val;
				}
			}
		}
		else if (checkFromPlayer.isPlayerControlled && checkFromPlayer.HasLineOfSightToPosition(pos, 50f, 40, -1f, -1))
		{
			return checkFromPlayer;
		}
		return null;
	}

	private PlayerControllerB GetValidPlayerHoldingItem()
	{
		if ((Object)(object)linkedItem == (Object)null)
		{
			return null;
		}
		if ((Object)(object)((GrabbableObject)linkedItem).playerHeldBy == (Object)null)
		{
			return null;
		}
		if (!((GrabbableObject)linkedItem).playerHeldBy.isPlayerControlled)
		{
			return null;
		}
		if (!((GrabbableObject)linkedItem).playerHeldBy.isInsideFactory)
		{
			return null;
		}
		return ((GrabbableObject)linkedItem).playerHeldBy;
	}

	private bool PlayersOutside(bool onlyTargetPlayer = false, bool unlimitedAwareness = false, float overrideAwarenessDistance = -1f)
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		if (overrideAwarenessDistance == -1f)
		{
			overrideAwarenessDistance = awarenessDistancePerState[base.currentBehaviourStateIndex % awarenessDistancePerState.Length];
		}
		if (onlyTargetPlayer)
		{
			if ((Object)(object)base.targetPlayer != (Object)null && base.targetPlayer.isPlayerControlled && base.targetPlayer.isInsideFactory && (unlimitedAwareness || Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < overrideAwarenessDistance))
			{
				everyoneOutside = false;
				return everyoneOutside;
			}
		}
		else
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!((Object)(object)val == (Object)null) && val.isPlayerControlled && val.isInsideFactory && (unlimitedAwareness || Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position) < overrideAwarenessDistance))
				{
					everyoneOutside = false;
					return everyoneOutside;
				}
			}
		}
		everyoneOutside = true;
		return everyoneOutside;
	}

	private void ResetVariables(bool moveToAmbush = false)
	{
		if (!((NetworkBehaviour)this).IsServer)
		{
			Log("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", 2);
			((EnemyAI)this).ChangeOwnershipOfEnemy(StartOfRound.Instance.allPlayerScripts[0].actualClientId);
			return;
		}
		Log("RESET!!!", 2);
		BeatAudioItem[] array = Object.FindObjectsByType<BeatAudioItem>((FindObjectsSortMode)0);
		foreach (BeatAudioItem obj in array)
		{
			obj.ToggleFakeAudio(setTo: false, sync: true);
			obj.ToggleAlarm(setTo: false, sync: true);
		}
		setItemLocally = false;
		reachedHideSpot = false;
		base.movingTowardsTargetPlayer = false;
		base.favoriteSpot = null;
		base.targetNode = null;
		tempTimer = 0f;
		fleeToWhileCalculating = null;
		pickItemPositionCoroutine = null;
		seenDuringThisAmbush = false;
		enraged = false;
		attemptingItemRetrieve = false;
		Log("set everything back", 1);
		if (moveToAmbush)
		{
			Log("moving to ambush");
			seenDuringThisAmbush = true;
			MoveToAmbush(base.targetPlayer);
		}
		else
		{
			base.targetPlayer = null;
			if (base.currentBehaviourStateIndex != 0)
			{
				Log("exiting chase");
				((EnemyAI)this).SwitchToBehaviourState(0);
			}
		}
		Log("Successfully reached end of ResetOnEveryoneOutside()", 1);
	}

	private void DetectNewSighting(Vector3 lookPos, bool lookImmediately = false)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		timeLastLookingAt = Time.realtimeSinceStartup;
		lookingAt = lookPos;
		if (lookImmediately)
		{
			turnCompass.LookAt(lookPos);
			((Component)this).transform.eulerAngles = new Vector3(((Component)this).transform.eulerAngles.x, turnCompass.eulerAngles.y, ((Component)this).transform.eulerAngles.z);
		}
	}

	private void MoveToAmbush(PlayerControllerB setTargetPlayer = null)
	{
		if (((NetworkBehaviour)this).IsServer && base.currentBehaviourStateIndex != 1 && !setItemLocally && !reachedHideSpot)
		{
			timesStartedAmbush++;
			fakeAudioThisAmbush = timesStartedAmbush % 2 == 1;
			Log($"timesStartedAmbush: {timesStartedAmbush} || modulo: {timesStartedAmbush % 2} || fakeAudioThisAmbush: {fakeAudioThisAmbush}");
			base.agent.speed = 0f;
			base.targetNode = null;
			tempTimer = 0f;
			if ((Object)(object)setTargetPlayer != (Object)null)
			{
				base.targetPlayer = setTargetPlayer;
				Log($"started ambush with targetPlayer {base.targetPlayer}");
			}
			SetAnimation("WalkUpright", sync: true, "WalkUprightSpeedMultiplier", 5f);
			if (roamingSearch.inProgress)
			{
				Log("STOP search // ROAM (ambush)");
				((EnemyAI)this).StopSearch(roamingSearch, true);
			}
			attemptingItemRetrieve = GetValidItemRetrieve(calculatePath: true);
			if (!attemptingItemRetrieve)
			{
				Log($"unlinking linkedItem {linkedItem} due to invalid attemptingItemRetrieve {attemptingItemRetrieve}");
				SeverItemLinkServerRpc();
			}
			((EnemyAI)this).SwitchToBehaviourState(1);
			ToggleAudioServerRpc(0f, hideSpeed);
		}
	}

	public void GoIntoChase(bool enrage = false)
	{
		if (((NetworkBehaviour)this).IsServer && base.currentBehaviourStateIndex != 2)
		{
			SyncHPAmbushStartServerRpc(base.enemyHP);
			if ((Object)(object)linkedItem != (Object)null && linkedItem.itemAnimator.GetBool("Footsteps"))
			{
				linkedItem.itemAnimator.SetBool("Footsteps", false);
			}
			enraged = enrage;
			StopPickItemPositionCoroutine();
			((EnemyAI)this).SwitchToBehaviourState(2);
			SetAnimation("WalkUpright", sync: true, "WalkUprightSpeedMultiplier", 3f);
		}
	}

	private void SpawnItemAndHide()
	{
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		if (!((NetworkBehaviour)this).IsServer)
		{
			return;
		}
		setItemLocally = true;
		if (fakeAudioThisAmbush)
		{
			if ((Object)(object)linkedItem == (Object)null || (Object)(object)((GrabbableObject)linkedItem).parentObject != (Object)(object)holdItemParentObject)
			{
				SpawnItemServerRpc(holdItemAfterSpawn: false);
			}
			else
			{
				Log($"owner dropping {linkedItem} #{((NetworkBehaviour)linkedItem).NetworkObjectId}", 1);
				DropLinkedItem();
			}
		}
		reachedHideSpot = false;
		tempTimer = 0f;
		if ((Object)(object)base.favoriteSpot == (Object)null)
		{
			Log("ChooseFarthestNodeFromPosition()!!", 3);
			base.favoriteSpot = ((EnemyAI)this).ChooseFarthestNodeFromPosition(base.targetNode.position, true, 0, true, (int)maxDistanceBetweenFarawayNodes, 0);
		}
		Log("spawned item, going back to state 0");
		((EnemyAI)this).SwitchToBehaviourState(0);
	}

	private void OnReachHideSpot()
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		if (((NetworkBehaviour)this).IsServer)
		{
			reachedHideSpot = true;
			base.movingTowardsTargetPlayer = false;
			tempTimer = 0f;
			((Component)this).transform.Rotate(new Vector3(0f, 180f, 0f), (Space)1);
			if (fakeAudioThisAmbush && (Object)(object)linkedItem != (Object)null)
			{
				Log("should call Idle here");
				SetAnimation("Idle");
				linkedItem.ToggleFakeAudio(setTo: true, sync: true);
			}
			else
			{
				Log($"fakeAudioThisAmbush: {fakeAudioThisAmbush} | linkedItem: {linkedItem}");
				SetAnimation("Ambush");
				ToggleAudioServerRpc(footstepsVolume);
			}
		}
	}

	private bool GetValidItemRetrieve(bool calculatePath = false)
	{
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)linkedItem == (Object)null)
		{
			LogAI("retrieve False: null");
			return false;
		}
		if (!((GrabbableObject)linkedItem).hasBeenHeld)
		{
			LogAI("retrieve True: !hasBeenHeld");
			return true;
		}
		if ((Object)(object)((GrabbableObject)linkedItem).parentObject == (Object)(object)holdItemParentObject)
		{
			LogAI("retrieve True: holding");
			return true;
		}
		if (!((GrabbableObject)linkedItem).isInFactory || (Object)(object)((GrabbableObject)linkedItem).playerHeldBy != (Object)null || ((GrabbableObject)linkedItem).deactivated || !((GrabbableObject)linkedItem).grabbable || !((GrabbableObject)linkedItem).grabbableToEnemies)
		{
			LogAI("retrieve False: misc");
			return false;
		}
		if (calculatePath)
		{
			Log("GetValidItemRetrieve(): trying to calculate path");
			if (!base.agent.CalculatePath(((Component)linkedItem).transform.position, base.path1))
			{
				Log("CalculatePath()", 2);
				return false;
			}
			if (Vector3.Distance(base.path1.corners[base.path1.corners.Length - 1], RoundManager.Instance.GetNavMeshPosition(((Component)linkedItem).transform.position, RoundManager.Instance.navHit, 2.7f, -1)) > 1f)
			{
				Log("GetNavMeshPosition()", 2);
				return false;
			}
			Log("successfully going for item retrieve");
		}
		LogAI("retrieve True");
		return true;
	}

	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_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).DetectNoise(noisePosition, noiseLoudness, timesPlayedInOneSpot, noiseID);
		if (noiseID != 546 && noiseID != 202251)
		{
			if (!((NetworkBehaviour)this).IsOwner && noiseID == 75 && Time.realtimeSinceStartup - timeLastVoiceChatLocalPlayer > 3f)
			{
				Log($"non-owner detected noise with ID {noiseID}, passing to server");
				timeLastVoiceChatLocalPlayer = Time.realtimeSinceStartup;
				PassNoiseToOwnerServerRpc(noisePosition, noiseLoudness);
			}
			else if (OnDetectNoiseValid())
			{
				DetectNoiseOwner(noisePosition, noiseLoudness, noiseID);
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void PassNoiseToOwnerServerRpc(Vector3 noisePosition, float noiseLoudness)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2430531890u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref noisePosition);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref noiseLoudness, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2430531890u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PassNoiseToOwnerClientRpc(noisePosition, noiseLoudness);
			}
		}
	}

	[ClientRpc]
	private void PassNoiseToOwnerClientRpc(Vector3 noisePosition, float noiseLoudness)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2592962014u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref noisePosition);
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref noiseLoudness, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2592962014u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsOwner)
			{
				DetectNoiseOwner(noisePosition, noiseLoudness);
			}
		}
	}

	private void DetectNoiseOwner(Vector3 noisePosition, float noiseLoudness, int noiseID = 0)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		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;
		LogAI($"(ID: {noiseID}) // {num} + {num2} = {num3}");
		if (num3 >= noiseLookThreshold)
		{
			Log("looking at");
			DetectNewSighting(noisePosition);
		}
		if (num3 >= noiseThreshold)
		{
			Log("passed threshold");
			MoveToAmbush();
		}
	}

	private bool OnDetectNoiseValid()
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			LogAI("DetectNoise(): not owner");
			return false;
		}
		if (!base.ventAnimationFinished)
		{
			LogAI("DetectNoise(): in vent animation");
			return false;
		}
		if (base.isEnemyDead)
		{
			LogAI("DetectNoise(): dead");
			return false;
		}
		if (base.inSpecialAnimation)
		{
			LogAI("DetectNoise(): inSpecialAnimation");
			return false;
		}
		if (base.stunNormalizedTimer > 0f)
		{
			LogAI("DetectNoise(): stunNormalizedTimer");
			return false;
		}
		if (base.currentBehaviourStateIndex == 0 && setItemLocally && !reachedHideSpot)
		{
			LogAI("DetectNoise(): in 0 and moving to hideSpot");
			return false;
		}
		if (base.currentBehaviourStateIndex == 1 && (attemptingItemRetrieve || enraged))
		{
			LogAI("DetectNoise(): in 1 and focused on item or player");
			return false;
		}
		if (base.currentBehaviourStateIndex == 2 && (Object)(object)base.targetPlayer != (Object)null)
		{
			LogAI("DetectNoise(): in 2 and chasing player");
			return false;
		}
		if (PlayersOutside())
		{
			LogAI("DetectNoise(): everyone outside awareness radius");
			return false;
		}
		return true;
	}

	public override void SetEnemyStunned(bool setToStunned, float setToStunTime = 1f, PlayerControllerB setStunnedByPlayer = null)
	{
		((EnemyAI)this).SetEnemyStunned(setToStunned, setToStunTime, setStunnedByPlayer);
		GoIntoChase();
	}

	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)
		{
			base.targetPlayer = playerWhoHit;
			GoIntoChase(enrage: true);
			PlaySFX(intimidateSFX, audibleNoise: true, isAudience: false, sync: false);
			base.enemyHP -= force;
			Log($"HP: {base.enemyHP}");
			if (base.enemyHP <= 0)
			{
				((EnemyAI)this).KillEnemyOnOwnerClient(false);
			}
		}
	}

	public override void KillEnemy(bool destroy = false)
	{
		((EnemyAI)this).KillEnemy(destroy);
		StopPickItemPositionCoroutine();
	}

	public override void OnCollideWithPlayer(Collider other)
	{
		if (Time.realtimeSinceStartup - timeLastCollisionLocalPlayer > collisionCooldown)
		{
			PlayerControllerB val = ((EnemyAI)this).MeetsStandardPlayerCollisionConditions(other, base.inSpecialAnimation, false);
			if ((Object)(object)val != (Object)null && (base.currentBehaviourStateIndex != 2 || (Object)(object)val == (Object)(object)base.targetPlayer))
			{
				((EnemyAI)this).OnCollideWithPlayer(other);
				timeLastCollisionLocalPlayer = Time.realtimeSinceStartup;
				PerformPlayerCollision(val);
			}
		}
	}

	private void PerformPlayerCollision(PlayerControllerB localPlayer)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		Vector3 zero = Vector3.zero;
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			zero = base.eye.forward * 3f + Vector3.up * 15f;
			localPlayer.DamagePlayer(10, true, true, (CauseOfDeath)12, 0, false, zero);
			if (!localPlayer.isPlayerDead)
			{
				localPlayer.externalForceAutoFade += zero;
			}
			if (((NetworkBehaviour)this).IsOwner)
			{
				if (!setItemLocally)
				{
					MoveToAmbush(localPlayer);
				}
			}
			else
			{
				CollisionLogicServerRpc();
			}
			break;
		case 1:
			zero = base.eye.forward * 5f + Vector3.up * 25f;
			localPlayer.DamagePlayer(20, true, true, (CauseOfDeath)12, 0, false, zero);
			if (!localPlayer.isPlayerDead)
			{
				localPlayer.externalForceAutoFade += zero;
			}
			if (((NetworkBehaviour)this).IsOwner)
			{
				enraged = false;
			}
			else
			{
				CollisionLogicServerRpc();
			}
			break;
		case 2:
		{
			bool doPreAttackAnimation = !enraged || localPlayer.isCrouching;
			((MonoBehaviour)this).StartCoroutine(AttackPlayer(localPlayer, doPreAttackAnimation));
			CollisionLogicServerRpc((int)localPlayer.playerClientId, doPreAttackAnimation);
			break;
		}
		}
	}

	private IEnumerator AttackPlayer(PlayerControllerB player, bool doPreAttackAnimation)
	{
		Log("starting collision coroutine!!", 1);
		base.agent.speed = 0f;
		realAudio.volume = 0f;
		base.inSpecialAnimationWithPlayer = player;
		if (doPreAttackAnimation)
		{
			PlaySFX(caughtSFX, audibleNoise: false, isAudience: false, sync: false);
			SetAnimation("AttackStart", sync: false);
			player.inAnimationWithEnemy = (EnemyAI)(object)this;
			player.inSpecialInteractAnimation = true;
			player.isCrouching = false;
			player.playerBodyAnimator.SetBool("crouching", false);
			RoundManager.Instance.tempTransform.position = ((Component)player).transform.position;
			RoundManager.Instance.tempTransform.LookAt(((Component)this).transform.position);
			Quaternion startingPlayerRot = ((Component)player).transform.rotation;
			Quaternion targetPlayerRot = RoundManager.Instance.tempTransform.rotation;
			for (int i = 0; i < turnPlayerIterations; i++)
			{
				((Component)player).transform.rotation = Quaternion.Lerp(startingPlayerRot, targetPlayerRot, (float)i / (float)turnPlayerIterations);
				((Component)player).transform.eulerAngles = new Vector3(0f, ((Component)player).transform.eulerAngles.y, 0f);
				yield return null;
			}
		}
		if ((Object)(object)linkedItem != (Object)null)
		{
			linkedItem.ToggleFakeAudio(setTo: false);
			if ((Object)(object)((GrabbableObject)linkedItem).playerHeldBy == (Object)null)
			{
				linkedItem.ToggleAlarm(setTo: false);
			}
		}
		player.inSpecialInteractAnimation = false;
		player.inAnimationWithEnemy = null;
		base.inSpecialAnimationWithPlayer = null;
		yield return null;
		player.averageVelocity = 0f;
		player.velocityLastFrame = Vector3.zero;
		SetAnimation("Attack", sync: false);
		PlaySFX(reelSFX, audibleNoise: false, isAudience: false, sync: false);
		yield return (object)new WaitForSeconds(0.6f);
		base.creatureSFX.Stop();
		Vector3 position = player.playerEye.position;
		bool hasKilled = true;
		Bounds bounds = killBox.bounds;
		if (((Bounds)(ref bounds)).Contains(position))
		{
			Log("KillPlayer: playerEye in killBox");
			player.KillPlayer(Vector3.zero, true, (CauseOfDeath)6, 8, default(Vector3), false);
			PlaySFX(punchHitSFX);
		}
		else
		{
			bounds = killBox.bounds;
			if (((Bounds)(ref bounds)).Contains(new Vector3(position.x, ((Component)killBox).transform.position.y, position.z)))
			{
				float y = position.y;
				float y2 = ((Component)killBox).transform.position.y;
				bounds = killBox.bounds;
				if (y > y2 - ((Bounds)(ref bounds)).extents.y && position.y < ((Component)killBox).transform.position.y + 3f)
				{
					Log("KillPlayer: playerEye in killBox.x && killBox.z, playerEye > killBox.y - 0.5 && playereye < killBox.y + 3");
					player.KillPlayer(Vector3.zero, true, (CauseOfDeath)6, 7, default(Vector3), false);
					PlaySFX(punchHitSFX);
					goto IL_0438;
				}
			}
			Log("KillPlayer: fail");
			hasKilled = false;
			PlaySFX(punchMissSFX);
		}
		goto IL_0438;
		IL_0438:
		yield return (object)new WaitForSeconds(0.6f);
		if (hasKilled)
		{
			PlaySFX(successCheer, audibleNoise: false, isAudience: true);
		}
		CheckEnragedAfterAttack();
	}

	private IEnumerator AttackPlayerNonLocal(PlayerControllerB player, bool doPreAttackAnimation)
	{
		Log("starting collision coroutine NON LOCAL!!!", 2);
		base.agent.speed = 0f;
		realAudio.volume = 0f;
		base.inSpecialAnimationWithPlayer = player;
		if (doPreAttackAnimation)
		{
			PlaySFX(caughtSFX, audibleNoise: false, isAudience: false, sync: false);
			SetAnimation("AttackStart", sync: false);
			player.inAnimationWithEnemy = (EnemyAI)(object)this;
			player.inSpecialInteractAnimation = true;
			for (int i = 0; i < turnPlayerIterations; i++)
			{
				yield return null;
			}
		}
		if ((Object)(object)linkedItem != (Object)null)
		{
			linkedItem.ToggleFakeAudio(setTo: false);
			if ((Object)(object)((GrabbableObject)linkedItem).playerHeldBy == (Object)null)
			{
				linkedItem.ToggleAlarm(setTo: false);
			}
		}
		player.inSpecialInteractAnimation = false;
		player.inAnimationWithEnemy = null;
		base.inSpecialAnimationWithPlayer = null;
		yield return null;
		player.averageVelocity = 0f;
		player.velocityLastFrame = Vector3.zero;
		SetAnimation("Attack", sync: false);
		PlaySFX(reelSFX, audibleNoise: false, isAudience: false, sync: false);
		yield return (object)new WaitForSeconds(1.2f);
		CheckEnragedAfterAttack();
	}

	private void CheckEnragedAfterAttack()
	{
		enraged = base.enemyHP < hpAmbushStart || (Object)(object)GetValidPlayerHoldingItem() != (Object)null;
		Log($"enraged: {enraged}");
		if (enraged)
		{
			return;
		}
		if (((NetworkBehaviour)this).IsServer)
		{
			Log("SERVER READYING UP TO RESET VARIABLES AND MOVE TO AMBUSH!!", 1);
			if (((NetworkBehaviour)this).IsOwner)
			{
				ResetVariables(moveToAmbush: true);
			}
			else
			{
				tempTimer = 99f;
			}
		}
		else if (((NetworkBehaviour)this).IsOwner)
		{
			Log("OWNER READYING UP TO GIVE CONTROL BACK TO SERVER!!", 1);
			((EnemyAI)this).ChangeOwnershipOfEnemy(StartOfRound.Instance.allPlayerScripts[0].actualClientId);
		}
	}

	public void SetEnemyInSpecialAnimation(bool setInSpecialAnimationTo)
	{
		base.inSpecialAnimation = setInSpecialAnimationTo;
		LogAI($"inSpecialAnimation = {base.inSpecialAnimation}");
	}

	[ServerRpc(RequireOwnership = false)]
	private void CollisionLogicServerRpc(int sentBy = -1, bool doPreAttackAnimation = true)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3087885578u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref doPreAttackAnimation, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3087885578u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				CollisionLogicClientRpc(sentBy, doPreAttackAnimation);
			}
		}
	}

	[ClientRpc]
	private void CollisionLogicClientRpc(int sentBy = -1, bool doPreAttackAnimation = true)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2055034921u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref doPreAttackAnimation, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2055034921u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		if (sentBy != -1 && sentBy == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
		{
			return;
		}
		Log($"CollisionLogicClientRpc(): currentBehaviourStateIndex {base.currentBehaviourStateIndex} | sentBy {sentBy}");
		sentBy = (int)GetValidPlayer(sentBy).playerClientId;
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			if (((NetworkBehaviour)this).IsOwner && !setItemLocally)
			{
				MoveToAmbush(StartOfRound.Instance.allPlayerScripts[sentBy]);
			}
			break;
		case 1:
			if (((NetworkBehaviour)this).IsOwner)
			{
				enraged = false;
			}
			break;
		case 2:
			((MonoBehaviour)this).StartCoroutine(AttackPlayerNonLocal(StartOfRound.Instance.allPlayerScripts[sentBy], doPreAttackAnimation));
			break;
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SpawnItemServerRpc(bool holdItemAfterSpawn)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: 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(1509949983u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref holdItemAfterSpawn, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1509949983u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		GameObject val3 = Object.Instantiate<GameObject>(itemToSpawn.spawnPrefab, ((Component)this).transform.position + Vector3.up * 2f, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
		NetworkObject component = val3.GetComponent<NetworkObject>();
		component.Spawn(false);
		if (holdItemAfterSpawn)
		{
			BeatAudioItem component2 = val3.GetComponent<BeatAudioItem>();
			if ((Object)(object)component2 == (Object)null)
			{
				Log("host failed to get itemScript in SpawnItemServerRpc()", 3);
				return;
			}
			GrabLinkedItemLocal(component2);
			SpawnItemClientRpc(NetworkObjectReference.op_Implicit(component));
		}
	}

	[ClientRpc]
	private void SpawnItemClientRpc(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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4046887583u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4046887583u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsServer)
			{
				((MonoBehaviour)this).StartCoroutine(WaitForSpawnedItem(itemNOR));
			}
		}
	}

	private IEnumerator WaitForSpawnedItem(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)
		{
			Log("failed to get netObj on client!", 3);
			yield break;
		}
		yield return (object)new WaitForEndOfFrame();
		BeatAudioItem component = ((Component)netObj).gameObject.GetComponent<BeatAudioItem>();
		if ((Object)(object)component == (Object)null)
		{
			Log("client failed to get itemScript in WaitForSpawnedItem()", 3);
		}
		else
		{
			GrabLinkedItemLocal(component);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void ToggleAudioServerRpc(float newVolume, 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_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(750633870u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref newVolume, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref agentSpeed, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 750633870u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				ToggleAudioClientRpc(newVolume, agentSpeed);
			}
		}
	}

	[ClientRpc]
	private void ToggleAudioClientRpc(float newVolume, 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_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2000840382u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref newVolume, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref agentSpeed, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2000840382u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (agentSpeed == -1f)
			{
				agentSpeed = base.agent.speed;
			}
			base.agent.speed = agentSpeed;
			if (newVolume == -1f)
			{
				newVolume = realAudio.volume;
			}
			realAudio.volume = newVolume;
		}
	}

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

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

	public void ChaseNewPlayer(PlayerControllerB player)
	{
		if (!((Object)(object)player == (Object)null) && ((NetworkBehaviour)this).IsOwner && (!base.movingTowardsTargetPlayer || ((NetworkBehaviour)player).OwnerClientId != ((NetworkBehaviour)this).NetworkObject.OwnerClientId))
		{
			Log("started new chase on owner, should sync AI-Calculation to chased player " + player.playerUsername, 2);
			((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)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(118970262u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 118970262u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				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)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(221236223u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 221236223u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				ChaseNewPlayerOnLocalClient(StartOfRound.Instance.allPlayerScripts[playerID]);
			}
		}
	}

	private void ChaseNewPlayerOnLocalClient(PlayerControllerB playerToChase)
	{
		((EnemyAI)this).SetMovingTowardsTargetPlayer(playerToChase);
	}

	private PlayerControllerB GetValidPlayer(int playerID, bool getClosestPlayer = false)
	{
		if (playerID >= 0 && playerID < StartOfRound.Instance.allPlayerScripts.Length)
		{
			return StartOfRound.Instance.allPlayerScripts[playerID];
		}
		if (getClosestPlayer)
		{
			PlayerControllerB closestPlayer = ((EnemyAI)this).GetClosestPlayer(false, false, false);
			if ((Object)(object)closestPlayer != (Object)null)
			{
				return closestPlayer;
			}
		}
		return StartOfRound.Instance.allPlayerScripts[0];
	}

	private void SetAnimation(string animString = null, bool sync = true, string paramString = null, float paramFloat = 1f)
	{
		SetAnimationLocal(animString, paramString, paramFloat);
		if (sync)
		{
			SetAnimationServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, animString, paramString, paramFloat);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SetAnimationServerRpc(int sentBy, string animString, string paramString, float paramFloat)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: 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_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: 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_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: 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(3422828450u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			bool flag = animString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(animString, false);
			}
			bool flag2 = paramString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
			if (flag2)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(paramString, false);
			}
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref paramFloat, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3422828450u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			SetAnimationClientRpc(sentBy, animString, paramString, paramFloat);
		}
	}

	[ClientRpc]
	private void SetAnimationClientRpc(int sentBy, string animString, string paramString, float paramFloat)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: 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_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: 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_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4043217162u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			bool flag = animString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(animString, false);
			}
			bool flag2 = paramString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
			if (flag2)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(paramString, false);
			}
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref paramFloat, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4043217162u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				SetAnimationLocal(animString, paramString, paramFloat);
			}
		}
	}

	private void SetAnimationLocal(string animString, string paramString, float paramFloat)
	{
		if (!string.IsNullOrEmpty(animString))
		{
			base.creatureAnimator.SetTrigger(animString);
		}
		if (!string.IsNullOrEmpty(paramString))
		{
			base.creatureAnimator.SetFloat(paramString, paramFloat);
		}
	}

	public void PlaySFX(AudioClip clipToPlay = null, bool audibleNoise = true, bool isAudience = false, bool sync = true, int clipCase = -1)
	{
		if ((Object)(object)clipToPlay == (Object)null)
		{
			clipToPlay = GetClipOfInt(clipCase);
		}
		PlaySFXLocal(clipToPlay, audibleNoise, isAudience);
		if (sync)
		{
			PlaySFXServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, GetIntOfClip(clipToPlay), audibleNoise, isAudience);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void PlaySFXServerRpc(int sentBy, int clipCase, bool audible, bool crowd)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		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(3943627448u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				BytePacker.WriteValueBitPacked(val2, clipCase);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref audible, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref crowd, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3943627448u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlaySFXClientRpc(sentBy, clipCase, audible, crowd);
			}
		}
	}

	[ClientRpc]
	private void PlaySFXClientRpc(int sentBy, int clipCase, bool audible, bool crowd)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2248627755u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			BytePacker.WriteValueBitPacked(val2, clipCase);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref audible, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref crowd, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2248627755u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				PlaySFXLocal(GetClipOfInt(clipCase), audible, crowd);
			}
		}
	}

	private void PlaySFXLocal(AudioClip clipToPlay, bool audibleNoise, bool isAudience)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		AudioSource creatureSFX = base.creatureSFX;
		if (isAudience)
		{
			creatureSFX = beatAudience;
			((Component)beatAudience).transform.position = base.eye.position;
		}
		creatureSFX.PlayOneShot(clipToPlay);
		WalkieTalkie.TransmitOneShotAudio(creatureSFX, clipToPlay, 1f);
		if (audibleNoise)
		{
			RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 20f, 0.5f, 0, false, 202251);
		}
	}

	private AudioClip GetClipOfInt(int ofInt)
	{
		return (AudioClip)(ofInt switch
		{
			1 => punchHitSFX, 
			2 => punchMissSFX, 
			3 => reelSFX, 
			4 => caughtSFX, 
			5 => successCheer, 
			_ => intimidateSFX, 
		});
	}

	private int GetIntOfClip(AudioClip ofClip)
	{
		if ((Object)(object)ofClip == (Object)(object)punchHitSFX)
		{
			return 1;
		}
		if ((Object)(object)ofClip == (Object)(object)punchMissSFX)
		{
			return 2;
		}
		if ((Object)(object)ofClip == (Object)(object)reelSFX)
		{
			return 3;
		}
		if ((Object)(object)ofClip == (Object)(object)caughtSFX)
		{
			return 4;
		}
		if ((Object)(object)ofClip == (Object)(object)successCheer)
		{
			return 5;
		}
		return 0;
	}

	private void GrabLinkedItem()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		if (((NetworkBehaviour)this).IsOwner)
		{
			GrabLinkedItemLocal(linkedItem);
			GrabLinkedItemServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)linkedItem).NetworkObject));
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void GrabLinkedItemServerRpc(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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3528047492u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3528047492u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				GrabLinkedItemClientRpc(itemNOR);
			}
		}
	}

	[ClientRpc]
	private void GrabLinkedItemClientRpc(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_00dc: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(229287909u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 229287909u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		if (((NetworkBehaviour)this).IsOwner)
		{
			return;
		}
		NetworkObject val3 = default(NetworkObject);
		if (((NetworkObjectReference)(ref itemNOR)).TryGet(ref val3, (NetworkManager)null))
		{
			BeatAudioItem component = ((Component)val3).GetComponent<BeatAudioItem>();
			if ((Object)(object)component == (Object)null)
			{
				Log($"failed to get itemScript for GrabLinkedItemClientRpc on netObj {((Object)val3).name} #{((NetworkBehaviour)this).NetworkObjectId}");
			}
			else
			{
				GrabLinkedItemLocal(component);
			}
		}
		else
		{
			Log("failed to get netObj of linkedItem!", 3);
		}
	}

	private void GrabLinkedItemLocal(BeatAudioItem itemToGrab)
	{
		Log($"!!!locally grabbing {((Object)itemToGrab).name} #{((NetworkBehaviour)itemToGrab).NetworkObjectId}!!!", 1);
		itemToGrab.ToggleFakeAudio(setTo: false);
		itemToGrab.ToggleAlarm(setTo: false);
		((GrabbableObject)itemToGrab).grabbableToEnemies = false;
		((GrabbableObject)itemToGrab).isHeldByEnemy = true;
		((GrabbableObject)itemToGrab).fallTime = 1f;
		((GrabbableObject)itemToGrab).hasHitGround = true;
		((GrabbableObject)itemToGrab).reachedFloorTarget = true;
		((GrabbableObject)itemToGrab).parentObject = holdItemParentObject;
	}

	private void DropLinkedItem()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		if (((NetworkBehaviour)this).IsOwner)
		{
			DropLinkedItemLocal(linkedItem);
			DropLinkedItemServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)linkedItem).NetworkObject));
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void DropLinkedItemServerRpc(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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(170081384u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 170081384u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				DropLinkedItemClientRpc(itemNOR);
			}
		}
	}

	[ClientRpc]
	private void DropLinkedItemClientRpc(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_00dc: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1835154970u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1835154970u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		if (((NetworkBehaviour)this).IsOwner)
		{
			return;
		}
		NetworkObject val3 = default(NetworkObject);
		if (((NetworkObjectReference)(ref itemNOR)).TryGet(ref val3, (NetworkManager)null))
		{
			BeatAudioItem component = ((Component)val3).GetComponent<BeatAudioItem>();
			if ((Object)(object)component == (Object)null)
			{
				Log($"failed to get itemScript for DropLinkedItemClientRpc on netObj {((Object)val3).name} #{((NetworkBehaviour)this).NetworkObjectId}");
			}
			else
			{
				DropLinkedItemLocal(component);
			}
		}
		else
		{
			Log("failed to get netObj of linkedItem!", 3);
		}
	}

	private void DropLinkedItemLocal(BeatAudioItem itemToDrop)
	{
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		Log($"!!!locally dropping {((Object)itemToDrop).name} #{((NetworkBehaviour)itemToDrop).NetworkObjectId}!!!", 1);
		((GrabbableObject)itemToDrop).grabbable = true;
		((GrabbableObject)itemToDrop).grabbableToEnemies = true;
		((GrabbableObject)itemToDrop).isHeld = false;
		((GrabbableObject)itemToDrop).isHeldByEnemy = false;
		((GrabbableObject)itemToDrop).fallTime = 0f;
		((GrabbableObject)itemToDrop).hasHitGround = false;
		((GrabbableObject)itemToDrop).reachedFloorTarget = false;
		((GrabbableObject)itemToDrop).parentObject = null;
		((GrabbableObject)itemToDrop).startFallingPosition = (((Object)(object)((Component)itemToDrop).transform.parent == (Object)null) ? (holdItemParentObject.position + Vector3.up * 0.5f) : ((Component)itemToDrop).transform.parent.InverseTransformPoint(holdItemParentObject.position + Vector3.up * 0.5f));
		((GrabbableObject)itemToDrop).FallToGround(false, false, default(Vector3));
	}

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

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

	private void Log(string message, int type = 0)
	{
		if (debugLogLevel >= 1)
		{
			switch (type)
			{
			default:
				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 (debugLogLevel >= 2)
		{
			switch (type)
			{
			default:
				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;
			}
		}
	}

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

	protected override void __initializeRpcs()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Expected O, but got Unknown
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Expected O, but got Unknown
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Expected O, but got Unknown
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Expected O, but got Unknown
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Expected O, but got Unknown
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Expected O, but got Unknown
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Expected O, but got Unknown
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Expected O, but got Unknown
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Expected O, but got Unknown
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Expected O, but got Unknown
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Expected O, but got Unknown
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Expected O, but got Unknown
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Expected O, but got Unknown
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Expected O, but got Unknown
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Expected O, but got Unknown
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Expected O, but got Unknown
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Expected O, but got Unknown
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Expected O, but got Unknown
		//IL_023d: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Expected O, but got Unknown
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Expected O, but got Unknown
		((NetworkBehaviour)this).__registerRpc(2430531890u, new RpcReceiveHandler(__rpc_handler_2430531890), "PassNoiseToOwnerServerRpc");
		((NetworkBehaviour)this).__registerRpc(2592962014u, new RpcReceiveHandler(__rpc_handler_2592962014), "PassNoiseToOwnerClientRpc");
		((NetworkBehaviour)this).__registerRpc(3087885578u, new RpcReceiveHandler(__rpc_handler_3087885578), "CollisionLogicServerRpc");
		((NetworkBehaviour)this).__registerRpc(2055034921u, new RpcReceiveHandler(__rpc_handler_2055034921), "CollisionLogicClientRpc");
		((NetworkBehaviour)this).__registerRpc(1509949983u, new RpcReceiveHandler(__rpc_handler_1509949983), "SpawnItemServerRpc");
		((NetworkBehaviour)this).__registerRpc(4046887583u, new RpcReceiveHandler(__rpc_handler_4046887583), "SpawnItemClientRpc");
		((NetworkBehaviour)this).__registerRpc(750633870u, new RpcReceiveHandler(__rpc_handler_750633870), "ToggleAudioServerRpc");
		((NetworkBehaviour)this).__registerRpc(2000840382u, new RpcReceiveHandler(__rpc_handler_2000840382), "ToggleAudioClientRpc");
		((NetworkBehaviour)this).__registerRpc(1893334989u, new RpcReceiveHandler(__rpc_handler_1893334989), "SyncHPAmbushStartServerRpc");
		((NetworkBehaviour)this).__registerRpc(2954965683u, new RpcReceiveHandler(__rpc_handler_2954965683), "SyncHPAmbushStartClientRpc");
		((NetworkBehaviour)this).__registerRpc(118970262u, new RpcReceiveHandler(__rpc_handler_118970262), "ChasePlayerServerRpc");
		((NetworkBehaviour)this).__registerRpc(221236223u, new RpcReceiveHandler(__rpc_handler_221236223), "ChasePlayerClientRpc");
		((NetworkBehaviour)this).__registerRpc(3422828450u, new RpcReceiveHandler(__rpc_handler_3422828450), "SetAnimationServerRpc");
		((NetworkBehaviour)this).__registerRpc(4043217162u, new RpcReceiveHandler(__rpc_handler_4043217162), "SetAnimationClientRpc");
		((NetworkBehaviour)this).__registerRpc(3943627448u, new RpcReceiveHandler(__rpc_handler_3943627448), "PlaySFXServerRpc");
		((NetworkBehaviour)this).__registerRpc(2248627755u, new RpcReceiveHandler(__rpc_handler_2248627755), "PlaySFXClientRpc");
		((NetworkBehaviour)this).__registerRpc(3528047492u, new RpcReceiveHandler(__rpc_handler_3528047492), "GrabLinkedItemServerRpc");
		((NetworkBehaviour)this).__registerRpc(229287909u, new RpcReceiveHandler(__rpc_handler_229287909), "GrabLinkedItemClientRpc");
		((NetworkBehaviour)this).__registerRpc(170081384u, new RpcReceiveHandler(__rpc_handler_170081384), "DropLinkedItemServerRpc");
		((NetworkBehaviour)this).__registerRpc(1835154970u, new RpcReceiveHandler(__rpc_handler_1835154970), "DropLinkedItemClientRpc");
		((NetworkBehaviour)this).__registerRpc(2021963918u, new RpcReceiveHandler(__rpc_handler_2021963918), "SeverItemLinkServerRpc");
		((NetworkBehaviour)this).__registerRpc(2496588832u, new RpcReceiveHandler(__rpc_handler_2496588832), "SeverItemLinkClientRpc");
		((EnemyAI)this).__initializeRpcs();
	}

	private static void __rpc_handler_2430531890(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			Vector3 noisePosition = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref noisePosition);
			float noiseLoudness = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref noiseLoudness, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).PassNoiseToOwnerServerRpc(noisePosition, noiseLoudness);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2592962014(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			Vector3 noisePosition = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref noisePosition);
			float noiseLoudness = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref noiseLoudness, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).PassNoiseToOwnerClientRpc(noisePosition, noiseLoudness);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3087885578(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool doPreAttackAnimation = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref doPreAttackAnimation, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).CollisionLogicServerRpc(sentBy, doPreAttackAnimation);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2055034921(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool doPreAttackAnimation = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref doPreAttackAnimation, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).CollisionLogicClientRpc(sentBy, doPreAttackAnimation);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

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

	private static void __rpc_handler_4046887583(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)1;
			((TheBeatAI)(object)target).SpawnItemClientRpc(itemNOR);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_750633870(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			float newVolume = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref newVolume, default(ForPrimitives));
			float agentSpeed = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref agentSpeed, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).ToggleAudioServerRpc(newVolume, agentSpeed);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2000840382(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			float newVolume = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref newVolume, default(ForPrimitives));
			float agentSpeed = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref agentSpeed, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).ToggleAudioClientRpc(newVolume, agentSpeed);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1893334989(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 hpAmbushStartValue = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref hpAmbushStartValue);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).SyncHPAmbushStartServerRpc(hpAmbushStartValue);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2954965683(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 hpAmbushStartValue = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref hpAmbushStartValue);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).SyncHPAmbushStartClientRpc(hpAmbushStartValue);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_118970262(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;
			((TheBeatAI)(object)target).ChasePlayerServerRpc(playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_221236223(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;
			((TheBeatAI)(object)target).ChasePlayerClientRpc(playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3422828450(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			string animString = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref animString, false);
			}
			bool flag2 = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
			string paramString = null;
			if (flag2)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref paramString, false);
			}
			float paramFloat = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref paramFloat, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).SetAnimationServerRpc(sentBy, animString, paramString, paramFloat);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_4043217162(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			string animString = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref animString, false);
			}
			bool flag2 = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
			string paramString = null;
			if (flag2)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref paramString, false);
			}
			float paramFloat = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref paramFloat, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).SetAnimationClientRpc(sentBy, animString, paramString, paramFloat);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3943627448(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int clipCase = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref clipCase);
			bool audible = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref audible, default(ForPrimitives));
			bool crowd = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref crowd, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).PlaySFXServerRpc(sentBy, clipCase, audible, crowd);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2248627755(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int clipCase = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref clipCase);
			bool audible = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref audible, default(ForPrimitives));
			bool crowd = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref crowd, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBeatAI)(object)target).PlaySFXClientRpc(sentBy, clipCase, audible, crowd);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3528047492(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)1;
			((TheBeatAI)(object)target).GrabLinkedItemServerRpc(itemNOR);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_229287909(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)1;
			((TheBeatAI)(object)target).GrabLinkedItemClientRpc(itemNOR);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_170081384(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)1;
			((TheBeatAI)(object)target).DropLinkedItemServerRpc(itemNOR);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1835154970(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)1;
			((TheBeatAI)(object)target).DropLinkedItemClientRpc(itemNOR);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2021963918(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;
			((TheBeatAI)(object)target).SeverItemLinkServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2496588832(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;
			((TheBeatAI)(object)target).SeverItemLinkClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	protected internal override string __getTypeName()
	{
		return "TheBeatAI";
	}
}
public class TheBoxerAI : EnemyAI, IVisibleThreat
{
	private static ManualLogSource Logger = Plugin.Logger;

	private static int debugLogLevel = -1;

	private Vector3 positionLastInterval;

	private float distanceLastIntervalTarget;

	private bool approachedTarget;

	private float timeLastVoiceChatLocalPlayer;

	private float timeLastScoreInterval;

	private float timeLastTurningTo;

	private float timeLastCollisionLocalPlayer;

	private float timeLastSwitchingTarget;

	private float timeLastSeeingTarget;

	private float timeLastCheckedForEnemies;

	private Vector3 turnTo;

	private int animState;

	private float headTargetWeight;

	private bool inSpecialAnimationPreVulnerable;

	private Vector3 specialAnimVelocity;

	private bool heldShovelLastInterval;

	private int docileLastIntervalPlayerHP;

	public static GameObject spawnedNest;

	[Space(3f)]
	[Header("MOVEMENT")]
	public float topSpeed;

	public float minTargetDistance;

	public float maxTargetDistance;

	public float calculateMovementInterval;

	private float calculateMovementTimer;

	public float distanceToLoseTarget;

	public float timeWithoutTargetToReset;

	public float[] accelerationPerState;

	public TwoBoneIKConstraint headIK;

	public Transform headTarget;

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

	public float seeWidth;

	public Transform turnCompass;

	[Space(3f)]
	[Header("SFX")]
	[Header("Enemy")]
	public AudioClip intimidateSFX;

	public AudioClip reelSFX;

	public AudioClip punchSFX;

	public AudioClip blockSFX;

	public AudioClip stunEnemySFX;

	public AudioClip stunPlayersSFX;

	[Header("Audience")]
	public AudioSource crowdVoices;

	public static AudioSource boxerAudience;

	public AudioClip bellSFX;

	public AudioClip spotlightSFX;

	public AudioClip crowdStartCheer;

	public AudioClip crowdKillCheer;

	[Space(3f)]
	[Header("PARAMETERS")]
	public float minTargetFocusTime;

	public float localPlayerLikeMeter;

	public float feedforwardThreshold;

	[Header("Docile")]
	public float docileThreshold;

	[Space]
	public float changePerAlone;

	public float changePerCrouching;

	public float changePerLight;

	[Space]
	public float carryWeightLight;

	[Header("Hostile")]
	public float hostileThreshold;

	[Space]
	public float changePerTogether;

	public float changePerStanding;

	public float changePerArmed;

	public float changePerApproach;

	public float changePerHeavy;

	[Space]
	public float approachLeeway;

	public float approachIncrements;

	public float carryWeightHeavy;

	[Space(3f)]
	[Header("DOCILE")]
	public GrabbableObject[] itemSlots;

	public Transform[] itemParents;

	public InteractTrigger interactScript;

	public float checkItemGiveInterval;

	private float checkItemGiveTimer;

	[Space(3f)]
	[Header("HOSTILE")]
	public bool vulnerable;

	public int enragedThreshold;

	public float collisionCooldown;

	public float collisionDistance;

	public float collisionDistanceEnemies;

	public float stunTimeDefault;

	public float stunTimeBonus;

	public HitboxScript managerHitbox;

	public int currentAttackIndex;

	public AttackData currentAttack;

	public AttackSequence currentAttackSequence;

	public AttackSequence[] allAttackSequences;

	[Space]
	public Transform shovelParent;

	public Shovel heldShovel;

	public Transform holdPlayerParent;

	public int turnPlayerIterations;

	[Space]
	public GameObject currentTarget;

	private GameObject previousTarget;

	public EnemyAI targetEnemy;

	public Light enemySpotlight;

	public Light targetSpotlight;

	public AnimationCurve threatThreshold;

	public int checkEnemiesEveryXSeconds;

	public bool[] statePrioritizePlayers;

	public string[] unfightableEnemies;

	[Space]
	public Item bellItem;

	public int bellValue;

	public int bellValueIncrease;

	ThreatType IVisibleThreat.type => (ThreatType)4;

	public override void Start()
	{
		base.favoriteSpot = GetNestTransform();
		((EnemyAI)this).Start();
		itemSlots = (GrabbableObject[])(object)new GrabbableObject[itemParents.Length];
		interactScript.interactable = false;
		if ((Object)(object)boxerAudience == (Object)null)
		{
			((Component)crowdVoices).transform.SetParent(RoundManager.Instance.spawnedScrapContainer);
			boxerAudience = crowdVoices;
		}
		enemySpotlight.intensity = 5000f;
		enemySpotlight.range = 25f;
		enemySpotlight.shadows = (LightShadows)0;
		SetSpotlight(enemySpotlight, sync: false);
		targetSpotlight.intensity = 5000f;
		targetSpotlight.range = 25f;
		targetSpotlight.shadows = (LightShadows)0;
		SetSpotlight(targetSpotlight, sync: false, enableLight: false);
		if (debugLogLevel == -1)
		{
			debugLogLevel = Plugin.DebugLogLevel();
			base.DebugEnemy = debugLogLevel >= 1;
			base.debugEnemyAI = debugLogLevel >= 2;
		}
	}

	private Transform GetNestTransform()
	{
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Expected O, but got Unknown
		for (int i = 0; i < RoundManager.Instance.enemyNestSpawnObjects.Count; i++)
		{
			if ((Object)(object)RoundManager.Instance.enemyNestSpawnObjects[i].enemyType == (Object)(object)base.enemyType)
			{
				return ((Component)RoundManager.Instance.enemyNestSpawnObjects[i]).gameObject.transform;
			}
		}
		Log("failed to find nest, creating new empty nest at current position", 3);
		if ((Object)(object)spawnedNest == (Object)null)
		{
			GameObject val = new GameObject("BoxerNestTransform");
			val.transform.SetParent(RoundManager.Instance.spawnedScrapContainer);
			spawnedNest = val;
		}
		spawnedNest.transform.position = ((Component)this).transform.position;
		return spawnedNest.transform;
	}

	public override void Update()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0335: Unknown result type (might be due to invalid IL or missing references)
		//IL_0350: Unknown result type (might be due to invalid IL or missing references)
		//IL_0397: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).Update();
		if (base.isEnemyDead || !base.ventAnimationFinished)
		{
			return;
		}
		if (base.inSpecialAnimation)
		{
			base.updatePositionThreshold = 0.1f;
			base.syncMovementSpeed = 0.1f;
			if (!((NetworkBehaviour)this).IsOwner)
			{
				((Component)this).transform.position = Vector3.SmoothDamp(((Component)this).transform.position, base.serverPosition, ref specialAnimVelocity, base.syncMovementSpeed);
			}
		}
		else if (calculateMovementTimer >= calculateMovementInterval)
		{
			CalculateAnimations();
			calculateMovementTimer = 0f;
		}
		else
		{
			base.updatePositionThreshold = 1f;
			calculateMovementTimer += Time.deltaTime;
		}
		if (base.stunNormalizedTimer > 0f)
		{
			if (animState != GetIntOfAnimState("Stunned", boolVal: true, printDebug: false))
			{
				Log("STUN - START!!", 3);
				SetAnimation("Stunned", ((NetworkBehaviour)this).IsOwner, boolAnim: true);
				DisableAllHitboxes(sync: false);
			}
		}
		else if (animState == GetIntOfAnimState("Stunned", boolVal: true, printDebug: false))
		{
			Log("STUN - END!!", 3);
			SetEnemyVulnerable(setVulnerableTo: false);
			SetAnimation("Stunned", sync: false, boolAnim: true, boolVal: false);
			if (((NetworkBehaviour)this).IsOwner && GetEnraged() && (Object)(object)currentAttackSequence != (Object)(object)allAttackSequences[1])
			{
				SetAttackSequence(1);
			}
		}
		((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)headIK).weight = Mathf.Lerp(((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)headIK).weight, headTargetWeight, 0.1f);
		if (((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)headIK).weight > 0.1f && (Object)(object)base.targetNode != (Object)null)
		{
			headTarget.position = Vector3.Lerp(headTarget.position, base.targetNode.position, 0.075f);
		}
		base.useSecondaryAudiosOnAnimatedObjects = base.currentBehaviourStateIndex == 2;
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			if (((Behaviour)interactScript).enabled)
			{
				interactScript.interactable = false;
				((Behaviour)interactScript).enabled = false;
				((Component)interactScript).gameObject.SetActive(false);
			}
			base.enemyType.pushPlayerForce = 8f;
			docileLastIntervalPlayerHP = 0;
			TurnToLookAt();
			break;
		case 1:
			if (!((Behaviour)interactScript).enabled)
			{
				((Component)interactScript).gameObject.SetActive(true);
				((Behaviour)interactScript).enabled = true;
			}
			base.enemyType.pushPlayerForce = 5f;
			if (checkItemGiveTimer >= checkItemGiveInterval)
			{
				checkItemGiveTimer = 0f;
				CheckInventory();
			}
			else
			{
				checkItemGiveTimer += Time.deltaTime;
			}
			CalculateTargetSpotlight();
			break;
		case 2:
			if (((Behaviour)interactScript).enabled)
			{
				interactScript.interactable = false;
				((Behaviour)interactScript).enabled = false;
				((Component)interactScript).gameObject.SetActive(false);
			}
			base.enemyType.pushPlayerForce = 1f;
			docileLastIntervalPlayerHP = 0;
			if ((Object)(object)base.inSpecialAnimationWithPlayer != (Object)null)
			{
				((Component)base.inSpecialAnimationWithPlayer).transform.position = holdPlayerParent.position;
				((Component)base.inSpecialAnimationWithPlayer).transform.rotation = holdPlayerParent.rotation;
			}
			else if (base.inSpecialAnimation && inSpecialAnimationPreVulnerable && (Object)(object)base.targetPlayer != (Object)null)
			{
				if (vulnerable)
				{
					inSpecialAnimationPreVulnerable = false;
				}
				else
				{
					DetectNewSighting(((Component)base.targetPlayer).transform.position, lookImmediately: true);
				}
			}
			if (checkItemGiveTimer >= checkItemGiveInterval)
			{
				checkItemGiveTimer = 0f;
			}
			else
			{
				checkItemGiveTimer += Time.deltaTime;
			}
			if (!CalculateTargetSpotlight())
			{
				TurnToLookAt();
			}
			break;
		}
	}

	public override void DoAIInterval()
	{
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_044b: Unknown result type (might be due to invalid IL or missing references)
		//IL_045b: Unknown result type (might be due to invalid IL or missing references)
		//IL_024a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0255: Unknown result type (might be due to invalid IL or missing references)
		//IL_033a: Unknown result type (might be due to invalid IL or missing references)
		//IL_033f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a78: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a8a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a9a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0503: Unknown result type (might be due to invalid IL or missing references)
		//IL_0297: Unknown result type (might be due to invalid IL or missing references)
		//IL_093c: Unknown result type (might be due to invalid IL or missing references)
		//IL_094c: Unknown result type (might be due to invalid IL or missing references)
		//IL_072b: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).DoAIInterval();
		if (base.isEnemyDead || !base.ventAnimationFinished)
		{
			return;
		}
		if (StartOfRound.Instance.allPlayersDead)
		{
			if (animState != GetIntOfAnimState("Sitting", boolVal: true, printDebug: false))
			{
				SetAnimation("Sitting");
			}
			return;
		}
		if (base.stunNormalizedTimer > 0f)
		{
			timeLastSeeingTarget = Time.realtimeSinceStartup;
			base.agent.speed = 0f;
			return;
		}
		if (heldShovelLastInterval && !GetHoldingShovel())
		{
			heldShovelLastInterval = false;
			if ((Object)(object)heldShovel != (Object)null && (Object)(object)((GrabbableObject)heldShovel).playerHeldBy != (Object)null)
			{
				DetectNewSighting(((GrabbableObject)heldShovel).playerHeldBy.playerEye.position);
				GoIntoHostile(((GrabbableObject)heldShovel).playerHeldBy);
			}
			return;
		}
		PlayerControllerB[] allPlayersInLineOfSight = ((EnemyAI)this).GetAllPlayersInLineOfSight(seeWidth, seeDistance, base.eye, -1f, -1);
		EnemyAI[] array = null;
		if (Time.realtimeSinceStartup - timeLastCheckedForEnemies > (float)checkEnemiesEveryXSeconds)
		{
			timeLastCheckedForEnemies = Time.realtimeSinceStartup;
			array = GetAllEnemiesInLineOfSight(seeWidth, seeDistance, base.eye);
		}
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			base.addPlayerVelocityToDestination = 0f;
			if (allPlayersInLineOfSight != null)
			{
				timeLastSeeingTarget = Time.realtimeSinceStartup;
				LogAI("C");
				if (SetTargetPlayer(GetClosestSeenPlayerEye(allPlayersInLineOfSight)))
				{
					Log($"owner switching OWNERSHIP, not performing rest of currentBehaviorState({base.currentBehaviourStateIndex})", 3);
				}
				else if ((Object)(object)base.targetPlayer != (Object)null)
				{
					turnTo = ((Component)base.targetPlayer).transform.position;
					timeLastTurningTo = Time.realtimeSinceStartup;
					if (LocalPlayerScoreInterval(1f, 1f, canGoToIdle: true))
					{
						Log($"owner switching STATE, not performing rest of previousBehaviorState({base.previousBehaviourStateIndex})", 2);
					}
				}
				else if (Time.realtimeSinceStartup - timeLastSeeingTarget > minTargetFocusTime)
				{
					LogAI("3");
					DoIdleSit();
				}
				break;
			}
			LogAI("A");
			SetTargetPlayer(null);
			if (array != null)
			{
				float num = threatThreshold.Evaluate(TimeOfDay.Instance.normalizedTimeOfDay);
				LogAI($"threshold now = {num}");
				EnemyAI highestThreatEnemy = GetHighestThreatEnemy(array);
				if ((Object)(object)highestThreatEnemy != (Object)null)
				{
					float threatLevelOfEnemy = GetThreatLevelOfEnemy(highestThreatEnemy);
					if (GetEnraged() || threatLevelOfEnemy > num)
					{
						GoIntoHostile(null, highestThreatEnemy, enableOwnSpotlight: true);
						Log($"owner switching STATE, not performing rest of previousBehaviorState({base.previousBehaviourStateIndex})", 2);
						break;
					}
				}
			}
			if (Time.realtimeSinceStartup - timeLastSeeingTarget > timeWithoutTargetToReset)
			{
				if (((Behaviour)enemySpotlight).enabled)
				{
					SetSpotlight(enemySpotlight, sync: true, enableLight: false);
				}
				if (Vector3.Distance(((Component)this).transform.position, base.favoriteSpot.position) > minTargetDistance)
				{
					if (animState != GetIntOfAnimState("Hunched"))
					{
						SetAnimation("Hunched");
					}
					((EnemyAI)this).SetDestinationToPosition(base.favoriteSpot.position, false);
					CalculateSpeedToDestination(base.favoriteSpot);
				}
				else
				{
					LogAI("1");
					DoIdleSit();
				}
			}
			else
			{
				LogAI("2");
				DoIdleSit();
			}
			break;
		case 1:
			base.addPlayerVelocityToDestination = 0f;
			if ((Object)(object)targetEnemy != (Object)null)
			{
				if (targetEnemy.isEnemyDead)
				{
					SetTargetEnemy(null);
					break;
				}
				if ((Object)(object)base.targetPlayer != (Object)null && (Object)(object)base.targetPlayer.inAnimationWithEnemy != (Object)null && (Object)(object)base.targetPlayer.inAnimationWithEnemy != (Object)(object)targetEnemy)
				{
					SetTargetEnemy(base.targetPlayer.inAnimationWithEnemy);
					break;
				}
				timeLastSeeingTarget = Time.realtimeSinceStartup;
				if (Vector3.Distance(((Component)this).transform.position, ((Component)targetEnemy).transform.position) < collisionDistanceEnemies)
				{
					if ((Object)(object)base.targetPlayer != (Object)null && (Object)(object)base.targetPlayer.inAnimationWithEnemy == (Object)(object)targetEnemy)
					{
						SetAnimation("BoxerStun");
					}
					else
					{
						PerformPlayerCollision(null, targetEnemy);
					}
					break;
				}
				CalculateSpeedToDestination(((Component)targetEnemy).transform, keepMinDistance: false);
				if (distanceLastIntervalTarget > distanceToLoseTarget)
				{
					LogAI("VII");
					SetTargetEnemy(null);
				}
				else
				{
					((EnemyAI)this).SetDestinationToPosition(((Component)targetEnemy).transform.position, false);
				}
			}
			else if ((Object)(object)base.targetPlayer != (Object)null && base.targetPlayer.isPlayerControlled && !base.targetPlayer.isInsideFactory && (!StartOfRound.Instance.hangarDoorsClosed || base.isInsidePlayerShip == base.targetPlayer.isInHangarShipRoom))
			{
				if ((Object)(object)targetEnemy == (Object)null)
				{
					EnemyAI val2 = null;
					if ((Object)(object)base.targetPlayer.inAnimationWithEnemy != (Object)null)
					{
						val2 = base.targetPlayer.inAnimationWithEnemy;
					}
					else if (base.targetPlayer.health < docileLastIntervalPlayerHP)
					{
						Log("noticed player getting hurt, going on the attack", 3);
						val2 = GetEnemyTargetingPlayer(base.targetPlayer, array);
						if ((Object)(object)val2 == (Object)null)
						{
							val2 = GetClosestSeenEnemyEye(array, requireLineOfSight: false);
						}
					}
					LogAI($"HP: {base.targetPlayer.health} | last: {docileLastIntervalPlayerHP}");
					docileLastIntervalPlayerHP = base.targetPlayer.health;
					if ((Object)(object)val2 != (Object)null)
					{
						SetWavingGoodbye(setTo: false, goToUpright: true);
						ClearInventory();
						InitiateAttackSequence();
						SetTargetEnemy(val2);
						break;
					}
				}
				if (((Behaviour)enemySpotlight).enabled)
				{
					SetSpotlight(enemySpotlight, sync: true, enableLight: false);
				}
				if (((Behaviour)targetSpotlight).enabled)
				{
					SetSpotlight(targetSpotlight, sync: true, enableLight: false);
				}
				timeLastSeeingTarget = Time.realtimeSinceStartup;
				bool flag = false;
				if (allPlayersInLineOfSight != null)
				{
					foreach (PlayerControllerB val3 in allPlayersInLineOfSight)
					{
						if (PlayerIsArmed(val3) && GoIntoIdle(val3))
						{
							LogAI("I");
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					Log($"owner switching STATE, not performing rest of previousBehaviorState({base.previousBehaviourStateIndex})", 2);
					break;
				}
				if (animState == GetIntOfAnimState("WaveGoodbye"))
				{
					base.agent.speed = 0f;
					DetectNewSighting(base.targetPlayer.playerEye.position);
					break;
				}
				if (animState == GetIntOfAnimState("Sitting"))
				{
					SetAnimation("Hunched");
				}
				if (LocalPlayerScoreInterval(0.25f, 0.1f))
				{
					Log($"owner switching STATE, not performing rest of previousBehaviorState({base.currentBehaviourStateIndex})", 2);
					break;
				}
				CalculateSpeedToDestination(base.targetPlayer.playerEye);
				if (distanceLastIntervalTarget > distanceToLoseTarget && Time.realtimeSinceStartup - timeLastSeeingTarget > minTargetFocusTime)
				{
					LogAI("II");
					GoIntoIdle();
				}
				else
				{
					((EnemyAI)this).SetMovingTowardsTargetPlayer(base.targetPlayer);
				}
			}
			else
			{
				LogAI("III");
				GoIntoIdle();
			}
			break;
		case 2:
		{
			base.addPlayerVelocityToDestination = 0f;
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				base.addPlayerVelocityToDestination = 1f;
				timeLastSeeingTarget = Time.realtimeSinceStartup;
				if (!base.inSpecialAnimation)
				{
					CalculateSpeedToDestination(base.targetPlayer.playerEye, keepMinDistance: false);
					if (!base.targetPlayer.isPlayerControlled || base.targetPlayer.isInsideFactory || distanceLastIntervalTarget > distanceToLoseTarget || (StartOfRound.Instance.hangarDoorsClosed && base.isInsidePlayerShip != base.targetPlayer.isInHangarShipRoom))
					{
						LogAI("B");
						SetTargetPlayer(null);
						break;
					}
					if (LocalPlayerScoreInterval(0.75f, 1.25f, !PlayerIsArmed()))
					{
						Log($"owner switching STATE, not performing rest of currentBehaviorState({base.previousBehaviourStateIndex})", 2);
						break;
					}
					((EnemyAI)this).SetMovingTowardsTargetPlayer(base.targetPlayer);
					if (animState != GetIntOfAnimState("Upright"))
					{
						SetAnimation("Upright");
					}
					if (Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < collisionDistance && Time.realtimeSinceStartup - timeLastCollisionLocalPlayer > collisionCooldown)
					{
						PerformPlayerCollision(base.targetPlayer);
						break;
					}
					if (currentAttackIndex < 0)
					{
						base.targetPlayer.JumpToFearLevel(0.8f, true);
						break;
					}
					if ((Object)(object)previousTarget != (Object)(object)currentTarget)
					{
						InitiateAttackSequence();
					}
					if (!((Behaviour)enemySpotlight).enabled)
					{
						SetSpotlight(enemySpotlight);
					}
					if (!((Behaviour)targetSpotlight).enabled)
					{
						SetSpotlight(targetSpotlight);
					}
				}
				else
				{
					base.agent.speed = 0f;
				}
				break;
			}
			if ((Object)(object)targetEnemy != (Object)null)
			{
				timeLastSeeingTarget = Time.realtimeSinceStartup;
				if (targetEnemy.isEnemyDead || targetEnemy.isOutside != base.isOutside)
				{
					SetTargetEnemy(null);
					break;
				}
				CalculateSpeedToDestination(((Component)targetEnemy).transform, keepMinDistance: false);
				((EnemyAI)this).SetDestinationToPosition(((Component)targetEnemy).transform.position, false);
				if (Vector3.Distance(((Component)this).transform.position, ((Component)targetEnemy).transform.position) < collisionDistanceEnemies && Time.realtimeSinceStartup - timeLastCollisionLocalPlayer > collisionCooldown)
				{
					PerformPlayerCollision(null, targetEnemy);
					break;
				}
				if ((Object)(object)previousTarget != (Object)(object)currentTarget)
				{
					InitiateAttackSequence();
				}
				if (!((Behaviour)enemySpotlight).enabled)
				{
					SetSpotlight(enemySpotlight);
				}
				if (!((Behaviour)targetSpotlight).enabled)
				{
					SetSpotlight(targetSpotlight);
				}
				break;
			}
			base.agent.speed = 0f;
			if (((Behaviour)targetSpotlight).enabled)
			{
				SetSpotlight(targetSpotlight, sync: true, enableLight: false);
			}
			LogAI("D");
			if (allPlayersInLineOfSight != null && SetTargetPlayer(GetClosestSeenPlayerEye(allPlayersInLineOfSight)))
			{
				Log($"owner switching OWNERSHIP, not performing rest of currentBehaviorState({base.currentBehaviourStateIndex})", 3);
				break;
			}
			EnemyAI val = null;
			if (array != null || GetEnraged())
			{
				val = GetClosestSeenEnemyEye(array);
			}
			if ((Object)(object)val != (Object)null)
			{
				SetTargetEnemy(val);
			}
			else if (Time.realtimeSinceStartup - timeLastSeeingTarget > timeWithoutTargetToReset)
			{
				LogAI("IV");
				GoIntoIdle();
			}
			break;
		}
		}
		heldShovelLastInterval = GetHoldingShovel();
	}

	private bool GoIntoIdle(PlayerControllerB withPlayer = null, EnemyAI withEnemy = null, bool enableOwnSpotlight = false)
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			return false;
		}
		bool flag = false;
		if ((Object)(object)withPlayer == (Object)null && (Object)(object)withEnemy == (Object)null)
		{
			withPlayer = base.targetPlayer;
		}
		flag = base.currentBehaviourStateIndex != 0;
		LogAI($"switchState? {flag}");
		if (!flag)
		{
			if ((Object)(object)withPlayer != (Object)null)
			{
				LogAI("E");
				SetTargetPlayer(withPlayer);
			}
			if ((Object)(object)withEnemy != (Object)null)
			{
				SetTargetEnemy(withEnemy);
			}
			return flag;
		}
		Log("switching to: IDLE", 1);
		DisableAllHitboxes();
		SetSpotlight(enemySpotlight, sync: true, enableOwnSpotlight);
		SetSpotlight(targetSpotlight, sync: true, enableLight: false);
		timeLastSeeingTarget = Time.realtimeSinceStartup;
		ClearInventory();
		((EnemyAI)this).SwitchToBehaviourState(0);
		if ((Object)(object)withPlayer != (Object)null)
		{
			LogAI("F");
			SetTargetPlayer(withPlayer);
		}
		if ((Object)(object)withEnemy != (Object)null)
		{
			SetTargetEnemy(withEnemy);
		}
		return flag;
	}

	private bool GoIntoDocile(PlayerControllerB withPlayer = null, EnemyAI withEnemy = null, bool enableOwnSpotlight = false)
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			return false;
		}
		bool flag = false;
		if ((Object)(object)withPlayer == (Object)null && (Object)(object)withEnemy == (Object)null)
		{
			withPlayer = base.targetPlayer;
		}
		flag = base.currentBehaviourStateIndex != 1;
		LogAI($"switchState? {flag}");
		if (!flag)
		{
			if ((Object)(object)withPlayer != (Object)null)
			{
				LogAI("G");
				SetTargetPlayer(withPlayer);
			}
			if ((Object)(object)withEnemy != (Object)null)
			{
				SetTargetEnemy(withEnemy);
			}
			return flag;
		}
		Log("switching to: DOCILE", 2);
		DisableAllHitboxes();
		SetSpotlight(enemySpotlight, sync: true, enableOwnSpotlight);
		SetSpotlight(targetSpotlight, sync: true, enableLight: false);
		ClearInventory();
		((EnemyAI)this).SwitchToBehaviourState(1);
		if ((Object)(object)withPlayer != (Object)null)
		{
			LogAI("H");
			SetTargetPlayer(withPlayer);
		}
		if ((Object)(object)withEnemy != (Object)null)
		{
			SetTargetEnemy(withEnemy);
		}
		return flag;
	}

	private bool GoIntoHostile(PlayerControllerB withPlayer = null, EnemyAI withEnemy = null, bool enableOwnSpotlight = false)
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			return false;
		}
		bool flag = false;
		if ((Object)(object)withPlayer == (Object)null && (Object)(object)withEnemy == (Object)null)
		{
			withPlayer = base.targetPlayer;
		}
		flag = base.currentBehaviourStateIndex != 2;
		LogAI($"switchState? {flag}");
		if (!flag)
		{
			if ((Object)(object)withPlayer != (Object)null)
			{
				LogAI("I");
				SetTargetPlayer(withPlayer);
			}
			if ((Object)(object)withEnemy != (Object)null)
			{
				SetTargetEnemy(withEnemy);
			}
			return flag;
		}
		Log("switching to: HOSTILE", 3);
		DisableAllHitboxes();
		SetWavingGoodbye(setTo: false, goToUpright: true);
		PlaySFX(intimidateSFX);
		SetSpotlight(targetSpotlight, sync: true, enableLight: false);
		ClearInventory();
		((EnemyAI)this).SwitchToBehaviourState(2);
		if ((Object)(object)withPlayer != (Object)null)
		{
			LogAI("J");
			SetTargetPlayer(withPlayer);
		}
		if ((Object)(object)withEnemy != (Object)null)
		{
			SetTargetEnemy(withEnemy);
		}
		return flag;
	}

	private void DoIdleSit()
	{
		if (animState != GetIntOfAnimState("Sitting", boolVal: true, printDebug: false))
		{
			SetAnimation("Sitting");
		}
		base.agent.speed = 0f;
	}

	private void CalculateAnimations()
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		if (base.currentBehaviourStateIndex == 1 && StartOfRound.Instance.shipIsLeaving && (Object)(object)base.targetPlayer != (Object)null)
		{
			if (base.targetPlayer.isInElevator)
			{
				SetWavingGoodbye(setTo: true, goToUpright: false, sync: false);
			}
			else
			{
				SetWavingGoodbye(setTo: false, goToUpright: false, sync: false);
			}
		}
		float num = Vector3.Distance(((Component)this).transform.position, positionLastInterval);
		positionLastInterval = ((Component)this).transform.position;
		float num2 = num / 6f;
		if (num < 0.5f)
		{
			if (base.creatureAnimator.GetBool("Moving"))
			{
				SetAnimation("Moving", sync: false, boolAnim: true, boolVal: false);
			}
		}
		else
		{
			if (!base.creatureAnimator.GetBool("Moving"))
			{
				SetAnimation("Moving", sync: false, boolAnim: true);
			}
			LogAI($"moveSpeed = {num2}");
			SetAnimation(null, sync: false, boolAnim: false, boolVal: false, "WalkSpeedMultiplier", num2);
		}
		base.syncMovementSpeed = Mathf.Clamp(0.8f - num2, 0.15f, 0.5f);
		base.targetNode = null;
		if (!base.inSpecialAnimation && base.stunNormalizedTimer <= 0f)
		{
			if ((Object)(object)targetEnemy != (Object)null)
			{
				base.targetNode = (((Object)(object)targetEnemy.eye != (Object)null) ? targetEnemy.eye : ((Component)targetEnemy).transform);
			}
			else if ((Object)(object)base.targetPlayer != (Object)null)
			{
				base.targetNode = base.targetPlayer.playerEye;
			}
			Vector3 val = ((Component)this).transform.TransformPoint(((Component)this).transform.InverseTransformPoint(base.eye.position));
			if (animState != GetIntOfAnimState("WaveGoodbye") && (Object)(object)base.targetNode != (Object)null && Vector3.Angle(((Component)this).transform.forward, base.targetNode.position - val) > Mathf.Clamp(seeWidth, 0f, 33f))
			{
				base.targetNode = null;
			}
		}
		headTargetWeight = ((!((Object)(object)base.targetNode == (Object)null)) ? 1 : 0);
	}

	private void CalculateDistanceTarget(Transform target)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)target == (Object)null)
		{
			distanceLastIntervalTarget = -1f;
			approachedTarget = false;
			return;
		}
		float num = Vector3.Distance(base.eye.position, target.position);
		LogAI($"CalculateDistanceChangeTarget: this = {num} | last = {distanceLastIntervalTarget}");
		approachedTarget = num < distanceLastIntervalTarget - approachLeeway;
		distanceLastIntervalTarget = num;
		LogAI($"approached? {approachedTarget}");
	}

	private void CalculateSpeedToDestination(Transform toDestination, bool keepMinDistance = true)
	{
		if ((Object)(object)toDestination == (Object)null || base.stunNormalizedTimer > 0f)
		{
			base.agent.speed = 0f;
			return;
		}
		float num = 1f;
		if (distanceLastIntervalTarget != -1f)
		{
			CalculateDistanceTarget(toDestination);
			LogAI($"distanceLastInterval: {distanceLastIntervalTarget}");
			if (keepMinDistance && distanceLastIntervalTarget < minTargetDistance)
			{
				base.agent.speed = 0f;
				return;
			}
			if (approachedTarget && distanceLastIntervalTarget < maxTargetDistance)
			{
				num = -1f;
			}
		}
		base.agent.speed = Mathf.Clamp(base.agent.speed + accelerationPerState[base.currentBehaviourStateIndex % accelerationPerState.Length] * num, 0f, topSpeed);
	}

	private void CalculateLocalPlayerScoreChange(float positiveMultiplier = 1f, float negativeMultiplier = 1f)
	{
		timeLastScoreInterval = Time.realtimeSinceStartup;
		if ((Object)(object)base.targetPlayer == (Object)null || (Object)(object)base.targetPlayer != (Object)(object)StartOfRound.Instance.localPlayerController)
		{
			Log($"owner called LocalPlayerScoreInterval despite targetPlayer being {base.targetPlayer}, returning");
			return;
		}
		float num = 0f;
		if (base.targetPlayer.isPlayerAlone)
		{
			LogAI("alone", 3);
			num += changePerAlone * positiveMultiplier;
		}
		else
		{
			LogAI("together", 3);
			num += changePerTogether * negativeMultiplier;
		}
		if (base.targetPlayer.isCrouching)
		{
			LogAI("crouching", 3);
			num += changePerCrouching * positiveMultiplier;
		}
		else
		{
			LogAI("standing", 3);
			num += changePerStanding * negativeMultiplier;
		}
		if (base.targetPlayer.carryWeight < carryWeightLight)
		{
			LogAI("light", 3);
			num += changePerLight * positiveMultiplier;
		}
		if (PlayerIsArmed())
		{
			LogAI("armed", 3);
			num += changePerArmed * negativeMultiplier;
		}
		if (base.currentBehaviourStateIndex == 0 && (Object)(object)base.targetPlayer != (Object)null)
		{
			CalculateDistanceTarget(base.targetPlayer.playerEye);
			if (approachedTarget)
			{
				int num2 = 0;
				float num3 = (float)seeDistance - distanceLastIntervalTarget;
				num2 += (int)(num3 / approachIncrements);
				LogAI($"approach (score: {num2})", 3);
				num += changePerApproach * (float)num2 * negativeMultiplier;
			}
		}
		if (base.targetPlayer.carryWeight >= carryWeightHeavy)
		{
			LogAI("heavy", 3);
			num += changePerHeavy * negativeMultiplier;
		}
		localPlayerLikeMeter = Mathf.Clamp(localPlayerLikeMeter + num, hostileThreshold - 99f, docileThreshold + 1f);
		LogAI($"updated localPlayerLikeMeter to {localPlayerLikeMeter} with changeThisInterval {num} for player {base.targetPlayer}", 1);
	}

	private bool CalculateTargetSpotlight()
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)currentTarget == (Object)null || (Object)(object)targetSpotlight == (Object)null || !((Behaviour)targetSpotlight).enabled)
		{
			return false;
		}
		((Component)targetSpotlight).transform.position = currentTarget.transform.position + Vector3.up * 15f;
		return true;
	}

	private bool GetTargetPriority(bool forPlayers = true)
	{
		return forPlayers == statePrioritizePlayers[base.currentBehaviourStateIndex];
	}

	private bool GetEnraged()
	{
		return base.enemyHP < enragedThreshold;
	}

	private bool LocalPlayerScoreInterval(float positiveMultiplier = 1f, float negativeMultiplier = 1f, bool canGoToIdle = false)
	{
		bool flag = false;
		if (Time.realtimeSinceStartup - timeLastScoreInterval > 1f)
		{
			CalculateLocalPlayerScoreChange(positiveMultiplier, negativeMultiplier);
			if (localPlayerLikeMeter > docileThreshold)
			{
				flag = GoIntoDocile(base.targetPlayer, targetEnemy);
			}
			else if (GetEnraged() || localPlayerLikeMeter < hostileThreshold)
			{
				flag = GoIntoHostile(base.targetPlayer);
			}
			else if (localPlayerLikeMeter > feedforwardThreshold && canGoToIdle)
			{
				LogAI("V");
				if (animState != GetIntOfAnimState("Hunched"))
				{
					LogAI($"animState: {animState}");
					SetAnimation("Hunched");
				}
				flag = GoIntoIdle(base.targetPlayer, targetEnemy, ((Behaviour)enemySpotlight).enabled);
			}
			else if (localPlayerLikeMeter < feedforwardThreshold && canGoToIdle)
			{
				LogAI("VI");
				if (animState != GetIntOfAnimState("Upright"))
				{
					LogAI($"animState: {animState}");
					PlaySFX(intimidateSFX);
					SetAnimation("Upright");
				}
				flag = GoIntoIdle(base.targetPlayer, targetEnemy, ((Behaviour)enemySpotlight).enabled);
			}
		}
		LogAI($"LocalPlayerScoreInterval() // targetPlayer: {base.targetPlayer} | scoreSwitchedState: {flag}", 1);
		if (flag)
		{
			timeLastScoreInterval = Time.realtimeSinceStartup + minTargetFocusTime;
			Log($"scoreSwitchedState {flag}: adding cooldown of {minTargetFocusTime} to LocalPlayerScoreInterval");
		}
		return flag;
	}

	private PlayerControllerB GetClosestSeenPlayerEye(PlayerControllerB[] seenPlayers = null, bool requireLineOfSight = true)
	{
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (seenPlayers == null)
		{
			seenPlayers = StartOfRound.Instance.allPlayerScripts;
		}
		PlayerControllerB val = null;
		base.mostOptimalDistance = seeDistance;
		foreach (PlayerControllerB val2 in seenPlayers)
		{
			if (val2.isPlayerControlled && !val2.isInsideFactory && (!requireLineOfSight || !Physics.Linecast(base.eye.position, val2.playerEye.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault)))
			{
				base.tempDist = Vector3.Distance(base.eye.position, val2.playerEye.position);
				if (base.tempDist < base.mostOptimalDistance)
				{
					base.mostOptimalDistance = base.tempDist;
					val = val2;
				}
			}
		}
		LogAI($"GetClosestSeenPlayerEye() returned {val}");
		return val;
	}

	private EnemyAI[] GetAllEnemiesInLineOfSight(float width = 45f, int range = 60, Transform eyeObject = null)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)eyeObject == (Object)null)
		{
			eyeObject = base.eye;
		}
		if (base.isOutside && !base.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
		{
			range = Mathf.Clamp(range, 0, 30);
		}
		if ((Object)(object)RoundManager.Instance == (Object)null || RoundManager.Instance.SpawnedEnemies == null || RoundManager.Instance.SpawnedEnemies.Count <= 1)
		{
			return null;
		}
		List<EnemyAI> list = new List<EnemyAI>();
		for (int i = 0; i < RoundManager.Instance.SpawnedEnemies.Count; i++)
		{
			EnemyAI val = RoundManager.Instance.SpawnedEnemies[i];
			if ((Object)(object)val == (Object)null || (Object)(object)val.enemyType == (Object)null || (Object)(object)val == (Object)(object)this || val.isEnemyDead || val.isOutside != base.isOutside || !val.ventAnimationFinished)
			{
				continue;
			}
			Vector3 val2 = (((Object)(object)val.eye != (Object)null) ? val.eye.position : ((Component)val).transform.position);
			if (Vector3.Distance(base.eye.position, val2) < (float)range && !Physics.Linecast(eyeObject.position, val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				Vector3 val3 = val2 - eyeObject.position;
				if (Vector3.Angle(eyeObject.forward, val3) < width)
				{
					LogAI($"adding {val}", 2);
					list.Add(val);
				}
			}
		}
		if (list.Count > 0)
		{
			return list.ToArray();
		}
		return null;
	}

	private EnemyAI GetClosestSeenEnemyEye(EnemyAI[] seenEnemies = null, bool requireLineOfSight = true)
	{
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		if (seenEnemies == null)
		{
			if ((Object)(object)RoundManager.Instance == (Object)null || RoundManager.Instance.SpawnedEnemies == null || RoundManager.Instance.SpawnedEnemies.Count <= 1)
			{
				return null;
			}
			Log("Getting spawnedEnemies from RoundManager in GetEnemyTargetingPlayer()");
			seenEnemies = RoundManager.Instance.SpawnedEnemies.ToArray();
		}
		seenEnemies = GetFightableEnemies(seenEnemies);
		EnemyAI val = null;
		base.mostOptimalDistance = seeDistance;
		foreach (EnemyAI val2 in seenEnemies)
		{
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2 == (Object)(object)this || val2.isEnemyDead || val2.isOutside != base.isOutside)
			{
				continue;
			}
			Transform val3 = (((Object)(object)val2.eye != (Object)null) ? val2.eye : ((Component)val2).transform);
			if (!requireLineOfSight || !Physics.Linecast(base.eye.position + Vector3.up, val3.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
			{
				base.tempDist = Vector3.Distance(base.eye.position, val3.position);
				if (base.tempDist < base.mostOptimalDistance)
				{
					base.mostOptimalDistance = base.tempDist;
					val = val2;
				}
			}
		}
		LogAI($"GetClosestSeenEnemyEye() returned {val}");
		return val;
	}

	private EnemyAI GetHighestThreatEnemy(EnemyAI[] seenEnemies = null)
	{
		if (seenEnemies == null)
		{
			if ((Object)(object)RoundManager.Instance == (Object)null || RoundManager.Instance.SpawnedEnemies == null || RoundManager.Instance.SpawnedEnemies.Count <= 1)
			{
				return null;
			}
			Log("Getting spawnedEnemies from RoundManager in GetEnemyTargetingPlayer()");
			seenEnemies = RoundManager.Instance.SpawnedEnemies.ToArray();
		}
		seenEnemies = GetFightableEnemies(seenEnemies);
		EnemyAI val = null;
		float num = 0f;
		foreach (EnemyAI val2 in seenEnemies)
		{
			if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)this) && !val2.isEnemyDead && val2.isOutside == base.isOutside && ((Component)val2).GetComponent<IVisibleThreat>() != null)
			{
				float threatLevelOfEnemy = GetThreatLevelOfEnemy(val2);
				if (threatLevelOfEnemy > num)
				{
					val = val2;
					num = threatLevelOfEnemy;
				}
			}
		}
		LogAI($"GetHighestThreatEnemy() returned {val}");
		return val;
	}

	private float GetThreatLevelOfEnemy(EnemyAI enemy)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)enemy == (Object)null)
		{
			return -99f;
		}
		IVisibleThreat component = ((Component)enemy).GetComponent<IVisibleThreat>();
		if (component == null)
		{
			return -1f;
		}
		float num = (float)(component.GetThreatLevel(base.eye.position) + component.GetInterestLevel()) * component.GetVisibility();
		LogAI($"thisEnemyThreat of {enemy} = {num}");
		return num;
	}

	private EnemyAI GetEnemyTargetingPlayer(PlayerControllerB player = null, EnemyAI[] seenEnemies = null)
	{
		if ((Object)(object)player == (Object)null)
		{
			player = (((Object)(object)base.targetPlayer != (Object)null) ? base.targetPlayer : ((EnemyAI)this).GetClosestPlayer(false, false, false));
			if ((Object)(object)player == (Object)null)
			{
				Log("GetEnemyTargetingPlayer failed to find player, returning null", 2);
				return null;
			}
		}
		if (seenEnemies == null)
		{
			if ((Object)(object)RoundManager.Instance == (Object)null || RoundManager.Instance.SpawnedEnemies == null || RoundManager.Instance.SpawnedEnemies.Count <= 1)
			{
				return null;
			}
			Log("Getting spawnedEnemies from RoundManager in GetEnemyTargetingPlayer()");
			seenEnemies = RoundManager.Instance.SpawnedEnemies.ToArray();
		}
		seenEnemies = GetFightableEnemies(seenEnemies);
		EnemyAI val = null;
		List<EnemyAI> list = new List<EnemyAI>();
		foreach (EnemyAI val2 in seenEnemies)
		{
			if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)this) && !val2.isEnemyDead && val2.isOutside == base.isOutside && (Object)(object)val2.targetPlayer != (Object)null && (Object)(object)val2.targetPlayer == (Object)(object)player)
			{
				list.Add(val2);
			}
		}
		if (list.Count == 1)
		{
			val = list[0];
		}
		else if (list.Count > 1)
		{
			val = GetHighestThreatEnemy(list.ToArray());
		}
		LogAI($"GetEnemyTargetingPlayer returned {val}");
		return val;
	}

	private EnemyAI[] GetFightableEnemies(EnemyAI[] originalList)
	{
		List<EnemyAI> list = new List<EnemyAI>();
		foreach (EnemyAI val in originalList)
		{
			if ((Object)(object)val != (Object)null && (Object)(object)val.enemyType != (Object)null && !unfightableEnemies.Contains(val.enemyType.enemyName))
			{
				list.Add(val);
			}
		}
		return list.ToArray();
	}

	private bool GetHoldingShovel()
	{
		if ((Object)(object)heldShovel == (Object)null)
		{
			return false;
		}
		if ((Object)(object)((GrabbableObject)heldShovel).parentObject == (Object)(object)shovelParent || (Object)(object)((GrabbableObject)heldShovel).parentObject == (Object)(object)itemParents[1])
		{
			return true;
		}
		return false;
	}

	private bool PlayerIsArmed(PlayerControllerB player = null, bool checkHeldItemOnly = true, bool countNonOffensive = true)
	{
		if ((Object)(object)player == (Object)null)
		{
			if ((Object)(object)base.targetPlayer == (Object)null)
			{
				return false;
			}
			player = base.targetPlayer;
		}
		if (checkHeldItemOnly)
		{
			GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
			if ((Object)(object)currentlyHeldObjectServer == (Object)null || (Object)(object)currentlyHeldObjectServer.itemProperties == (Object)null)
			{
				return false;
			}
			if (currentlyHeldObjectServer.itemProperties.isDefensiveWeapon)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<Shovel>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<KnifeItem>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<ShotgunItem>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<PatcherTool>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<StunGrenadeItem>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<ExtensionLadderItem>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<RadarBoosterItem>()))
			{
				return true;
			}
			if (countNonOffensive && (Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<GunAmmo>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<RagdollGrabbableObject>()) || Object.op_Implicit((Object)(object)((Component)currentlyHeldObjectServer).GetComponent<BeatAudioItem>())))
			{
				return true;
			}
		}
		else
		{
			GrabbableObject[] array = player.ItemSlots;
			foreach (GrabbableObject val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.itemProperties == (Object)null))
				{
					if (val.itemProperties.isDefensiveWeapon)
					{
						return true;
					}
					if (Object.op_Implicit((Object)(object)((Component)val).GetComponent<Shovel>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<KnifeItem>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<ShotgunItem>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<PatcherTool>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<StunGrenadeItem>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<ExtensionLadderItem>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<RagdollGrabbableObject>()) || Object.op_Implicit((Object)(object)((Component)val).GetComponent<BeatAudioItem>()))
					{
						return true;
					}
				}
			}
		}
		return false;
	}

	private void SetWavingGoodbye(bool setTo, bool goToUpright = false, bool sync = true)
	{
		if (setTo && animState != GetIntOfAnimState("WaveGoodbye"))
		{
			ClearInventory(dropItem: true, sync);
			SetAnimation("WaveGoodbye", sync);
		}
		else if (!setTo)
		{
			string animString = (goToUpright ? "Upright" : "Hunched");
			int num = ((!goToUpright) ? 1 : 2);
			if (animState != num)
			{
				SetAnimation(animString, sync);
			}
		}
	}

	private void CheckInventory()
	{
		bool flag = true;
		for (int i = 0; i < itemSlots.Length; i++)
		{
			GrabbableObject val = itemSlots[i];
			if ((Object)(object)val != (Object)null)
			{
				flag = false;
				if ((Object)(object)val.parentObject != (Object)(object)itemParents[i])
				{
					Log($"found item {val} in slot {i} to be elsewhere than {itemParents[i]}, removing link from inventory");
					RemoveItemFromInventoryLocal(val, i);
				}
			}
		}
		LogAI($"{flag} | {animState}");
		if ((Object)(object)targetEnemy == (Object)null && flag && animState == GetIntOfAnimState("Upright"))
		{
			LogAI($"counted enemy {((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} to have emptyInventory {flag}, going to hunched animation");
			SetAnimation("Hunched", sync: false);
		}
		if ((Object)(object)StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer == (Object)null)
		{
			interactScript.interactable = false;
			interactScript.disabledHoverTip = "Not holding item";
		}
		else if (GetFirstSlot() == -1)
		{
			interactScript.interactable = false;
			interactScript.disabledHoverTip = "Hands full";
		}
		else
		{
			interactScript.interactable = true;
			interactScript.hoverTip = "Give item : [E]";
		}
	}

	public void InteractGiveHoldingItem(PlayerControllerB calledBy)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		GrabbableObject currentlyHeldObjectServer = calledBy.currentlyHeldObjectServer;
		if ((Object)(object)currentlyHeldObjectServer == (Object)null)
		{
			Log("local player tried giving item without holding one");
			return;
		}
		int firstSlot = GetFirstSlot(null, printDebug: true);
		if (firstSlot == -1)
		{
			Log("enemy found to have full inventory upon interact, likely thanks to other player handing over item at same time?", 2);
			return;
		}
		GiveHoldingItemLocal(currentlyHeldObjectServer, firstSlot, calledBy);
		GiveHoldingItemServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)currentlyHeldObjectServer).NetworkObject), firstSlot, (int)calledBy.playerClientId);
	}

	[ServerRpc(RequireOwnership = false)]
	private void GiveHoldingItemServerRpc(NetworkObjectReference itemNOR, int putInSlot, int sentBy)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: 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(3753337281u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val2, putInSlot);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3753337281u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				GiveHoldingItemClientRpc(itemNOR, putInSlot, sentBy);
			}
		}
	}

	[ClientRpc]
	private void GiveHoldingItemClientRpc(NetworkObjectReference itemNOR, int putInSlot, int sentBy)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2304444667u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			BytePacker.WriteValueBitPacked(val2, putInSlot);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2304444667u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		Log($"GiveHoldingItemClientRpc({putInSlot}, {sentBy})");
		if (sentBy < 0 || sentBy >= StartOfRound.Instance.allPlayerScripts.Length)
		{
			Log("sentBy in GiveHoldingItemClientRpc invalid!!");
		}
		else if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
		{
			NetworkObject val3 = default(NetworkObject);
			if (((NetworkObjectReference)(ref itemNOR)).TryGet(ref val3, (NetworkManager)null))
			{
				GrabbableObject component = ((Component)val3).GetComponent<GrabbableObject>();
				if ((Object)(object)component == (Object)null)
				{
					Log("failed to get item in GiveHoldingItemClientRpc()", 3);
				}
				else
				{
					GiveHoldingItemLocal(component, putInSlot, StartOfRound.Instance.allPlayerScripts[sentBy]);
				}
			}
			else
			{
				Log("failed to get netObj in GiveHoldingItemClientRpc()!", 3);
			}
		}
		else
		{
			Log("local player");
		}
	}

	private void GiveHoldingItemLocal(GrabbableObject itemToGrab, int putInSlot, PlayerControllerB removeFromPlayer)
	{
		if ((Object)(object)itemToGrab == (Object)null || (Object)(object)removeFromPlayer == (Object)null || putInSlot < 0 || putInSlot >= itemSlots.Length)
		{
			Log($"GiveHoldingItemLocal tried invalid giving item {itemToGrab} with slot {putInSlot}", 2);
			return;
		}
		Log($"grabbing {itemToGrab} #{((NetworkBehaviour)itemToGrab).NetworkObjectId}!!", 1);
		if ((Object)(object)itemSlots[putInSlot] != (Object)null)
		{
			Log($"DESYNC: player tried putting {itemToGrab} in slot [{putInSlot}] already occupied by {itemSlots[putInSlot]}, putting in next best slot locally!!!", 2);
			putInSlot = GetFirstSlot();
			if (putInSlot == -1)
			{
				Log("ERROR: still could not find empty slot, not giving item locally", 3);
				return;
			}
		}
		RemoveItemFromPlayerInventory(itemToGrab, removeFromPlayer);
		itemSlots[putInSlot] = itemToGrab;
		itemToGrab.grabbableToEnemies = false;
		itemToGrab.isHeldByEnemy = true;
		itemToGrab.fallTime = 1f;
		itemToGrab.hasHitGround = true;
		itemToGrab.reachedFloorTarget = true;
		itemToGrab.parentObject = itemParents[putInSlot];
		itemToGrab.EnableItemMeshes(true);
		itemToGrab.EnablePhysics(true);
		base.agent.speed = 0f;
		SetAnimation("GrabItem", sync: false);
		CheckInventory();
	}

	private void RemoveItemFromPlayerInventory(GrabbableObject item, PlayerControllerB player)
	{
		if ((Object)(object)item == (Object)null || (Object)(object)player == (Object)null)
		{
			Log($"RemoveItemFromPlayerInventory({item}, {player})", 3);
			return;
		}
		bool flag = false;
		int num = -1;
		if ((Object)(object)player.ItemOnlySlot == (Object)(object)item)
		{
			flag = true;
		}
		else
		{
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				if ((Object)(object)player.ItemSlots[i] == (Object)(object)item)
				{
					flag = true;
					num = i;
					break;
				}
			}
		}
		if (!flag)
		{
			Log($"failed to find player {player} slot for item {item} #{((NetworkBehaviour)item).NetworkObjectId} given to {this} #{((NetworkBehaviour)this).NetworkObjectId}!!!", 3);
			return;
		}
		item.isHeld = false;
		item.playerHeldBy = null;
		item.heldByPlayerOnServer = false;
		item.DiscardItem();
		if (num != -1)
		{
			player.ItemSlots[num] = null;
			if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				((Behaviour)HUDManager.Instance.itemSlotIcons[num]).enabled = false;
				((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = false;
				HUDManager.Instance.ClearControlTips();
			}
		}
		else
		{
			player.ItemOnlySlot = null;
			if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				((Behaviour)HUDManager.Instance.itemOnlySlotIcon).enabled = false;
				((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = false;
				HUDManager.Instance.ClearControlTips();
			}
		}
		player.twoHanded = false;
		player.twoHandedAnimation = false;
		player.activatingItem = false;
		player.IsInspectingItem = false;
		player.isHoldingObject = false;
		player.currentlyHeldObject = null;
		player.currentlyHeldObjectServer = null;
		player.equippedUsableItemQE = false;
		player.carryWeight = Mathf.Clamp(player.carryWeight - (item.itemProperties.weight - 1f), 1f, 10f);
		player.playerBodyAnimator.SetBool("cancelHolding", true);
		player.playerBodyAnimator.SetTrigger("Throw");
		player.playerBodyAnimator.SetBool("Grab", false);
		try
		{
			player.playerBodyAnimator.SetBool(item.itemProperties.grabAnim, false);
		}
		catch
		{
			Log("error when trying to give item and setting playerBodyAnimator with grabAnim " + item.itemProperties.grabAnim, 2);
		}
	}

	private void ClearInventory(bool dropItem = true, bool sync = true)
	{
		for (int i = 0; i < itemSlots.Length; i++)
		{
			if ((Object)(object)itemSlots[i] != (Object)null)
			{
				RemoveItemFromInventoryLocal(itemSlots[i], i, dropItem);
			}
			if (sync && ((NetworkBehaviour)this).IsOwner)
			{
				DropItemInSlotServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, i, dropItem);
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void DropItemInSlotServerRpc(int sentBy, int forSlot, bool dropItem)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(725744846u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				BytePacker.WriteValueBitPacked(val2, forSlot);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref dropItem, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 725744846u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				DropItemInSlotClientRpc(sentBy, forSlot, dropItem);
			}
		}
	}

	[ClientRpc]
	private void DropItemInSlotClientRpc(int sentBy, int forSlot, bool dropItem)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3895402323u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			BytePacker.WriteValueBitPacked(val2, forSlot);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref dropItem, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3895402323u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
		{
			GrabbableObject val3 = itemSlots[forSlot];
			if ((Object)(object)val3 != (Object)null)
			{
				RemoveItemFromInventoryLocal(val3, forSlot, dropItem);
			}
		}
	}

	private void RemoveItemFromInventoryLocal(GrabbableObject itemToDrop = null, int removeFromSlot = -1, bool dropToGround = false)
	{
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		if (removeFromSlot != -1 && removeFromSlot >= 0 && removeFromSlot < itemSlots.Length)
		{
			itemSlots[removeFromSlot] = null;
			itemToDrop.isHeldByEnemy = false;
		}
		else
		{
			if (!((Object)(object)itemToDrop != (Object)null))
			{
				Log($"RemoveItemFromInventoryLocal() called with invalid itemToDrop '{itemToDrop}' and removeFromSlot [{removeFromSlot}]!!", 3);
				return;
			}
			Log($"failed to find {itemToDrop} in slot [{removeFromSlot}], calculating locally", 2);
			removeFromSlot = GetFirstSlot(itemToDrop, printDebug: true);
			if (removeFromSlot == -1)
			{
				Log("still failed to find itemToDrop in any slot!!", 3);
				return;
			}
			itemSlots[removeFromSlot] = null;
			itemToDrop.isHeldByEnemy = false;
		}
		if (dropToGround && (Object)(object)itemToDrop != (Object)null)
		{
			Log($"dropping {itemToDrop} #{((NetworkBehaviour)this).NetworkObjectId}!!", 1);
			itemToDrop.grabbableToEnemies = true;
			itemToDrop.hasHitGround = false;
			itemToDrop.reachedFloorTarget = false;
			itemToDrop.parentObject = null;
			Vector3 val = ((Component)itemToDrop).transform.position + Vector3.up;
			itemToDrop.startFallingPosition = (((Object)(object)((Component)itemToDrop).transform.parent != (Object)null) ? ((Component)itemToDrop).transform.parent.InverseTransformPoint(val) : val);
			itemToDrop.FallToGround(false, false, default(Vector3));
			itemToDrop.EnableItemMeshes(true);
			itemToDrop.EnablePhysics(true);
		}
		CheckInventory();
	}

	private int GetFirstSlot(GrabbableObject getItem = null, bool printDebug = false)
	{
		int num = -1;
		if ((Object)(object)getItem == (Object)null)
		{
			for (int i = 0; i < itemSlots.Length; i++)
			{
				if ((Object)(object)itemSlots[i] == (Object)null)
				{
					num = i;
					break;
				}
			}
		}
		else
		{
			for (int j = 0; j < itemSlots.Length; j++)
			{
				if ((Object)(object)itemSlots[j] == (Object)(object)getItem)
				{
					num = j;
					break;
				}
			}
		}
		if (printDebug)
		{
			Log($"GetFirstFreeSlot returned {num}");
		}
		return num;
	}

	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_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).DetectNoise(noisePosition, noiseLoudness, timesPlayedInOneSpot, noiseID);
		if (noiseID != 546 && noiseID != 202252)
		{
			if (!((NetworkBehaviour)this).IsOwner && noiseID == 75 && Time.realtimeSinceStartup - timeLastVoiceChatLocalPlayer > 3f)
			{
				Log($"non-owner detected noise with ID {noiseID}, passing to server");
				timeLastVoiceChatLocalPlayer = Time.realtimeSinceStartup;
				PassNoiseToOwnerServerRpc(noisePosition);
			}
			else if (OnDetectNoiseValid())
			{
				DetectNoiseOnOwner(noisePosition);
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void PassNoiseToOwnerServerRpc(Vector3 noisePosition)
	{
		//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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			ServerRpcParams val = default(ServerRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1412222866u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref noisePosition);
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1412222866u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsOwner)
			{
				DetectNoiseOnOwner(noisePosition);
			}
			else
			{
				PassNoiseToOwnerClientRpc(noisePosition);
			}
		}
	}

	[ClientRpc]
	private void PassNoiseToOwnerClientRpc(Vector3 noisePosition)
	{
		//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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1805534101u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref noisePosition);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1805534101u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsOwner)
			{
				DetectNoiseOnOwner(noisePosition);
			}
		}
	}

	private void DetectNoiseOnOwner(Vector3 noisePos)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		DetectNewSighting(noisePos);
	}

	private void DetectNewSighting(Vector3 lookPos, bool lookImmediately = false)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		timeLastTurningTo = Time.realtimeSinceStartup;
		turnTo = lookPos;
		if (lookImmediately)
		{
			turnCompass.LookAt(lookPos);
			((Component)this).transform.eulerAngles = new Vector3(((Component)this).transform.eulerAngles.x, turnCompass.eulerAngles.y, ((Component)this).transform.eulerAngles.z);
		}
	}

	private bool OnDetectNoiseValid()
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			LogAI("DetectNoise(): not owner");
			return false;
		}
		if (!base.ventAnimationFinished)
		{
			LogAI("DetectNoise(): in vent animation");
			return false;
		}
		if (base.isEnemyDead)
		{
			LogAI("DetectNoise(): dead");
			return false;
		}
		if (base.inSpecialAnimation)
		{
			LogAI("DetectNoise(): inSpecialAnimation");
			return false;
		}
		if (base.stunNormalizedTimer > 0f)
		{
			LogAI("DetectNoise(): stunNormalizedTimer");
			return false;
		}
		if (base.currentBehaviourStateIndex == 1 && (Object)(object)base.targetPlayer != (Object)null)
		{
			LogAI("DetectNoise(): docile");
			return false;
		}
		if (base.currentBehaviourStateIndex == 2 && ((Object)(object)base.targetPlayer != (Object)null || (Object)(object)targetEnemy != (Object)null))
		{
			LogAI("DetectNoise(): hostile");
			return false;
		}
		return true;
	}

	private void TurnToLookAt()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		if (Time.realtimeSinceStartup - timeLastTurningTo < 1f)
		{
			turnCompass.LookAt(turnTo);
			((Component)this).transform.eulerAngles = new Vector3(((Component)this).transform.eulerAngles.x, turnCompass.eulerAngles.y, ((Component)this).transform.eulerAngles.z);
		}
	}

	public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
	{
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).HitEnemy(force, playerWhoHit, playHitSFX, hitID);
		if (base.isEnemyDead || !base.ventAnimationFinished)
		{
			return;
		}
		bool flag = true;
		if (base.currentBehaviourStateIndex != 2 || ((Object)(object)base.targetPlayer == (Object)null && (Object)(object)targetEnemy == (Object)null))
		{
			GoIntoHostile(playerWhoHit);
		}
		else if (((Object)(object)currentAttack == (Object)null || currentAttack.canBlock) && force <= 2 && ((Object)(object)base.inSpecialAnimationWithPlayer != (Object)null || (!vulnerable && base.stunNormalizedTimer <= 0f)))
		{
			flag = false;
		}
		if (flag && ((Object)(object)currentAttack == (Object)null || currentAttack.canStun))
		{
			float num = (((Object)(object)currentAttack != (Object)null) ? currentAttack.stunTime : stunTimeDefault);
			if (GetEnraged())
			{
				num += stunTimeBonus;
			}
			((EnemyAI)this).SetEnemyStunned(true, num, playerWhoHit);
			if ((Object)(object)playerWhoHit != (Object)null && (Object)(object)playerWhoHit == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				localPlayerLikeMeter = -99f;
			}
			if (((NetworkBehaviour)this).IsOwner)
			{
				int num2 = base.enemyHP - force;
				bool addPlayerHit = (Object)(object)playerWhoHit != (Object)null;
				SyncHPServerRpc(num2, addPlayerHit);
				SyncHPLocal(num2, addPlayerHit);
			}
		}
		else if ((Object)(object)base.inSpecialAnimationWithPlayer == (Object)null)
		{
			if ((Object)(object)playerWhoHit != (Object)null)
			{
				DetectNewSighting(((Component)playerWhoHit).transform.position, lookImmediately: true);
			}
			SetAnimation("Block", ((NetworkBehaviour)this).IsOwner);
		}
	}

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

	[ClientRpc]
	private void SyncHPClientRpc(int ownerHP, bool addPlayerHit)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(180112085u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, ownerHP);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref addPlayerHit, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 180112085u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsOwner)
			{
				SyncHPLocal(ownerHP, addPlayerHit);
			}
		}
	}

	private void SyncHPLocal(int newHP, bool addPlayerHit)
	{
		if (newHP < base.enemyHP)
		{
			PlaySFX(intimidateSFX, audibleNoise: true, isAudience: false, sync: false);
		}
		if (addPlayerHit)
		{
			bellValue += bellValueIncrease;
		}
		base.enemyHP = newHP;
		Log($"HP: {base.enemyHP} // value: {bellValue}");
		if (base.enemyHP <= 0 && ((NetworkBehaviour)this).IsOwner)
		{
			((EnemyAI)this).KillEnemyOnOwnerClient(false);
		}
	}

	public override void SetEnemyStunned(bool setToStunned, float setToStunTime = 1f, PlayerControllerB setStunnedByPlayer = null)
	{
		((EnemyAI)this).SetEnemyStunned(setToStunned, setToStunTime, setStunnedByPlayer);
		if (base.isEnemyDead || !base.enemyType.canBeStunned || base.stunNormalizedTimer > 0f)
		{
			return;
		}
		PlaySFX(stunEnemySFX, audibleNoise: false, isAudience: false, sync: false);
		bool flag = false;
		PlayerControllerB withPlayer = null;
		if (base.currentBehaviourStateIndex != 2)
		{
			flag = true;
		}
		if ((Object)(object)setStunnedByPlayer != (Object)null)
		{
			if ((Object)(object)setStunnedByPlayer == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				localPlayerLikeMeter = -99f;
			}
			withPlayer = setStunnedByPlayer;
		}
		if (flag)
		{
			GoIntoHostile(withPlayer);
		}
	}

	public override void KillEnemy(bool destroy = false)
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).KillEnemy(destroy);
		if (destroy)
		{
			return;
		}
		DisableAllHitboxes(sync: false);
		SetSpotlight(enemySpotlight, sync: false, enableLight: false);
		SetSpotlight(targetSpotlight, sync: false, enableLight: false);
		((MonoBehaviour)this).StartCoroutine(PlayBellDings(3, 0.4f, crowdKillCheer));
		if (((NetworkBehaviour)this).IsServer)
		{
			GameObject obj = Object.Instantiate<GameObject>(bellItem.spawnPrefab, ((Component)this).transform.position + Vector3.up * 2f + ((Component)this).transform.right, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
			NetworkObject component = obj.GetComponent<NetworkObject>();
			component.Spawn(false);
			GrabbableObject component2 = obj.GetComponent<GrabbableObject>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.SetScrapValue(bellValue);
				RoundManager instance = RoundManager.Instance;
				instance.totalScrapValueInLevel += (float)bellValue;
				Logger.LogDebug((object)$"{this} #{((NetworkBehaviour)this).NetworkObjectId} SERVER spawned {component2} with bellValue {component2.scrapValue}");
			}
			SpawnBellItemClientRpc(NetworkObjectReference.op_Implicit(component), bellValue);
		}
	}

	[ClientRpc]
	private void SpawnBellItemClientRpc(NetworkObjectReference itemNOR, int bellValueServer)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3031003030u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			BytePacker.WriteValueBitPacked(val2, bellValueServer);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3031003030u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsServer)
			{
				((MonoBehaviour)this).StartCoroutine(WaitForSpawnedItem(itemNOR, bellValueServer));
			}
		}
	}

	private IEnumerator WaitForSpawnedItem(NetworkObjectReference itemNOR, int bellValueServer)
	{
		//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)
		{
			Log("Bell: failed to get netObj on client!", 3);
			yield break;
		}
		yield return (object)new WaitForEndOfFrame();
		GrabbableObject component = ((Component)netObj).GetComponent<GrabbableObject>();
		if ((Object)(object)component != (Object)null)
		{
			component.SetScrapValue(bellValueServer);
			RoundManager instance = RoundManager.Instance;
			instance.totalScrapValueInLevel += (float)bellValueServer;
			Logger.LogDebug((object)$"{this} #{((NetworkBehaviour)this).NetworkObjectId} CLIENT spawned {component} with bellValueServer {component.scrapValue}");
		}
	}

	public override void OnCollideWithPlayer(Collider other)
	{
		if (Time.realtimeSinceStartup - timeLastCollisionLocalPlayer > collisionCooldown)
		{
			PlayerControllerB val = ((EnemyAI)this).MeetsStandardPlayerCollisionConditions(other, base.inSpecialAnimation, false);
			if ((Object)(object)val != (Object)null && (base.currentBehaviourStateIndex != 2 || (Object)(object)val == (Object)(object)base.targetPlayer))
			{
				((EnemyAI)this).OnCollideWithPlayer(other);
				PerformPlayerCollision(val);
			}
		}
	}

	private void PerformPlayerCollision(PlayerControllerB localPlayer = null, EnemyAI collidedEnemy = null)
	{
		if ((Object)(object)localPlayer != (Object)null && localPlayer.isClimbingLadder)
		{
			return;
		}
		timeLastCollisionLocalPlayer = Time.realtimeSinceStartup;
		switch (base.currentBehaviourStateIndex)
		{
		case 1:
			if ((Object)(object)collidedEnemy != (Object)null)
			{
				Log($"{((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} calling PerformNextAttack (enemy: {collidedEnemy} | state: {base.currentBehaviourStateIndex})");
				PerformNextAttack(((Component)collidedEnemy).transform);
			}
			break;
		case 2:
			if ((Object)(object)localPlayer != (Object)null)
			{
				if ((Object)(object)localPlayer != (Object)(object)base.targetPlayer)
				{
					Log($"localPlayer {localPlayer} not targetPlayer {base.targetPlayer}, breaking");
					break;
				}
				if (GetHoldingShovel() && !PlayerIsArmed(localPlayer, checkHeldItemOnly: true, countNonOffensive: false))
				{
					Log("!!!GIVE SHOVEL HERE; heldShovel " + ((Object)heldShovel).name);
					((MonoBehaviour)this).StartCoroutine(StartGiveShovelAnim(localPlayer));
					break;
				}
				Log($"{((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} calling PerformNextAttack (player: {localPlayer} | state: {base.currentBehaviourStateIndex})");
				PerformNextAttack(((Component)localPlayer).transform);
			}
			else if ((Object)(object)collidedEnemy != (Object)null)
			{
				Log($"{((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} calling PerformNextAttack (enemy: {collidedEnemy} | state: {base.currentBehaviourStateIndex})");
				PerformNextAttack(((Component)collidedEnemy).transform);
			}
			break;
		case 0:
			break;
		}
	}

	private void PerformNextAttack(Transform turnTo = null)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)turnTo != (Object)null)
		{
			DetectNewSighting(turnTo.position, lookImmediately: true);
		}
		base.agent.speed = 0f;
		int ownerAttackIndex = Mathf.Clamp((currentAttackIndex + 1) % currentAttackSequence.attacks.Length, 0, currentAttackSequence.attacks.Length - 1);
		SyncAttackAnimation(ownerAttackIndex, sync: true, onlySyncParameters: false, ((Component)this).transform.position);
	}

	private void SyncAttackAnimation(int ownerAttackIndex, bool sync = true, bool onlySyncParameters = false, Vector3 atPos = default(Vector3))
	{
		//IL_0003: 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)
		SyncAttackAnimationLocal(ownerAttackIndex, onlySyncParameters, atPos);
		if (sync && ((NetworkBehaviour)this).IsOwner)
		{
			SyncAttackAnimationServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, ownerAttackIndex, onlySyncParameters, atPos);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SyncAttackAnimationServerRpc(int sentBy, int ownerAttackIndex, bool onlySyncParameters, Vector3 atPos)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: 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(2838109337u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				BytePacker.WriteValueBitPacked(val2, ownerAttackIndex);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref onlySyncParameters, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref atPos);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2838109337u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				SyncAttackAnimationClientRpc(sentBy, ownerAttackIndex, onlySyncParameters, atPos);
			}
		}
	}

	[ClientRpc]
	private void SyncAttackAnimationClientRpc(int sentBy, int ownerAttackIndex, bool onlySyncParameters, Vector3 atPos)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1031167580u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			BytePacker.WriteValueBitPacked(val2, ownerAttackIndex);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref onlySyncParameters, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref atPos);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1031167580u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				SyncAttackAnimationLocal(ownerAttackIndex, onlySyncParameters, atPos);
			}
		}
	}

	private void SyncAttackAnimationLocal(int receivedAttackIndex, bool onlySyncParameters = false, Vector3 ownerServerPos = default(Vector3))
	{
		//IL_0081: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		currentAttack = null;
		currentAttackIndex = receivedAttackIndex;
		Log($"index: {currentAttackIndex}");
		if (onlySyncParameters)
		{
			Log($"previousTarget: {previousTarget} (currentTarget? {currentTarget})", 1);
			previousTarget = currentTarget;
			return;
		}
		currentAttack = currentAttackSequence.attacks[currentAttackIndex];
		managerHitbox.OnAttackStart();
		inSpecialAnimationPreVulnerable = true;
		if (ownerServerPos != default(Vector3))
		{
			base.serverPosition = ownerServerPos;
			positionLastInterval = ownerServerPos;
		}
		DisableAllHitboxes(sync: false);
		SetEnemyInSpecialAnimation(setinSpecialAnimationTo: true);
		SetEnemyVulnerable(setVulnerableTo: false);
		PlaySFX(reelSFX, audibleNoise: false, isAudience: false, sync: false);
		if ((Object)(object)currentAttack.creatureSFX != (Object)null)
		{
			PlaySFX(currentAttack.creatureSFX, audibleNoise: true, isAudience: false, sync: false);
		}
		if ((Object)(object)currentAttack.audienceSFX != (Object)null)
		{
			PlaySFX(currentAttack.audienceSFX, audibleNoise: true, isAudience: true, sync: false);
		}
		AttackAnimationNames animationName = currentAttack.animationName;
		Log($"trigger: {animationName} | stunTime: {currentAttack.stunTime}");
		SetAnimation(animationName.ToString(), sync: false);
	}

	public bool OnHitSuccessful(int[] hitIDs, bool forPlayers)
	{
		if (hitIDs == null || hitIDs.Length == 0)
		{
			return false;
		}
		bool flag = false;
		for (int i = 0; i < hitIDs.Length; i++)
		{
			if (forPlayers)
			{
				if (StartOfRound.Instance.allPlayerScripts[hitIDs[i]].isPlayerDead)
				{
					flag = true;
					break;
				}
			}
			else if (RoundManager.Instance.SpawnedEnemies[hitIDs[i]].isEnemyDead)
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			return false;
		}
		DisableAllHitboxes();
		((MonoBehaviour)this).StartCoroutine(PlayBellDings(5, 0.2f, crowdKillCheer, sync: true));
		if (forPlayers)
		{
			if (base.targetPlayer.isPlayerDead)
			{
				SetSpotlight(targetSpotlight, sync: true, enableLight: false);
			}
		}
		else if (targetEnemy.isEnemyDead)
		{
			SetSpotlight(targetSpotlight, sync: true, enableLight: false);
		}
		SetAnimation("Taunt");
		return true;
	}

	public void SetEnemyVulnerable(bool setVulnerableTo)
	{
		vulnerable = setVulnerableTo;
		LogAI($"SetEnemyVulnerable(): vulnerable = {vulnerable}");
	}

	public void SetEnemyInSpecialAnimation(bool setinSpecialAnimationTo)
	{
		base.inSpecialAnimation = setinSpecialAnimationTo;
		LogAI($"SetEnemyInSpecialAnimationTo(): inSpecialAnimation = {base.inSpecialAnimation}");
	}

	private void DisableAllHitboxes(bool sync = true)
	{
		DisableAllHitboxesLocal();
		if (sync && ((NetworkBehaviour)this).IsOwner)
		{
			DisableAllHitboxesServerRpc((int)StartOfRound.Instance.localPlayerController.playerClientId);
		}
	}

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

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

	private void DisableAllHitboxesLocal()
	{
		if ((Object)(object)managerHitbox == (Object)null)
		{
			Log("managerHitbox null in DisableAllHitboxesLocal()!", 3);
		}
		else
		{
			managerHitbox.DisableAllHitboxes();
		}
	}

	public void SpawnShovelAndSync()
	{
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		if (!((NetworkBehaviour)this).IsServer)
		{
			return;
		}
		GameObject val = Object.Instantiate<GameObject>(AssetsCollection.shovelItem.spawnPrefab);
		if ((Object)(object)val == (Object)null)
		{
			Log("failed to instantiate shovel on server");
			return;
		}
		heldShovel = val.GetComponent<Shovel>();
		if ((Object)(object)heldShovel == (Object)null)
		{
			Log("error spawning shovel on host", 3);
			return;
		}
		((GrabbableObject)heldShovel).hasHitGround = true;
		((GrabbableObject)heldShovel).reachedFloorTarget = true;
		((GrabbableObject)heldShovel).isInFactory = true;
		((GrabbableObject)heldShovel).parentObject = shovelParent;
		HoarderBugAI.grabbableObjectsInMap.Add(val);
		NetworkObject networkObject = ((NetworkBehaviour)heldShovel).NetworkObject;
		networkObject.Spawn(false);
		Log("spawned shovel on host", 1);
		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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(224874733u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 224874733u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).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)
		{
			Log("failed to get Shovel netObj on client!", 3);
			yield break;
		}
		yield return (object)new WaitForEndOfFrame();
		GameObject gameObject = ((Component)netObj).gameObject;
		heldShovel = ((Component)netObj).GetComponent<Shovel>();
		if ((Object)(object)heldShovel == (Object)null)
		{
			Log("error spawning shovel on client", 3);
			yield break;
		}
		((GrabbableObject)heldShovel).hasHitGround = true;
		((GrabbableObject)heldShovel).reachedFloorTarget = true;
		((GrabbableObject)heldShovel).isInFactory = true;
		((GrabbableObject)heldShovel).parentObject = shovelParent;
		HoarderBugAI.grabbableObjectsInMap.Add(gameObject);
		Log("spawned shovel on client", 1);
	}

	private IEnumerator StartGiveShovelAnim(PlayerControllerB collidedPlayer)
	{
		if ((Object)(object)heldShovel == (Object)null)
		{
			Log($"SHOVEL SCRIPT ON heldShovel {heldShovel} COULD NOT BE FOUND, returning", 3);
			base.inSpecialAnimation = false;
			yield break;
		}
		if ((Object)(object)collidedPlayer == (Object)null)
		{
			Log("collidedPlayer on StartGiveShovel() for some reason null, returning", 3);
			base.inSpecialAnimation = false;
			yield break;
		}
		PlaySFX(reelSFX);
		collidedPlayer.CancelSpecialTriggerAnimations();
		yield return null;
		collidedPlayer.ResetFallGravity();
		collidedPlayer.isCrouching = false;
		collidedPlayer.playerBodyAnimator.SetBool("crouching", false);
		collidedPlayer.playerBodyAnimator.SetBool("Walking", false);
		collidedPlayer.playerBodyAnimator.SetBool("Sprinting", false);
		collidedPlayer.playerBodyAnimator.SetBool("Sideways", false);
		collidedPlayer.playerBodyAnimator.SetBool("hinderedMovement", false);
		collidedPlayer.playerBodyAnimator.SetBool("Jumping", false);
		collidedPlayer.playerBodyAnimator.SetBool("FallNoJump", false);
		collidedPlayer.playerBodyAnimator.SetBool("Limp", false);
		collidedPlayer.DropAllHeldItemsAndSync(((Component)collidedPlayer).transform.position, collidedPlayer.localItemHolder.position, collidedPlayer.localItemHolder.eulerAngles, ((Component)collidedPlayer.playerEye).transform.position, ((Component)collidedPlayer.playerEye).transform.eulerAngles);
		collidedPlayer.inSpecialInteractAnimation = true;
		collidedPlayer.inAnimationWithEnemy = (EnemyAI)(object)this;
		base.inSpecialAnimationWithPlayer = collidedPlayer;
		SetAnimWithPlayerServerRpc((int)collidedPlayer.playerClientId, isGiveShovelAnim: true, ((Component)this).transform.position);
		SetEnemyInSpecialAnimation(setinSpecialAnimationTo: true);
		((GrabbableObject)heldShovel).grabbable = false;
		((GrabbableObject)heldShovel).parentObject = itemParents[1];
		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 < turnPlayerIterations; i++)
		{
			((Component)collidedPlayer).transform.rotation = Quaternion.Lerp(startingPlayerRot, targetPlayerRot, (float)i / (float)turnPlayerIterations);
			((Component)collidedPlayer).transform.eulerAngles = new Vector3(0f, ((Component)collidedPlayer).transform.eulerAngles.y, 0f);
			yield return null;
		}
		DetectNewSighting(((Component)collidedPlayer).transform.position, lookImmediately: true);
		SetSpotlight(enemySpotlight);
		SetSpotlight(targetSpotlight);
		SetAnimation("GiveShovel");
	}

	public void EndGiveShovelAnim()
	{
		PlayerControllerB inSpecialAnimationWithPlayer = base.inSpecialAnimationWithPlayer;
		if ((Object)(object)inSpecialAnimationWithPlayer == (Object)null)
		{
			Log("collidedPlayer null! cannot call GiveShovel and CancelSpecialAnimationWithPlayer");
			base.inSpecialAnimation = false;
		}
		else
		{
			((MonoBehaviour)this).StartCoroutine(GiveShovelLocal(inSpecialAnimationWithPlayer));
		}
	}

	private IEnumerator GiveShovelLocal(PlayerControllerB giveToPlayer)
	{
		Log($"GIVING SHOVEL TO {giveToPlayer}!!!", 2);
		if ((Object)(object)giveToPlayer == (Object)null)
		{
			Log("error finding player", 3);
			yield break;
		}
		if ((Object)(object)heldShovel == (Object)null)
		{
			Log("error finding shovel script", 3);
			yield break;
		}
		giveToPlayer.ItemSlots[giveToPlayer.currentItemSlot] = (GrabbableObject)(object)heldShovel;
		giveToPlayer.playerBodyAnimator.SetBool(((GrabbableObject)heldShovel).itemProperties.grabAnim, true);
		giveToPlayer.playerBodyAnimator.SetBool("GrabValidated", true);
		giveToPlayer.playerBodyAnimator.SetBool("cancelHolding", false);
		giveToPlayer.playerBodyAnimator.ResetTrigger("SwitchHoldAnimationTwoHanded");
		giveToPlayer.playerBodyAnimator.SetTrigger("SwitchHoldAnimationTwoHanded");
		giveToPlayer.itemAudio.PlayOneShot(((GrabbableObject)heldShovel).itemProperties.grabSFX);
		giveToPlayer.currentlyHeldObject = (GrabbableObject)(object)heldShovel;
		giveToPlayer.currentlyHeldObjectServer = (GrabbableObject)(object)heldShovel;
		giveToPlayer.twoHanded = ((GrabbableObject)heldShovel).itemProperties.twoHanded;
		giveToPlayer.twoHandedAnimation = ((GrabbableObject)heldShovel).itemProperties.twoHandedAnimation;
		giveToPlayer.isHoldingObject = true;
		giveToPlayer.carryWeight = Mathf.Clamp(giveToPlayer.carryWeight + (((GrabbableObject)heldShovel).itemProperties.weight - 1f), 1f, 10f);
		giveToPlayer.ResetFallGravity();
		giveToPlayer.externalForceAutoFade = ((Component)this).transform.forward * 20f + Vector3.up * 20f;
		if ((Object)(object)giveToPlayer == (Object)(object)GameNetworkManager.Instance.localPlayerController)
		{
			HUDManager.Instance.itemSlotIcons[giveToPlayer.currentItemSlot].sprite = ((GrabbableObject)heldShovel).itemProperties.itemIcon;
			((Behaviour)HUDManager.Instance.itemSlotIcons[giveToPlayer.currentItemSlot]).enabled = true;
		}
		((EnemyAI)this).CancelSpecialAnimationWithPlayer();
		((GrabbableObject)heldShovel).parentObject = (((Object)(object)giveToPlayer == (Object)(object)GameNetworkManager.Instance.localPlayerController) ? giveToPlayer.localItemHolder : giveToPlayer.serverItemHolder);
		((GrabbableObject)heldShovel).isHeld = true;
		((GrabbableObject)heldShovel).playerHeldBy = giveToPlayer;
		((GrabbableObject)heldShovel).grabbable = true;
		((Component)heldShovel).transform.localScale = ((GrabbableObject)heldShovel).originalScale;
		((GrabbableObject)heldShovel).EnableItemMeshes(true);
		((GrabbableObject)heldShovel).EnablePhysics(false);
		((GrabbableObject)heldShovel).GrabItemOnClient();
		((GrabbableObject)heldShovel).EquipItem();
		if (((NetworkBehaviour)this).IsServer)
		{
			try
			{
				((NetworkBehaviour)heldShovel).NetworkObject.ChangeOwnership(giveToPlayer.actualClientId);
			}
			catch
			{
				Log("failed to ChangeOwnership to new player!", 3);
			}
		}
		Log("reached end of GiveShovelLocal()");
		yield return null;
		timeLastCollisionLocalPlayer = Time.realtimeSinceStartup - collisionCooldown + 1f;
		InitiateAttackSequence(playAudioVisual: true, sync: false);
		yield return (object)new WaitForSeconds(0.33f);
		SetAnimation("Taunt", sync: false);
	}

	private void InitiateAttackSequence(bool playAudioVisual = true, bool sync = true)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		Log("ATTACK SEQUENCE - INITIATE!!", 2);
		DisableAllHitboxes(sync);
		SyncAttackAnimation(-1, sync, onlySyncParameters: true);
		if (playAudioVisual)
		{
			SetSpotlight(enemySpotlight, sync);
			((MonoBehaviour)this).StartCoroutine(PlayBellDings(2, 0.25f, crowdStartCheer, sync));
		}
	}

	private void SetAttackSequence(int sequenceIndex, bool sync = true)
	{
		SetAttackSequenceLocal(sequenceIndex);
		if (((NetworkBehaviour)this).IsOwner && sync)
		{
			SetAttackSequenceServerRpc(sequenceIndex, (int)GameNetworkManager.Instance.localPlayerController.playerClientId);
		}
	}

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

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

	private void SetAttackSequenceLocal(int sequenceIndex)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		Log("ATTACK SEQUENCE - SWITCH!!", 3);
		timeLastCollisionLocalPlayer = Time.realtimeSinceStartup + 1f;
		currentAttackSequence = allAttackSequences[sequenceIndex];
		SyncAttackAnimation(-1, sync: false, onlySyncParameters: true);
		SetAnimation("Intimidate", sync: false);
		((MonoBehaviour)this).StartCoroutine(PlayBellDings(2, 0.15f, crowdStartCheer));
	}

	[ServerRpc(RequireOwnership = false)]
	private void SetAnimWithPlayerServerRpc(int playerID, bool isGiveShovelAnim = false, Vector3 ownerPos = default(Vector3))
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: 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(2163757669u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isGiveShovelAnim, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref ownerPos);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2163757669u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				SetAnimWithPlayerClientRpc(playerID, isGiveShovelAnim, ownerPos);
			}
		}
	}

	[ClientRpc]
	private void SetAnimWithPlayerClientRpc(int playerID, bool isGiveShovelAnim = false, Vector3 ownerPos = default(Vector3))
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2151956930u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, playerID);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isGiveShovelAnim, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe(ref ownerPos);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2151956930u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		if (playerID == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
		{
			return;
		}
		base.serverPosition = ownerPos;
		if (playerID < 0 || playerID >= StartOfRound.Instance.allPlayerScripts.Length)
		{
			base.inSpecialAnimationWithPlayer = null;
			SetEnemyInSpecialAnimation(setinSpecialAnimationTo: false);
			return;
		}
		PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerID];
		val3.inAnimationWithEnemy = (EnemyAI)(object)this;
		val3.inSpecialInteractAnimation = true;
		base.inSpecialAnimationWithPlayer = val3;
		SetEnemyInSpecialAnimation(setinSpecialAnimationTo: true);
		if (isGiveShovelAnim && (Object)(object)heldShovel != (Object)null)
		{
			((GrabbableObject)heldShovel).grabbable = false;
			((GrabbableObject)heldShovel).parentObject = itemParents[1];
		}
	}

	public IEnumerator PlayBellDings(int amountOfDings, float delayBetweenDings, AudioClip playCrowdSFX = null, bool sync = false)
	{
		int performedDings = 0;
		while (performedDings < amountOfDings)
		{
			PlaySFX(bellSFX, audibleNoise: false, isAudience: true, sync);
			performedDings++;
			if (performedDings < amountOfDings)
			{
				yield return (object)new WaitForSeconds(delayBetweenDings);
			}
		}
		yield return (object)new WaitForSeconds(0.2f);
		if ((Object)(object)playCrowdSFX != (Object)null)
		{
			PlaySFX(playCrowdSFX, audibleNoise: false, isAudience: true, sync);
		}
	}

	public void SetSpotlight(Light lightToSet, bool sync = true, bool enableLight = true)
	{
		bool setEnemyLight = (Object)(object)lightToSet == (Object)(object)enemySpotlight;
		SetSpotlightLocal(setEnemyLight, enableLight);
		if (sync && ((NetworkBehaviour)this).IsOwner)
		{
			SetSpotlightServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, setEnemyLight, enableLight);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SetSpotlightServerRpc(int sentBy, bool setEnemyLight, bool enableLight)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		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(1791566011u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref setEnemyLight, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enableLight, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1791566011u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				SetSpotlightClientRpc(sentBy, setEnemyLight, enableLight);
			}
		}
	}

	[ClientRpc]
	private void SetSpotlightClientRpc(int sentBy, bool setEnemyLight, bool enableLight)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3638408080u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref setEnemyLight, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enableLight, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3638408080u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				SetSpotlightLocal(setEnemyLight, enableLight);
			}
		}
	}

	private void SetSpotlightLocal(bool setEnemyLight, bool enableLight = true)
	{
		//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_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		Light val = (setEnemyLight ? enemySpotlight : targetSpotlight);
		if (!((Object)(object)val == (Object)null))
		{
			Log($"starting SetSpotlightLocal with setEnemyLight {setEnemyLight} | enableLight {enableLight}");
			((Behaviour)val).enabled = enableLight;
			if (enableLight)
			{
				PlaySFXLocal(spotlightSFX, audibleNoise: false, isAudience: true, ((Component)val).transform.position - Vector3.up * 10f);
			}
		}
	}

	public void SetAnimation(string animString = null, bool sync = true, bool boolAnim = false, bool boolVal = true, string paramString = null, float paramFloat = 1f)
	{
		SetAnimationLocal(animString, boolAnim, boolVal, paramString, paramFloat);
		if (sync && ((NetworkBehaviour)this).IsOwner)
		{
			SetAnimationServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, animString, boolAnim, boolVal, paramString, paramFloat);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SetAnimationServerRpc(int sentBy, string animString, bool boolAnim, bool boolVal, string paramString, float paramFloat)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: 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_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		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(2879605001u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			bool flag = animString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(animString, false);
			}
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref boolAnim, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref boolVal, default(ForPrimitives));
			bool flag2 = paramString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
			if (flag2)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(paramString, false);
			}
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref paramFloat, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2879605001u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			SetAnimationClientRpc(sentBy, animString, boolAnim, boolVal, paramString, paramFloat);
		}
	}

	[ClientRpc]
	private void SetAnimationClientRpc(int sentBy, string animString, bool boolAnim, bool boolVal, string paramString, float paramFloat)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: 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_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1674142588u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			bool flag = animString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(animString, false);
			}
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref boolAnim, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref boolVal, default(ForPrimitives));
			bool flag2 = paramString != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
			if (flag2)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(paramString, false);
			}
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref paramFloat, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1674142588u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				SetAnimationLocal(animString, boolAnim, boolVal, paramString, paramFloat);
			}
		}
	}

	private void SetAnimationLocal(string animString, bool boolAnim, bool boolVal, string paramString, float paramFloat)
	{
		if (base.isEnemyDead)
		{
			return;
		}
		if (boolAnim)
		{
			if (!string.IsNullOrEmpty(animString))
			{
				base.creatureAnimator.SetBool(animString, boolVal);
				UpdateAnimStateInt(animString, boolVal);
			}
		}
		else if (!string.IsNullOrEmpty(animString))
		{
			base.creatureAnimator.SetTrigger(animString);
			UpdateAnimStateInt(animString);
		}
		if (!string.IsNullOrEmpty(paramString))
		{
			base.creatureAnimator.SetFloat(paramString, paramFloat);
		}
	}

	private void UpdateAnimStateInt(string animString, bool boolVal = true)
	{
		int intOfAnimState = GetIntOfAnimState(animString, boolVal);
		if (intOfAnimState != -1 && intOfAnimState != animState)
		{
			animState = intOfAnimState;
			LogAI($"UpdateAnimStateInt({animString}) successfully updated to {animState}");
		}
	}

	private int GetIntOfAnimState(string animString, bool boolVal = true, bool printDebug = true)
	{
		int num = -1;
		num = animString switch
		{
			"Sitting" => 0, 
			"Hunched" => 1, 
			"WaveGoodbye" => 3, 
			"Stunned" => boolVal ? 4 : 2, 
			_ => 2, 
		};
		if (printDebug)
		{
			LogAI($"GetIntOfAnimState returned {num}");
		}
		return num;
	}

	public void PlaySFX(AudioClip clipToPlay = null, bool audibleNoise = true, bool isAudience = false, bool sync = true, int clipCase = -1)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)clipToPlay == (Object)null)
		{
			clipToPlay = GetClipOfInt(clipCase);
		}
		PlaySFXLocal(clipToPlay, audibleNoise, isAudience);
		if (sync && ((NetworkBehaviour)this).IsOwner)
		{
			PlaySFXServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, GetIntOfClip(clipToPlay), audibleNoise, isAudience);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void PlaySFXServerRpc(int sentBy, int clipCase, bool audible, bool crowd)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		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(739170154u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, sentBy);
				BytePacker.WriteValueBitPacked(val2, clipCase);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref audible, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref crowd, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 739170154u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlaySFXClientRpc(sentBy, clipCase, audible, crowd);
			}
		}
	}

	[ClientRpc]
	private void PlaySFXClientRpc(int sentBy, int clipCase, bool audible, bool crowd)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3008003237u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, sentBy);
			BytePacker.WriteValueBitPacked(val2, clipCase);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref audible, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref crowd, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3008003237u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (sentBy != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				PlaySFXLocal(GetClipOfInt(clipCase), audible, crowd);
			}
		}
	}

	private void PlaySFXLocal(AudioClip clipToPlay, bool audibleNoise, bool isAudience, Vector3 audiencePosition = default(Vector3))
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		AudioSource creatureSFX = base.creatureSFX;
		if (isAudience)
		{
			if (audiencePosition == default(Vector3))
			{
				audiencePosition = ((Component)this).transform.position;
			}
			creatureSFX = boxerAudience;
			((Component)boxerAudience).transform.position = audiencePosition;
		}
		creatureSFX.PlayOneShot(clipToPlay);
		WalkieTalkie.TransmitOneShotAudio(creatureSFX, clipToPlay, 1f);
		if (audibleNoise)
		{
			RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 20f, 0.5f, 0, false, 202252);
		}
	}

	private AudioClip GetClipOfInt(int ofInt)
	{
		return (AudioClip)(ofInt switch
		{
			1 => bellSFX, 
			2 => punchSFX, 
			3 => stunPlayersSFX, 
			4 => stunEnemySFX, 
			5 => reelSFX, 
			6 => blockSFX, 
			7 => crowdStartCheer, 
			8 => crowdKillCheer, 
			_ => intimidateSFX, 
		});
	}

	private int GetIntOfClip(AudioClip ofClip)
	{
		if ((Object)(object)ofClip == (Object)(object)bellSFX)
		{
			return 1;
		}
		if ((Object)(object)ofClip == (Object)(object)punchSFX)
		{
			return 2;
		}
		if ((Object)(object)ofClip == (Object)(object)stunPlayersSFX)
		{
			return 3;
		}
		if ((Object)(object)ofClip == (Object)(object)stunEnemySFX)
		{
			return 4;
		}
		if ((Object)(object)ofClip == (Object)(object)reelSFX)
		{
			return 5;
		}
		if ((Object)(object)ofClip == (Object)(object)blockSFX)
		{
			return 6;
		}
		if ((Object)(object)ofClip == (Object)(object)crowdStartCheer)
		{
			return 7;
		}
		if ((Object)(object)ofClip == (Object)(object)crowdKillCheer)
		{
			return 8;
		}
		return 0;
	}

	private bool SetTargetPlayer(PlayerControllerB player)
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			return false;
		}
		if (Time.realtimeSinceStartup - timeLastSwitchingTarget < minTargetFocusTime)
		{
			return false;
		}
		if ((Object)(object)player == (Object)null && (Object)(object)base.targetPlayer != (Object)null)
		{
			Log("owner setting targetPlayer to null");
			SetTargetPlayerLocal(null);
			SetTargetPlayerServerRpc(-1);
			return false;
		}
		if ((Object)(object)player != (Object)null && ((Object)(object)base.targetPlayer == (Object)null || ((NetworkBehaviour)player).OwnerClientId != ((NetworkBehaviour)this).NetworkObject.OwnerClientId))
		{
			Log("found new player for SetPlayerAsOwner " + player.playerUsername, 2);
			((EnemyAI)this).ChangeOwnershipOfEnemy(player.actualClientId);
			SetTargetPlayerLocal(player);
			SetTargetPlayerServerRpc((int)player.playerClientId);
			return true;
		}
		return false;
	}

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

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

	private void SetTargetPlayerLocal(PlayerControllerB player)
	{
		base.targetPlayer = player;
		timeLastSwitchingTarget = Time.realtimeSinceStartup;
		Log($"targetPlayer = {base.targetPlayer}");
		bool targetPriority = GetTargetPriority();
		if ((Object)(object)base.targetPlayer != (Object)null && ((Object)(object)currentTarget == (Object)null || (Object)(object)targetEnemy == (Object)null || targetPriority))
		{
			currentTarget = ((Component)base.targetPlayer).gameObject;
			Log($"prioritize? {targetPriority} | currentTarget = {currentTarget}");
		}
	}

	private void SetTargetEnemy(EnemyAI enemy, bool sync = true)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		if (Time.realtimeSinceStartup - timeLastSwitchingTarget < minTargetFocusTime)
		{
			return;
		}
		SetTargetEnemyLocal(enemy);
		if (sync && ((NetworkBehaviour)this).IsOwner)
		{
			if ((Object)(object)enemy != (Object)null)
			{
				SetTargetEnemyServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)enemy).NetworkObject), (int)GameNetworkManager.Instance.localPlayerController.playerClientId);
			}
			else
			{
				SetTargetEnemyServerRpc();
			}
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SetTargetEnemyServerRpc(NetworkObjectReference enemyNOR, 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_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1783695022u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref enemyNOR, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1783695022u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				SetTargetEnemyClientRpc(enemyNOR, playerID);
			}
		}
	}

	[ClientRpc]
	private void SetTargetEnemyClientRpc(NetworkObjectReference enemyNOR, 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_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2382220646u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref enemyNOR, default(ForNetworkSerializable));
			BytePacker.WriteValueBitPacked(val2, playerID);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2382220646u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
		{
			return;
		}
		((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
		if (playerID == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
		{
			return;
		}
		NetworkObject val3 = default(NetworkObject);
		if (((NetworkObjectReference)(ref enemyNOR)).TryGet(ref val3, (NetworkManager)null))
		{
			EnemyAI component = ((Component)val3).GetComponent<EnemyAI>();
			if ((Object)(object)component == (Object)null)
			{
				Log("failed to get script from enemyNOR", 3);
			}
			else
			{
				SetTargetEnemyLocal(component);
			}
		}
		else
		{
			Log("failed to get netObj from enemyNOR", 3);
		}
	}

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

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

	private void SetTargetEnemyLocal(EnemyAI enemy)
	{
		targetEnemy = enemy;
		Log($"targetEnemy = {targetEnemy}");
		bool targetPriority = GetTargetPriority(forPlayers: false);
		if ((Object)(object)targetEnemy != (Object)null && ((Object)(object)currentTarget == (Object)null || (Object)(object)base.targetPlayer == (Object)null || targetPriority))
		{
			currentTarget = ((Component)targetEnemy).gameObject;
			Log($"prioritize? {targetPriority} | currentTarget = {currentTarget}");
		}
	}

	private void OnDisable()
	{
		if (((NetworkBehaviour)this).IsServer && (Object)(object)heldShovel != (Object)null && GetHoldingShovel())
		{
			NetworkObject component = ((Component)heldShovel).GetComponent<NetworkObject>();
			if ((Object)(object)component != (Object)null && component.IsSpawned)
			{
				Log($"despawning netObj of {heldShovel}", 2);
				component.Despawn(true);
			}
			else
			{
				Log($"could not find netObj of {heldShovel}, destroying instead", 3);
				Object.Destroy((Object)(object)heldShovel);
			}
		}
	}

	int IVisibleThreat.GetThreatLevel(Vector3 seenByPosition)
	{
		return base.currentBehaviourStateIndex switch
		{
			1 => 0, 
			2 => 10, 
			_ => 5, 
		};
	}

	int IVisibleThreat.GetInterestLevel()
	{
		return base.currentBehaviourStateIndex switch
		{
			1 => 1, 
			2 => 2, 
			_ => 0, 
		};
	}

	Transform IVisibleThreat.GetThreatLookTransform()
	{
		return base.eye;
	}

	Transform IVisibleThreat.GetThreatTransform()
	{
		return ((Component)this).transform;
	}

	Vector3 IVisibleThreat.GetThreatVelocity()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		if (((NetworkBehaviour)this).IsOwner)
		{
			return base.agent.velocity;
		}
		return Vector3.zero;
	}

	float IVisibleThreat.GetVisibility()
	{
		if (base.isEnemyDead)
		{
			return 0f;
		}
		if (animState == GetIntOfAnimState("Upright") || animState == GetIntOfAnimState("Stunned"))
		{
			return 1f;
		}
		if (animState == GetIntOfAnimState("Hunched"))
		{
			return 0.75f;
		}
		return 0.5f;
	}

	int IVisibleThreat.SendSpecialBehaviour(int id)
	{
		return 0;
	}

	GrabbableObject IVisibleThreat.GetHeldObject()
	{
		return (GrabbableObject)(object)heldShovel;
	}

	bool IVisibleThreat.IsThreatDead()
	{
		return base.isEnemyDead;
	}

	private void Log(string message, int type = 0)
	{
		if (debugLogLevel >= 1)
		{
			switch (type)
			{
			default:
				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 (debugLogLevel >= 2)
		{
			switch (type)
			{
			default:
				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;
			}
		}
	}

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

	protected override void __initializeRpcs()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Expected O, but got Unknown
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Expected O, but got Unknown
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Expected O, but got Unknown
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Expected O, but got Unknown
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Expected O, but got Unknown
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Expected O, but got Unknown
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Expected O, but got Unknown
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Expected O, but got Unknown
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Expected O, but got Unknown
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Expected O, but got Unknown
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Expected O, but got Unknown
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Expected O, but got Unknown
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Expected O, but got Unknown
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Expected O, but got Unknown
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Expected O, but got Unknown
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Expected O, but got Unknown
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Expected O, but got Unknown
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Expected O, but got Unknown
		//IL_023d: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Expected O, but got Unknown
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Expected O, but got Unknown
		//IL_0275: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Expected O, but got Unknown
		//IL_0291: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a0: Expected O, but got Unknown
		//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bc: Expected O, but got Unknown
		//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Expected O, but got Unknown
		//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f4: Expected O, but got Unknown
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		//IL_0310: Expected O, but got Unknown
		//IL_031d: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Expected O, but got Unknown
		//IL_0339: Unknown result type (might be due to invalid IL or missing references)
		//IL_0348: Expected O, but got Unknown
		((NetworkBehaviour)this).__registerRpc(3753337281u, new RpcReceiveHandler(__rpc_handler_3753337281), "GiveHoldingItemServerRpc");
		((NetworkBehaviour)this).__registerRpc(2304444667u, new RpcReceiveHandler(__rpc_handler_2304444667), "GiveHoldingItemClientRpc");
		((NetworkBehaviour)this).__registerRpc(725744846u, new RpcReceiveHandler(__rpc_handler_725744846), "DropItemInSlotServerRpc");
		((NetworkBehaviour)this).__registerRpc(3895402323u, new RpcReceiveHandler(__rpc_handler_3895402323), "DropItemInSlotClientRpc");
		((NetworkBehaviour)this).__registerRpc(1412222866u, new RpcReceiveHandler(__rpc_handler_1412222866), "PassNoiseToOwnerServerRpc");
		((NetworkBehaviour)this).__registerRpc(1805534101u, new RpcReceiveHandler(__rpc_handler_1805534101), "PassNoiseToOwnerClientRpc");
		((NetworkBehaviour)this).__registerRpc(833820681u, new RpcReceiveHandler(__rpc_handler_833820681), "SyncHPServerRpc");
		((NetworkBehaviour)this).__registerRpc(180112085u, new RpcReceiveHandler(__rpc_handler_180112085), "SyncHPClientRpc");
		((NetworkBehaviour)this).__registerRpc(3031003030u, new RpcReceiveHandler(__rpc_handler_3031003030), "SpawnBellItemClientRpc");
		((NetworkBehaviour)this).__registerRpc(2838109337u, new RpcReceiveHandler(__rpc_handler_2838109337), "SyncAttackAnimationServerRpc");
		((NetworkBehaviour)this).__registerRpc(1031167580u, new RpcReceiveHandler(__rpc_handler_1031167580), "SyncAttackAnimationClientRpc");
		((NetworkBehaviour)this).__registerRpc(1973553030u, new RpcReceiveHandler(__rpc_handler_1973553030), "DisableAllHitboxesServerRpc");
		((NetworkBehaviour)this).__registerRpc(1404788327u, new RpcReceiveHandler(__rpc_handler_1404788327), "DisableAllHitboxesClientRpc");
		((NetworkBehaviour)this).__registerRpc(224874733u, new RpcReceiveHandler(__rpc_handler_224874733), "SpawnShovelClientRpc");
		((NetworkBehaviour)this).__registerRpc(2829866388u, new RpcReceiveHandler(__rpc_handler_2829866388), "SetAttackSequenceServerRpc");
		((NetworkBehaviour)this).__registerRpc(1786351614u, new RpcReceiveHandler(__rpc_handler_1786351614), "SetAttackSequenceClientRpc");
		((NetworkBehaviour)this).__registerRpc(2163757669u, new RpcReceiveHandler(__rpc_handler_2163757669), "SetAnimWithPlayerServerRpc");
		((NetworkBehaviour)this).__registerRpc(2151956930u, new RpcReceiveHandler(__rpc_handler_2151956930), "SetAnimWithPlayerClientRpc");
		((NetworkBehaviour)this).__registerRpc(1791566011u, new RpcReceiveHandler(__rpc_handler_1791566011), "SetSpotlightServerRpc");
		((NetworkBehaviour)this).__registerRpc(3638408080u, new RpcReceiveHandler(__rpc_handler_3638408080), "SetSpotlightClientRpc");
		((NetworkBehaviour)this).__registerRpc(2879605001u, new RpcReceiveHandler(__rpc_handler_2879605001), "SetAnimationServerRpc");
		((NetworkBehaviour)this).__registerRpc(1674142588u, new RpcReceiveHandler(__rpc_handler_1674142588), "SetAnimationClientRpc");
		((NetworkBehaviour)this).__registerRpc(739170154u, new RpcReceiveHandler(__rpc_handler_739170154), "PlaySFXServerRpc");
		((NetworkBehaviour)this).__registerRpc(3008003237u, new RpcReceiveHandler(__rpc_handler_3008003237), "PlaySFXClientRpc");
		((NetworkBehaviour)this).__registerRpc(943357845u, new RpcReceiveHandler(__rpc_handler_943357845), "SetTargetPlayerServerRpc");
		((NetworkBehaviour)this).__registerRpc(1343550192u, new RpcReceiveHandler(__rpc_handler_1343550192), "SetTargetPlayerClientRpc");
		((NetworkBehaviour)this).__registerRpc(1783695022u, new RpcReceiveHandler(__rpc_handler_1783695022), "SetTargetEnemyServerRpc");
		((NetworkBehaviour)this).__registerRpc(2382220646u, new RpcReceiveHandler(__rpc_handler_2382220646), "SetTargetEnemyClientRpc");
		((NetworkBehaviour)this).__registerRpc(375865059u, new RpcReceiveHandler(__rpc_handler_375865059), "SetTargetEnemyServerRpc");
		((NetworkBehaviour)this).__registerRpc(2442538025u, new RpcReceiveHandler(__rpc_handler_2442538025), "SetTargetEnemyClientRpc");
		((EnemyAI)this).__initializeRpcs();
	}

	private static void __rpc_handler_3753337281(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			NetworkObjectReference itemNOR = default(NetworkObjectReference);
			((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			int putInSlot = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref putInSlot);
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).GiveHoldingItemServerRpc(itemNOR, putInSlot, sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2304444667(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			NetworkObjectReference itemNOR = default(NetworkObjectReference);
			((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			int putInSlot = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref putInSlot);
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).GiveHoldingItemClientRpc(itemNOR, putInSlot, sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_725744846(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int forSlot = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref forSlot);
			bool dropItem = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref dropItem, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).DropItemInSlotServerRpc(sentBy, forSlot, dropItem);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3895402323(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int forSlot = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref forSlot);
			bool dropItem = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref dropItem, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).DropItemInSlotClientRpc(sentBy, forSlot, dropItem);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1412222866(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			Vector3 noisePosition = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref noisePosition);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).PassNoiseToOwnerServerRpc(noisePosition);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1805534101(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			Vector3 noisePosition = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref noisePosition);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).PassNoiseToOwnerClientRpc(noisePosition);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_833820681(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int ownerHP = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref ownerHP);
			bool addPlayerHit = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref addPlayerHit, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SyncHPServerRpc(ownerHP, addPlayerHit);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_180112085(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int ownerHP = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref ownerHP);
			bool addPlayerHit = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref addPlayerHit, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SyncHPClientRpc(ownerHP, addPlayerHit);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3031003030(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			NetworkObjectReference itemNOR = default(NetworkObjectReference);
			((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
			int bellValueServer = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref bellValueServer);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SpawnBellItemClientRpc(itemNOR, bellValueServer);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2838109337(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int ownerAttackIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref ownerAttackIndex);
			bool onlySyncParameters = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref onlySyncParameters, default(ForPrimitives));
			Vector3 atPos = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref atPos);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SyncAttackAnimationServerRpc(sentBy, ownerAttackIndex, onlySyncParameters, atPos);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1031167580(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int ownerAttackIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref ownerAttackIndex);
			bool onlySyncParameters = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref onlySyncParameters, default(ForPrimitives));
			Vector3 atPos = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref atPos);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SyncAttackAnimationClientRpc(sentBy, ownerAttackIndex, onlySyncParameters, atPos);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1973553030(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 sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).DisableAllHitboxesServerRpc(sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1404788327(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 sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).DisableAllHitboxesClientRpc(sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_224874733(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)1;
			((TheBoxerAI)(object)target).SpawnShovelClientRpc(itemNOR);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2829866388(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sequenceIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sequenceIndex);
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetAttackSequenceServerRpc(sequenceIndex, sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1786351614(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sequenceIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sequenceIndex);
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetAttackSequenceClientRpc(sequenceIndex, sentBy);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2163757669(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			bool isGiveShovelAnim = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isGiveShovelAnim, default(ForPrimitives));
			Vector3 ownerPos = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref ownerPos);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetAnimWithPlayerServerRpc(playerID, isGiveShovelAnim, ownerPos);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2151956930(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			bool isGiveShovelAnim = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isGiveShovelAnim, default(ForPrimitives));
			Vector3 ownerPos = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref ownerPos);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetAnimWithPlayerClientRpc(playerID, isGiveShovelAnim, ownerPos);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1791566011(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool setEnemyLight = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref setEnemyLight, default(ForPrimitives));
			bool enableLight = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref enableLight, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetSpotlightServerRpc(sentBy, setEnemyLight, enableLight);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3638408080(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool setEnemyLight = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref setEnemyLight, default(ForPrimitives));
			bool enableLight = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref enableLight, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetSpotlightClientRpc(sentBy, setEnemyLight, enableLight);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2879605001(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			string animString = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref animString, false);
			}
			bool boolAnim = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref boolAnim, default(ForPrimitives));
			bool boolVal = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref boolVal, default(ForPrimitives));
			bool flag2 = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
			string paramString = null;
			if (flag2)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref paramString, false);
			}
			float paramFloat = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref paramFloat, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetAnimationServerRpc(sentBy, animString, boolAnim, boolVal, paramString, paramFloat);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1674142588(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			string animString = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref animString, false);
			}
			bool boolAnim = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref boolAnim, default(ForPrimitives));
			bool boolVal = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref boolVal, default(ForPrimitives));
			bool flag2 = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
			string paramString = null;
			if (flag2)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref paramString, false);
			}
			float paramFloat = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref paramFloat, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetAnimationClientRpc(sentBy, animString, boolAnim, boolVal, paramString, paramFloat);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_739170154(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int clipCase = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref clipCase);
			bool audible = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref audible, default(ForPrimitives));
			bool crowd = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref crowd, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).PlaySFXServerRpc(sentBy, clipCase, audible, crowd);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3008003237(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int sentBy = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sentBy);
			int clipCase = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref clipCase);
			bool audible = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref audible, default(ForPrimitives));
			bool crowd = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref crowd, default(ForPrimitives));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).PlaySFXClientRpc(sentBy, clipCase, audible, crowd);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_943357845(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 targetPlayerServerRpc = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref targetPlayerServerRpc);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetTargetPlayerServerRpc(targetPlayerServerRpc);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1343550192(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 targetPlayerClientRpc = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref targetPlayerClientRpc);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetTargetPlayerClientRpc(targetPlayerClientRpc);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1783695022(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			NetworkObjectReference enemyNOR = default(NetworkObjectReference);
			((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref enemyNOR, default(ForNetworkSerializable));
			int playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetTargetEnemyServerRpc(enemyNOR, playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2382220646(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			NetworkObjectReference enemyNOR = default(NetworkObjectReference);
			((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref enemyNOR, default(ForNetworkSerializable));
			int playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TheBoxerAI)(object)target).SetTargetEnemyClientRpc(enemyNOR, playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_375865059(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;
			((TheBoxerAI)(object)target).SetTargetEnemyServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_2442538025(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;
			((TheBoxerAI)(object)target).SetTargetEnemyClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	protected internal override string __getTypeName()
	{
		return "TheBoxerAI";
	}
}
public class BeatAudioItem : GrabbableObject
{
	private static ManualLogSource Logger = Plugin.Logger;

	[Space(3f)]
	[Header("Custom")]
	public TheBeatAI linkedEnemy;

	public int intendedValue;

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

	public float nearbyToStop;

	public float checkPlayerInterval;

	private float checkTimer;

	[Space]
	public Animator itemAnimator;

	public AudioSource fakeAudio;

	public AudioClip footstepSFX;

	public AudioClip alarmSFX;

	public override void Start()
	{
		((GrabbableObject)this).Start();
		if (!StartOfRound.Instance.inShipPhase || (Object)(object)StartOfRound.Instance.testRoom != (Object)null)
		{
			LinkItemToEnemy(null, overwriteLink: true);
			((GrabbableObject)this).SetScrapValue(intendedValue);
			RoundManager instance = RoundManager.Instance;
			instance.totalScrapValueInLevel += (float)intendedValue;
			HoarderBugAI.grabbableObjectsInMap.Add(((Component)this).gameObject);
		}
	}

	public override void Update()
	{
		((GrabbableObject)this).Update();
		if (((NetworkBehaviour)this).IsOwner)
		{
			if (checkTimer >= checkPlayerInterval)
			{
				checkTimer = 0f;
				DoPlayerCheck();
			}
			else
			{
				checkTimer += Time.deltaTime;
			}
		}
	}

	private void DoPlayerCheck()
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		if (!itemAnimator.GetBool("Footsteps"))
		{
			return;
		}
		for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
		{
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
			if (!((Object)(object)val == (Object)null) && val.isPlayerControlled)
			{
				Vector3 val2 = ((Component)this).transform.position + Vector3.up * 0.5f;
				Vector3 position = val.playerEye.position;
				float num = Vector3.Distance(val2, position);
				if ((num <= nearbyToStop || !Physics.Linecast(val2, position, StartOfRound.Instance.collidersAndRoomMask, (QueryTriggerInteraction)1)) && num < fakeAudio.maxDistance * distanceThresholdToStop)
				{
					Logger.LogDebug((object)$"no line between {((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} and {val.playerUsername}, going quiet");
					ToggleFakeAudio(setTo: false, sync: true);
					break;
				}
			}
		}
	}

	public override void GrabItem()
	{
		((GrabbableObject)this).GrabItem();
		Logger.LogDebug((object)$"GrabItem(): playerHeldBy {base.playerHeldBy} | linkedEnemy {linkedEnemy}");
		if ((Object)(object)base.playerHeldBy != (Object)null)
		{
			if (base.playerHeldBy.isInsideFactory && (Object)(object)linkedEnemy != (Object)null && !((EnemyAI)linkedEnemy).isEnemyDead)
			{
				Logger.LogDebug((object)"TOGGLE ALARM");
				ToggleAlarm(setTo: true);
			}
			else
			{
				itemAnimator.SetFloat("LookSpeedMultiplier", Random.Range(0.1f, 0.8f));
				itemAnimator.SetBool("Looking", true);
			}
		}
	}

	public override void DiscardItem()
	{
		((GrabbableObject)this).DiscardItem();
		if (itemAnimator.GetBool("Looking"))
		{
			itemAnimator.SetBool("Looking", false);
		}
		if ((Object)(object)linkedEnemy == (Object)null || ((EnemyAI)linkedEnemy).isEnemyDead || ((EnemyAI)linkedEnemy).currentBehaviourStateIndex != 2)
		{
			ToggleFakeAudio(setTo: false);
			ToggleAlarm(setTo: false);
		}
	}

	public void ToggleAlarm(bool setTo, bool sync = false)
	{
		if (sync)
		{
			ToggleAlarmServerRpc(setTo);
		}
		else
		{
			SetAlarmTo(setTo);
		}
	}

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

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

	private void SetAlarmTo(bool setTo)
	{
		if (!setTo)
		{
			itemAnimator.SetBool("Alarm", false);
		}
		if (setTo)
		{
			Logger.LogDebug((object)"setting trigger Alarm");
			itemAnimator.SetBool("Footsteps", false);
			itemAnimator.SetBool("Alarm", true);
			if ((Object)(object)linkedEnemy != (Object)null)
			{
				linkedEnemy.GoIntoChase(enrage: true);
			}
		}
	}

	public void ToggleFakeAudio(bool setTo, bool sync = false)
	{
		if (sync)
		{
			ToggleFakeAudioServerRpc(setTo);
		}
		else
		{
			SetFakeAudioTo(setTo);
		}
	}

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

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

	private void SetFakeAudioTo(bool setTo)
	{
		if (!setTo)
		{
			itemAnimator.SetBool("Footsteps", false);
		}
		if (setTo)
		{
			Logger.LogDebug((object)"setting trigger Footsteps");
			itemAnimator.SetBool("Alarm", false);
			itemAnimator.SetBool("Footsteps", true);
		}
	}

	public void LinkItemToEnemy(TheBeatAI enemy = null, bool overwriteLink = false)
	{
		if ((Object)(object)enemy == (Object)null)
		{
			enemy = Object.FindAnyObjectByType<TheBeatAI>();
			if ((Object)(object)enemy == (Object)null)
			{
				Logger.LogDebug((object)"no beat enemy found to link item to");
				return;
			}
		}
		if (!overwriteLink && (Object)(object)enemy.linkedItem != (Object)null)
		{
			Logger.LogDebug((object)"enemy already linked to item");
			return;
		}
		linkedEnemy = enemy;
		linkedEnemy.linkedItem = this;
		Logger.LogDebug((object)$"linked ITEM {this} #{((NetworkBehaviour)this).NetworkObjectId} to ENEMY {linkedEnemy} #{((NetworkBehaviour)linkedEnemy).NetworkObjectId}");
	}

	public void UnlinkItemFromEnemy(TheBeatAI enemy = null, bool keepItemLinkedToEnemy = true)
	{
		if ((Object)(object)enemy == (Object)null)
		{
			enemy = ((!((Object)(object)linkedEnemy != (Object)null)) ? Object.FindAnyObjectByType<TheBeatAI>() : linkedEnemy);
			if ((Object)(object)enemy == (Object)null)
			{
				Logger.LogDebug((object)"no beat enemy found to link unitem from");
				return;
			}
		}
		linkedEnemy.linkedItem = null;
		if (!keepItemLinkedToEnemy)
		{
			linkedEnemy = null;
		}
		ToggleAlarm(setTo: false);
		ToggleFakeAudio(setTo: false);
	}

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

	protected override void __initializeRpcs()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Expected O, but got Unknown
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Expected O, but got Unknown
		((NetworkBehaviour)this).__registerRpc(4253543015u, new RpcReceiveHandler(__rpc_handler_4253543015), "ToggleAlarmServerRpc");
		((NetworkBehaviour)this).__registerRpc(4136750616u, new RpcReceiveHandler(__rpc_handler_4136750616), "ToggleAlarmClientRpc");
		((NetworkBehaviour)this).__registerRpc(3305329290u, new RpcReceiveHandler(__rpc_handler_3305329290), "ToggleFakeAudioServerRpc");
		((NetworkBehaviour)this).__registerRpc(3841443489u, new RpcReceiveHandler(__rpc_handler_3841443489), "ToggleFakeAudioClientRpc");
		((GrabbableObject)this).__initializeRpcs();
	}

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

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

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

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

	protected internal override string __getTypeName()
	{
		return "BeatAudioItem";
	}
}
[CreateAssetMenu(menuName = "LCBeatBoxerMod/AllAssets")]
public class AllAssets : ScriptableObject
{
	public EnemyType[] allEnemies;

	[Space(3f)]
	public LevelWithRarity[] allLevelRarities;

	[Space(3f)]
	public Item[] allItems;

	[Space(3f)]
	public TerminalNode[] allBestiaryPages;

	[Space(3f)]
	public TerminalKeyword[] allKeywords;

	[Space(3f)]
	public GameObject[] allNetworkPrefabs;
}
public class AssetsCollection
{
	private static ManualLogSource Logger = Plugin.Logger;

	public static Item shovelItem;

	public static AudioClip grabSFX;

	public static AudioClip dropSFX;

	public static Sprite scrapIcon;

	public static Sprite handIcon;

	public static Material mapDotRedMat;

	public static Material backUpMapDotMat;

	public static void GetEnemyAssets(SpawnableEnemyWithRarity[] enemies)
	{
		if (enemies == null || enemies.Length == 0)
		{
			Logger.LogWarning((object)"GetEnemyAssets() called with null enemies");
			return;
		}
		foreach (SpawnableEnemyWithRarity val in enemies)
		{
			if (val == null || (Object)(object)val.enemyType == (Object)null)
			{
				break;
			}
			EnemyType enemyType = val.enemyType;
			if (!((Object)(object)enemyType == (Object)null) && enemyType.enemyName != null && !((Object)(object)enemyType.enemyPrefab == (Object)null) && enemyType.enemyName == "Flowerman")
			{
				Logger.LogDebug((object)"Trying to build MAP DOT MATERIAL");
				GameObject gameObject = ((Component)enemyType.enemyPrefab.transform.Find("MapDot (2)")).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					Logger.LogDebug((object)"no MapDot found");
					break;
				}
				MeshRenderer component = gameObject.GetComponent<MeshRenderer>();
				if ((Object)(object)component == (Object)null || (Object)(object)((Renderer)component).material == (Object)null || ((Object)((Renderer)component).material).name == null)
				{
					Logger.LogDebug((object)"no meshRenderer or material found");
					break;
				}
				string text = "MapDotRed (Instance)";
				if (((Object)((Renderer)component).material).name != text)
				{
					Logger.LogDebug((object)("meshRenderer material is not " + text));
					break;
				}
				mapDotRedMat = ((Renderer)component).material;
				Logger.LogDebug((object)("successfully found " + ((Object)mapDotRedMat).name));
			}
		}
	}

	public static void GetItemAssets(Item[] itemsList)
	{
		foreach (Item val in itemsList)
		{
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)shovelItem == (Object)null && ((Object)val).name == "Shovel")
				{
					Logger.LogDebug((object)$"Trying to build shovelItem with prefab {val.spawnPrefab}");
					shovelItem = val;
				}
				else if ((Object)(object)scrapIcon == (Object)null && (Object)(object)val.itemIcon != (Object)null && ((Object)val.itemIcon).name == "ScrapItemIcon2")
				{
					scrapIcon = val.itemIcon;
					Logger.LogDebug((object)$"successfully found {scrapIcon}");
				}
				else if ((Object)(object)grabSFX == (Object)null && (Object)(object)val.grabSFX != (Object)null && ((Object)val.grabSFX).name == "ShovelPickUp")
				{
					grabSFX = val.grabSFX;
					Logger.LogDebug((object)$"found {grabSFX}");
				}
				else if ((Object)(object)dropSFX == (Object)null && (Object)(object)val.dropSFX != (Object)null && ((Object)val.dropSFX).name == "DropPlasticLarge")
				{
					dropSFX = val.dropSFX;
					Logger.LogDebug((object)$"found {dropSFX}");
				}
			}
		}
	}

	public static void GetMiscAssets(StartOfRound __instance)
	{
		Logger.LogDebug((object)"Trying to build HAND ICON");
		if ((Object)(object)__instance != (Object)null && (Object)(object)__instance.allPlayerScripts[0] != (Object)null && (Object)(object)__instance.allPlayerScripts[0].grabItemIcon != (Object)null)
		{
			handIcon = __instance.allPlayerScripts[0].grabItemIcon;
		}
	}
}
public class Configs
{
	private static ManualLogSource Logger = Plugin.Logger;

	public static ConfigEntry<int> overrideRarityAll;

	public static ConfigEntry<bool> printDebugEnemy;

	public static ConfigEntry<bool> printDebugEnemyAI;

	public Configs(ConfigFile cfg)
	{
		overrideRarityAll = cfg.Bind<int>("Customization", "Override Rarity All", -1, "Set this value to 1 or above to use that value as the rarity of both enemies on all levels, instead of the default values.\nLobby host's values are used.");
		printDebugEnemy = cfg.Bind<bool>("Debug", "Print DebugEnemy", true, "Set this to true to print information of the more important enemy behaviours to the debug log window.");
		printDebugEnemyAI = cfg.Bind<bool>("Debug", "Print debugEnemyAI", false, "Set this to true to print information of every little single individual step the enemies perform to the debug log window.");
	}

	public static void DisplayConfigs()
	{
		if (overrideRarityAll.Value >= 1)
		{
			Logger.LogInfo((object)$"Config [Override Rarity All] is set to a value of {overrideRarityAll.Value}");
		}
		if (printDebugEnemyAI.Value)
		{
			Logger.LogInfo((object)"Config [Print debugEnemyAI] is set to TRUE. This mod's enemies will print all their information to this log.");
		}
		else if (printDebugEnemy.Value)
		{
			Logger.LogInfo((object)"Config [Print DebugEnemy] is set to TRUE. This mod's enemies will print their important information to this log.");
		}
		else
		{
			Logger.LogInfo((object)"Config [Print DebugEnemy] is set to FALSE. This mod's enemies won't print their primary debug information.");
		}
	}
}
public enum AttackAnimationNames
{
	BoxerHighPunch,
	BoxerLowSweep,
	BoxerUppercut,
	BoxerStun,
	BoxerFakeOut
}
[CreateAssetMenu(menuName = "LCBeatBoxerMod/DataContainers/AttackData")]
public class AttackData : ScriptableObject
{
	[Header("General")]
	public AttackAnimationNames animationName;

	[Space(3f)]
	[Header("Parameters")]
	[Tooltip("Determines if the enemy will cancel hits it receives itself.")]
	public bool canBlock = true;

	[Tooltip("Determines if the enemy will be stunned if hit while vulnerable.")]
	public bool canStun = true;

	public float stunTime = 1.5f;

	[Space(3f)]
	[Header("Audiovisual")]
	public AudioClip creatureSFX;

	public AudioClip audienceSFX;
}
[CreateAssetMenu(menuName = "LCBeatBoxerMod/DataContainers/AttackSequence")]
public class AttackSequence : ScriptableObject
{
	public AttackData[] attacks;
}
[CreateAssetMenu(menuName = "LCBeatBoxerMod/DataContainers/LevelWithRarity")]
public class LevelWithRarity : ScriptableObject
{
	public int levelID;

	public SpawnableEnemyWithRarity[] enemiesWithRarities;
}
public class HarmonyPatches
{
	[HarmonyPatch(typeof(GameNetworkManager), "Start")]
	public class NewGameNetworkManagerStart
	{
		[HarmonyPostfix]
		public static void Init(GameNetworkManager __instance)
		{
			if (Plugin.allAssets.allNetworkPrefabs == null || Plugin.allAssets.allNetworkPrefabs.Length == 0)
			{
				Logger.LogError((object)"allNetworkPrefabs is not valid, please fix");
				return;
			}
			for (int i = 0; i < Plugin.allAssets.allNetworkPrefabs.Length; i++)
			{
				NetworkManager.Singleton.AddNetworkPrefab(Plugin.allAssets.allNetworkPrefabs[i]);
			}
		}
	}

	[HarmonyPatch(typeof(StartOfRound), "Start")]
	public class NewStartOfRoundStart
	{
		[HarmonyPrefix]
		public static void StartPrefix(StartOfRound __instance)
		{
			if (alreadySetUp)
			{
				return;
			}
			AssetsCollection.GetEnemyAssets(__instance.levels[0].Enemies.ToArray());
			AssetsCollection.GetItemAssets(__instance.allItemsList.itemsList.ToArray());
			AssetsCollection.GetMiscAssets(__instance);
			int debugOtherEnemyCase = RegisterData.debugOtherEnemyCase;
			if (debugOtherEnemyCase != -1)
			{
				SelectableLevel[] levels = __instance.levels;
				foreach (SelectableLevel val in levels)
				{
					Logger.LogError((object)$"!!!Overwriting all {val} other enemies' rarities to {debugOtherEnemyCase}!!!");
					foreach (SpawnableEnemyWithRarity enemy in val.Enemies)
					{
						enemy.rarity = debugOtherEnemyCase;
					}
					foreach (SpawnableEnemyWithRarity outsideEnemy in val.OutsideEnemies)
					{
						outsideEnemy.rarity = debugOtherEnemyCase;
					}
				}
			}
			EnemyType[] allEnemies = Plugin.allAssets.allEnemies;
			for (int i = 0; i < allEnemies.Length; i++)
			{
				RegisterData.SetUpEnemy(allEnemies[i], __instance);
			}
			RegisterData.AddAllEnemyTypesToLevels();
			Item[] allItems = Plugin.allAssets.allItems;
			for (int i = 0; i < allItems.Length; i++)
			{
				RegisterData.SetUpItem(allItems[i], __instance);
			}
			alreadySetUp = true;
		}
	}

	[HarmonyPatch(typeof(Terminal), "Awake")]
	public class NewTerminalAwake
	{
		[HarmonyPostfix]
		public static void AwakePostfix(Terminal __instance)
		{
			List<TerminalKeyword> list = __instance.terminalNodes.allKeywords.ToList();
			list.AddRange(Plugin.allAssets.allKeywords);
			__instance.terminalNodes.allKeywords = list.ToArray();
			Logger.LogDebug((object)$"updated allKeywords to Length {__instance.terminalNodes.allKeywords.Length}");
			RegisterData.AddEnemyFilesToTerminal(__instance);
		}
	}

	private static ManualLogSource Logger = Plugin.Logger;

	private static bool alreadySetUp = false;
}
[BepInPlugin("com.github.SimonTendo.LCBeatBoxerMod", "LCBeatBoxerMod", "0.3.4")]
public class Plugin : BaseUnityPlugin
{
	internal static ManualLogSource Logger;

	public static AssetBundle assetBundle;

	public static AllAssets allAssets;

	public static Configs myConfig { get; internal set; }

	private void Awake()
	{
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		Logger = ((BaseUnityPlugin)this).Logger;
		Logger.LogInfo((object)"Plugin LCBeatBoxerMod is loaded!");
		assetBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "beatboxerassetbundle"));
		if ((Object)(object)assetBundle == (Object)null)
		{
			Logger.LogError((object)"Failed to load LCBeatBoxerMod AssetBundle");
			return;
		}
		allAssets = assetBundle.LoadAsset<AllAssets>("Assets/LCBeatBoxerMod/ScriptableObjects/AllAssets.asset");
		if ((Object)(object)allAssets == (Object)null)
		{
			Logger.LogError((object)"Failed to load LCBeatBoxerMod AllAssets");
			return;
		}
		Logger.LogDebug((object)"Loaded LCBeatBoxerMod AssetBundle and AllAssets");
		myConfig = new Configs(((BaseUnityPlugin)this).Config);
		Configs.DisplayConfigs();
		new Harmony("LCBeatBoxerMod").PatchAll();
		HarmonyFileLog.Enabled = false;
		UnityNetcodePatcher();
	}

	public static bool ConvertToBool(int value)
	{
		return value == 1;
	}

	public static bool ConvertToBool(string value)
	{
		return value.ToLower() == "true";
	}

	public static int GetEnemyIndexInRoundManager(EnemyAI enemy)
	{
		int result = 0;
		if ((Object)(object)enemy != (Object)null)
		{
			for (int i = 0; i < RoundManager.Instance.SpawnedEnemies.Count; i++)
			{
				if ((Object)(object)RoundManager.Instance.SpawnedEnemies[i] == (Object)(object)enemy)
				{
					result = i;
					break;
				}
			}
		}
		return result;
	}

	public static int DebugLogLevel()
	{
		int num = 0;
		if (Configs.printDebugEnemyAI.Value)
		{
			num = 2;
			Logger.LogDebug((object)$"[Print debugEnemyAI]: {Configs.printDebugEnemyAI.Value} || toReturn = {num}");
			return num;
		}
		if (Application.isEditor)
		{
			num = 1;
			Logger.LogDebug((object)$"isEditor: {Application.isEditor} || toReturn = {num}");
			return 1;
		}
		if (Configs.printDebugEnemy.Value)
		{
			num = 1;
			Logger.LogDebug((object)$"[Print DebugEnemy]: {Configs.printDebugEnemy.Value} || toReturn = {num}");
			return 1;
		}
		PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
		foreach (PlayerControllerB val in allPlayerScripts)
		{
			if ((Object)(object)val != (Object)null && val.playerUsername != null && val.playerUsername == "simtendo")
			{
				num = 1;
				Logger.LogDebug((object)$"playing with {val.playerUsername} || toReturn = {num}");
				return num;
			}
		}
		Logger.LogDebug((object)$"toReturn = {num}");
		return num;
	}

	private static void UnityNetcodePatcher()
	{
		Type[] types = Assembly.GetExecutingAssembly().GetTypes();
		for (int i = 0; i < types.Length; i++)
		{
			MethodInfo[] methods = types[i].GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
				{
					methodInfo.Invoke(null, null);
				}
			}
		}
	}
}
public class RegisterData
{
	private static ManualLogSource Logger = Plugin.Logger;

	public static int debugOtherEnemyCase = -1;

	public static void SetUpEnemy(EnemyType enemyType, StartOfRound startOfRound = null)
	{
		if ((Object)(object)startOfRound == (Object)null)
		{
			startOfRound = StartOfRound.Instance;
		}
		Logger.LogDebug((object)$"Setting up '{enemyType}':");
		AddMapDotMat(enemyType);
		AddInteractHandIcon(enemyType);
		AddEnemyToDebugMenu(enemyType);
	}

	public static void AddAllEnemyTypesToLevels()
	{
		for (int i = 0; i < Plugin.allAssets.allLevelRarities.Length; i++)
		{
			LevelWithRarity levelWithRarity = Plugin.allAssets.allLevelRarities[i];
			Logger.LogDebug((object)$"setting up for {levelWithRarity}");
			for (int j = 0; j < StartOfRound.Instance.levels.Length; j++)
			{
				SelectableLevel val = StartOfRound.Instance.levels[j];
				if ((levelWithRarity.levelID == -1 && val.levelID > 12) || levelWithRarity.levelID == val.levelID)
				{
					RegisterEnemyToLevel(levelWithRarity, val);
				}
			}
		}
	}

	public static void RegisterEnemyToLevel(LevelWithRarity rarityData, SelectableLevel level)
	{
		SpawnableEnemyWithRarity[] enemiesWithRarities = rarityData.enemiesWithRarities;
		foreach (SpawnableEnemyWithRarity val in enemiesWithRarities)
		{
			if (Configs.overrideRarityAll.Value >= 1)
			{
				val.rarity = Configs.overrideRarityAll.Value;
			}
			if (val.enemyType.isOutsideEnemy)
			{
				Logger.LogDebug((object)$"adding OUTside {val.enemyType.enemyName} to {level} #{level.levelID} with rarity {val.rarity}");
				level.OutsideEnemies.Add(val);
			}
			else
			{
				Logger.LogDebug((object)$"adding INside {val.enemyType.enemyName} to {level} #{level.levelID} with rarity {val.rarity}");
				level.Enemies.Add(val);
			}
		}
	}

	private static void AddEnemyToDebugMenu(EnemyType enemyToAdd)
	{
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Expected O, but got Unknown
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Expected O, but got Unknown
		if ((Object)(object)enemyToAdd == (Object)null)
		{
			Logger.LogWarning((object)"enemyToAdd given to AddEnemyToDebugMenu() is null!");
			return;
		}
		Logger.LogDebug((object)("starting AddEnemyToDebugMenu(" + ((Object)enemyToAdd).name + ")"));
		QuickMenuManager val = Object.FindAnyObjectByType<QuickMenuManager>();
		if ((Object)(object)val == (Object)null)
		{
			Logger.LogWarning((object)"failed to find debugMenu, try later");
		}
		else if (enemyToAdd.isOutsideEnemy)
		{
			val.testAllEnemiesLevel.OutsideEnemies.Add(new SpawnableEnemyWithRarity(enemyToAdd, 0));
		}
		else
		{
			val.testAllEnemiesLevel.Enemies.Add(new SpawnableEnemyWithRarity(enemyToAdd, 0));
		}
	}

	public static void AddEnemyToLevel(EnemyType enemyToAdd, SelectableLevel levelToAddTo, int rarityOnLevel)
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Expected O, but got Unknown
		if ((Object)(object)enemyToAdd == (Object)null)
		{
			Logger.LogWarning((object)"enemyToAdd given to AddEnemyToLevel() is null!");
			return;
		}
		if ((Object)(object)levelToAddTo == (Object)null)
		{
			Logger.LogWarning((object)"levelToAddTo given to AddEnemyToLevel() is null!");
			return;
		}
		if (rarityOnLevel <= 0)
		{
			Logger.LogWarning((object)"rarityOnLevel given to AddEnemyToLevel() is too low!");
			return;
		}
		Logger.LogInfo((object)$"starting AddEnemyToLevel({((Object)enemyToAdd).name}, {((Object)levelToAddTo).name}, {rarityOnLevel})");
		levelToAddTo.Enemies.Add(new SpawnableEnemyWithRarity(enemyToAdd, rarityOnLevel));
		Logger.LogDebug((object)"successfully reached end!");
	}

	private static void AddMapDotMat(EnemyType enemyType)
	{
		if ((Object)(object)enemyType == (Object)null || (Object)(object)enemyType.enemyPrefab == (Object)null)
		{
			Logger.LogWarning((object)"AddMapDotMat() called with null enemyType");
			return;
		}
		Logger.LogDebug((object)("starting AddMapDotMat(" + ((Object)enemyType).name + ")"));
		Material material = (((Object)(object)AssetsCollection.mapDotRedMat != (Object)null) ? AssetsCollection.mapDotRedMat : AssetsCollection.backUpMapDotMat);
		Transform val = enemyType.enemyPrefab.transform.Find("MapDot");
		if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject.GetComponent<MeshRenderer>() == (Object)null)
		{
			Logger.LogError((object)$"Add a child called 'MapDot' with MeshRenderer to {enemyType.enemyPrefab}");
			return;
		}
		((Component)val).gameObject.SetActive(true);
		((Renderer)((Component)val).gameObject.GetComponent<MeshRenderer>()).material = material;
	}

	private static void AddInteractHandIcon(EnemyType enemyType)
	{
		if ((Object)(object)AssetsCollection.handIcon == (Object)null)
		{
			Logger.LogDebug((object)"AssetsCollection does not have handIcon");
			return;
		}
		if ((Object)(object)enemyType == (Object)null || (Object)(object)enemyType.enemyPrefab == (Object)null)
		{
			Logger.LogWarning((object)"AddInterHandIcon() called with null enemyType");
			return;
		}
		InteractTrigger[] componentsInChildren = enemyType.enemyPrefab.GetComponentsInChildren<InteractTrigger>();
		if (componentsInChildren == null || componentsInChildren.Length == 0)
		{
			Logger.LogDebug((object)$"AddInterHandIcon(): enemyType {enemyType} does not have interacts");
			return;
		}
		Logger.LogDebug((object)("starting AddInteractHandIcon(" + ((Object)enemyType).name + ")"));
		InteractTrigger[] array = componentsInChildren;
		for (int i = 0; i < array.Length; i++)
		{
			array[i].hoverIcon = AssetsCollection.handIcon;
		}
	}

	public static void SetUpItem(Item item, StartOfRound startOfRound = null)
	{
		if ((Object)(object)item == (Object)null)
		{
			Logger.LogWarning((object)"item given to SetUpItem() is null!");
			return;
		}
		if ((Object)(object)startOfRound == (Object)null)
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				Logger.LogWarning((object)"startOfRound and StartOfRound.Instance given to SetUpItem() are both null!");
				return;
			}
			startOfRound = StartOfRound.Instance;
		}
		AddItemToItemsList(item, startOfRound);
	}

	private static void AddItemToItemsList(Item item, StartOfRound __instance)
	{
		if ((Object)(object)__instance.allItemsList == (Object)null || __instance.allItemsList.itemsList == null)
		{
			Logger.LogWarning((object)"allItemsList or itemsList in StartOfRound.Instance is null!");
			return;
		}
		item.itemIcon = AssetsCollection.scrapIcon;
		item.grabSFX = AssetsCollection.grabSFX;
		item.dropSFX = AssetsCollection.dropSFX;
		Logger.LogDebug((object)("adding item " + item.itemName + " to StartOfRound.Instance.allItemsList.itemsList"));
		__instance.allItemsList.itemsList.Add(item);
	}

	public static void AddEnemyFilesToTerminal(Terminal terminalScript)
	{
		TerminalKeyword infoKeyword = GetInfoKeyword(terminalScript.terminalNodes.allKeywords);
		List<CompatibleNoun> list = null;
		if ((Object)(object)infoKeyword != (Object)null)
		{
			list = infoKeyword.compatibleNouns.ToList();
		}
		for (int i = 0; i < Plugin.allAssets.allBestiaryPages.Length; i++)
		{
			TerminalNode val = Plugin.allAssets.allBestiaryPages[i];
			int count = terminalScript.enemyFiles.Count;
			Logger.LogDebug((object)$"Setting up enemy file {val} with ID: [{count}]");
			terminalScript.enemyFiles.Add(val);
			val.creatureFileID = count;
			GameObject val2 = null;
			for (int j = 0; j < Plugin.allAssets.allEnemies.Length; j++)
			{
				EnemyType val3 = Plugin.allAssets.allEnemies[j];
				if (val3.enemyName.Contains(val.creatureName))
				{
					val2 = val3.enemyPrefab;
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				ScanNodeProperties componentInChildren = val2.GetComponentInChildren<ScanNodeProperties>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.creatureScanID = count;
					Logger.LogDebug((object)$"set creatureScanID for {((Object)val2).name} to {componentInChildren.creatureScanID}");
				}
			}
			else
			{
				Logger.LogWarning((object)$"failed to find prefab ({val2}) or scan node for {val.creatureName}");
			}
			list?.Add(SetEnemyInfoCnoun(val, infoKeyword));
		}
		if (list != null)
		{
			infoKeyword.compatibleNouns = list.ToArray();
		}
	}

	private static TerminalKeyword GetInfoKeyword(TerminalKeyword[] allKeywords)
	{
		foreach (TerminalKeyword val in allKeywords)
		{
			if (val.word == "info")
			{
				Logger.LogDebug((object)$"found {val}");
				return val;
			}
		}
		Logger.LogWarning((object)"failed to find TerminalKeyword 'info', bestiary files cannot be accessed using this keyword");
		return null;
	}

	private static CompatibleNoun SetEnemyInfoCnoun(TerminalNode enemyFile, TerminalKeyword infoVerb)
	{
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Expected O, but got Unknown
		TerminalKeyword val = null;
		TerminalKeyword[] allKeywords = Plugin.allAssets.allKeywords;
		foreach (TerminalKeyword val2 in allKeywords)
		{
			if ((Object)(object)val2.specialKeywordResult == (Object)(object)enemyFile)
			{
				val2.defaultVerb = infoVerb;
				val = val2;
				Logger.LogDebug((object)$"successfully found keyword '{val2}' with defaultVerb '{val2.defaultVerb}' to link to node '{enemyFile}'");
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			Logger.LogWarning((object)$"SetEnemyInfoCnoun({enemyFile}, {infoVerb}) did not find keyword for noun");
		}
		Logger.LogDebug((object)$"Created new CompatibleNoun with result '{enemyFile}' and noun '{val}'");
		return new CompatibleNoun(val, enemyFile);
	}
}
[CompilerGenerated]
[EditorBrowsable(EditorBrowsableState.Never)]
[GeneratedCode("Unity.MonoScriptGenerator.MonoScriptInfoGenerator", null)]
internal class UnitySourceGeneratedAssemblyMonoScriptTypes_v1
{
	private struct MonoScriptData
	{
		public byte[] FilePathsData;

		public byte[] TypesData;

		public int TotalTypes;

		public int TotalFiles;

		public bool IsEditorOnly;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	private static MonoScriptData Get()
	{
		MonoScriptData result = default(MonoScriptData);
		result.FilePathsData = new byte[813]
		{
			0, 0, 0, 1, 0, 0, 0, 53, 92, 65,
			115, 115, 101, 116, 115, 92, 76, 67, 66, 101,
			97, 116, 66, 111, 120, 101, 114, 77, 111, 100,
			92, 83, 99, 114, 105, 112, 116, 115, 92, 67,
			111, 109, 98, 97, 116, 92, 72, 105, 116, 98,
			111, 120, 83, 99, 114, 105, 112, 116, 46, 99,
			115, 0, 0, 0, 1, 0, 0, 0, 51, 92,
			65, 115, 115, 101, 116, 115, 92, 76, 67, 66,
			101, 97, 116, 66, 111, 120, 101, 114, 77, 111,
			100, 92, 83, 99, 114, 105, 112, 116, 115, 92,
			69, 110, 101, 109, 121, 65, 73, 92, 84, 104,
			101, 66, 101, 97, 116, 65, 73, 46, 99, 115,
			0, 0, 0, 1, 0, 0, 0, 52, 92, 65,
			115, 115, 101, 116, 115, 92, 76, 67, 66, 101,
			97, 116, 66, 111, 120, 101, 114, 77, 111, 100,
			92, 83, 99, 114, 105, 112, 116, 115, 92, 69,
			110, 101, 109, 121, 65, 73, 92, 84, 104, 101,
			66, 111, 120, 101, 114, 65, 73, 46, 99, 115,
			0, 0, 0, 1, 0, 0, 0, 63, 92, 65,
			115, 115, 101, 116, 115, 92, 76, 67, 66, 101,
			97, 116, 66, 111, 120, 101, 114, 77, 111, 100,
			92, 83, 99, 114, 105, 112, 116, 115, 92, 71,
			114, 97, 98, 98, 97, 98, 108, 101, 79, 98,
			106, 101, 99, 116, 92, 66, 101, 97, 116, 65,
			117, 100, 105, 111, 73, 116, 101, 109, 46, 99,
			115, 0, 0, 0, 1, 0, 0, 0, 47, 92,
			65, 115, 115, 101, 116, 115, 92, 76, 67, 66,
			101, 97, 116, 66, 111, 120, 101, 114, 77, 111,
			100, 92, 83, 99, 114, 105, 112, 116, 115, 92,
			77, 111, 100, 92, 65, 108, 108, 65, 115, 115,
			101, 116, 115, 46, 99, 115, 0, 0, 0, 1,
			0, 0, 0, 54, 92, 65, 115, 115, 101, 116,
			115, 92, 76, 67, 66, 101, 97, 116, 66, 111,
			120, 101, 114, 77, 111, 100, 92, 83, 99, 114,
			105, 112, 116, 115, 92, 77, 111, 100, 92, 65,
			115, 115, 101, 116, 115, 67, 111, 108, 108, 101,
			99, 116, 105, 111, 110, 46, 99, 115, 0, 0,
			0, 1, 0, 0, 0, 45, 92, 65, 115, 115,
			101, 116, 115, 92, 76, 67, 66, 101, 97, 116,
			66, 111, 120, 101, 114, 77, 111, 100, 92, 83,
			99, 114, 105, 112, 116, 115, 92, 77, 111, 100,
			92, 67, 111, 110, 102, 105, 103, 115, 46, 99,
			115, 0, 0, 0, 1, 0, 0, 0, 63, 92,
			65, 115, 115, 101, 116, 115, 92, 76, 67, 66,
			101, 97, 116, 66, 111, 120, 101, 114, 77, 111,
			100, 92, 83, 99, 114, 105, 112, 116, 115, 92,
			77, 111, 100, 92, 68, 97, 116, 97, 67, 111,
			110, 116, 97, 105, 110, 101, 114, 115, 92, 65,
			116, 116, 97, 99, 107, 68, 97, 116, 97, 46,
			99, 115, 0, 0, 0, 1, 0, 0, 0, 67,
			92, 65, 115, 115, 101, 116, 115, 92, 76, 67,
			66, 101, 97, 116, 66, 111, 120, 101, 114, 77,
			111, 100, 92, 83, 99, 114, 105, 112, 116, 115,
			92, 77, 111, 100, 92, 68, 97, 116, 97, 67,
			111, 110, 116, 97, 105, 110, 101, 114, 115, 92,
			65, 116, 116, 97, 99, 107, 83, 101, 113, 117,
			101, 110, 99, 101, 46, 99, 115, 0, 0, 0,
			1, 0, 0, 0, 68, 92, 65, 115, 115, 101,
			116, 115, 92, 76, 67, 66, 101, 97, 116, 66,
			111, 120, 101, 114, 77, 111, 100, 92, 83, 99,
			114, 105, 112, 116, 115, 92, 77, 111, 100, 92,
			68, 97, 116, 97, 67, 111, 110, 116, 97, 105,
			110, 101, 114, 115, 92, 76, 101, 118, 101, 108,
			87, 105, 116, 104, 82, 97, 114, 105, 116, 121,
			46, 99, 115, 0, 0, 0, 4, 0, 0, 0,
			52, 92, 65, 115, 115, 101, 116, 115, 92, 76,
			67, 66, 101, 97, 116, 66, 111, 120, 101, 114,
			77, 111, 100, 92, 83, 99, 114, 105, 112, 116,
			115, 92, 77, 111, 100, 92, 72, 97, 114, 109,
			111, 110, 121, 80, 97, 116, 99, 104, 101, 115,
			46, 99, 115, 0, 0, 0, 1, 0, 0, 0,
			44, 92, 65, 115, 115, 101, 116, 115, 92, 76,
			67, 66, 101, 97, 116, 66, 111, 120, 101, 114,
			77, 111, 100, 92, 83, 99, 114, 105, 112, 116,
			115, 92, 77, 111, 100, 92, 80, 108, 117, 103,
			105, 110, 46, 99, 115, 0, 0, 0, 1, 0,
			0, 0, 50, 92, 65, 115, 115, 101, 116, 115,
			92, 76, 67, 66, 101, 97, 116, 66, 111, 120,
			101, 114, 77, 111, 100, 92, 83, 99, 114, 105,
			112, 116, 115, 92, 77, 111, 100, 92, 82, 101,
			103, 105, 115, 116, 101, 114, 68, 97, 116, 97,
			46, 99, 115
		};
		result.TypesData = new byte[347]
		{
			0, 0, 0, 0, 13, 124, 72, 105, 116, 98,
			111, 120, 83, 99, 114, 105, 112, 116, 0, 0,
			0, 0, 10, 124, 84, 104, 101, 66, 101, 97,
			116, 65, 73, 0, 0, 0, 0, 11, 124, 84,
			104, 101, 66, 111, 120, 101, 114, 65, 73, 0,
			0, 0, 0, 14, 124, 66, 101, 97, 116, 65,
			117, 100, 105, 111, 73, 116, 101, 109, 0, 0,
			0, 0, 10, 124, 65, 108, 108, 65, 115, 115,
			101, 116, 115, 0, 0, 0, 0, 17, 124, 65,
			115, 115, 101, 116, 115, 67, 111, 108, 108, 101,
			99, 116, 105, 111, 110, 0, 0, 0, 0, 8,
			124, 67, 111, 110, 102, 105, 103, 115, 0, 0,
			0, 0, 11, 124, 65, 116, 116, 97, 99, 107,
			68, 97, 116, 97, 0, 0, 0, 0, 15, 124,
			65, 116, 116, 97, 99, 107, 83, 101, 113, 117,
			101, 110, 99, 101, 0, 0, 0, 0, 16, 124,
			76, 101, 118, 101, 108, 87, 105, 116, 104, 82,
			97, 114, 105, 116, 121, 0, 0, 0, 0, 15,
			124, 72, 97, 114, 109, 111, 110, 121, 80, 97,
			116, 99, 104, 101, 115, 0, 0, 0, 0, 41,
			72, 97, 114, 109, 111, 110, 121, 80, 97, 116,
			99, 104, 101, 115, 124, 78, 101, 119, 71, 97,
			109, 101, 78, 101, 116, 119, 111, 114, 107, 77,
			97, 110, 97, 103, 101, 114, 83, 116, 97, 114,
			116, 0, 0, 0, 0, 35, 72, 97, 114, 109,
			111, 110, 121, 80, 97, 116, 99, 104, 101, 115,
			124, 78, 101, 119, 83, 116, 97, 114, 116, 79,
			102, 82, 111, 117, 110, 100, 83, 116, 97, 114,
			116, 0, 0, 0, 0, 31, 72, 97, 114, 109,
			111, 110, 121, 80, 97, 116, 99, 104, 101, 115,
			124, 78, 101, 119, 84, 101, 114, 109, 105, 110,
			97, 108, 65, 119, 97, 107, 101, 0, 0, 0,
			0, 7, 124, 80, 108, 117, 103, 105, 110, 0,
			0, 0, 0, 13, 124, 82, 101, 103, 105, 115,
			116, 101, 114, 68, 97, 116, 97
		};
		result.TotalFiles = 13;
		result.TotalTypes = 16;
		result.IsEditorOnly = false;
		return result;
	}
}
namespace __GEN;

internal class NetworkVariableSerializationHelper
{
	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeSerialization()
	{
	}
}