using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DrConEnemy.Configuration;
using GameNetcodeStuff;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using ReavsStuff.DrConEnemy.NetcodePatcher;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.VFX;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ReavsStuff.DrConEnemy")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1")]
[assembly: AssemblyProduct("DrConEnemy")]
[assembly: AssemblyTitle("ReavsStuff.DrConEnemy")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DrConEnemy
{
	internal class DrConAI : EnemyAI
	{
		public enum State
		{
			Idle,
			RoamSearch,
			Chasing
		}

		private enum CorruptionState
		{
			NotCorrupted,
			Corrupted
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static RpcReceiveHandler <0>____rpc_handler_537851232;

			public static RpcReceiveHandler <1>____rpc_handler_1631869031;

			public static RpcReceiveHandler <2>____rpc_handler_3631905316;

			public static RpcReceiveHandler <3>____rpc_handler_2705285129;

			public static RpcReceiveHandler <4>____rpc_handler_3215422204;

			public static RpcReceiveHandler <5>____rpc_handler_3211178542;

			public static RpcReceiveHandler <6>____rpc_handler_543789041;

			public static RpcReceiveHandler <7>____rpc_handler_3186420411;

			public static RpcReceiveHandler <8>____rpc_handler_2423799401;

			public static RpcReceiveHandler <9>____rpc_handler_2631100579;
		}

		public AISearchRoutine drConSearchRoutine = null;

		private readonly float maxIdleTime = 5f;

		public float currentIdleTime = 0f;

		public float currentAttackTime = 0f;

		public float noticePlayerTimer;

		public bool attackingDone = false;

		public bool punchAttack = false;

		public bool attackTriggerBool = false;

		public bool attackMovement = false;

		private bool attackingPlayer;

		private bool enteredChaseMode;

		private bool lostPlayerInChase;

		private bool beginningChasingThisClient;

		private Coroutine attackingPlayerCoroutine;

		private Vector3 lastPositionOfSeenPlayer;

		private float checkLineofSightInterval;

		public Transform turnCompass = null;

		public Transform attackArea = null;

		private int observedState = -1;

		private AudioSource audioSource;

		public AudioClip AudioClipIdle;

		public AudioClip AudioClipRoaming;

		public AudioClip AudioClipChasingFirst;

		public AudioClip[] AudioClipChasing;

		public AudioClip[] AudioClipFootstep;

		public AudioClip[] AudioClipDeathEscape;

		public float WaitForAI;

		public bool WaitForAIDone = false;

		public float setChaseSpeedNumber;

		private Vector3 previousPosition;

		private float previousVelocity;

		private float averageVelocity;

		private float velocityInterval;

		private float velocityAverageCount;

		private float agentSpeedWithNegative;

		[Space(5f)]
		public float BaseAcceleration = 55f;

		public float SpeedAccelerationEffect = 2f;

		public float SpeedIncreaseRate = 5f;

		private float lastTimeHit;

		private float drConVolume;

		private float drConRoamSpeed;

		private float drConChaseSpeed;

		private float drConDamage;

		private int drConHealth;

		private bool drConCanCorrupt;

		private bool drConInstantCorrupt;

		private float drConCorruptTimeMax;

		private readonly float volumeGet = PluginConfig.DrConVolumeAdjustment.Value;

		private readonly float roamSpeedGet = PluginConfig.DrConRoamSpeed.Value;

		private readonly float chaseSpeedGet = PluginConfig.DrConChaseSpeed.Value;

		private readonly int healthGet = PluginConfig.DrConHealth.Value;

		private readonly int damageGet = PluginConfig.DrConDamage.Value;

		private readonly bool canCorruptGet = PluginConfig.DrConCanBecomeCorrupted.Value;

		private readonly bool instantCorruptGet = PluginConfig.DrConInstantCorruption.Value;

		private readonly float corruptionTimeGet = PluginConfig.DrConUntilCorruptionDuration.Value;

		public bool canBecomeCorrupted;

		public bool corruptedDrCon;

		public bool corruptionTimeFinal = false;

		public bool corruptionCoroutine = false;

		public float currentUntilCorruptionTime = 0f;

		[Header("Required Variables")]
		public Collider DrConCollider;

		public Transform stareTransform;

		public AudioSource farAudio;

		[Header("Audio Clips")]
		public AudioClip AudioClipCorruptedIdling;

		public AudioClip AudioClipCorruptedRoaming;

		public AudioClip AudioClipCorruptedChasing;

		public AudioClip AudioClipCorruptedTriggering;

		public AudioClip AudioClipCorruptedKilling;

		public AudioClip[] AudioClipCorruptedFootstep;

		private Vector3 spawnPos;

		private float roamingTime = 25f;

		private float lookingAtDrConTime;

		private float triggeringTime;

		private bool goToIdle;

		private bool standingStill;

		private float triggerDuration = 30f;

		private readonly float triggerDurationDefault = 30f;

		private readonly float stareToTriggerTime = 0.7f;

		private bool inKillingAnim;

		public List<PlayerControllerB> conTargets = new List<PlayerControllerB>();

		private Vector3 mainEntrancePosition;

		public VisualEffect visualEffects;

		private static VFXExposedProperty keyVFXBeginTrigger;

		private static VFXExposedProperty keyVFXEndTrigger;

		private static readonly string keyVFXBeginTriggerName = "StartKeyDoorParticle";

		private static readonly string keyVFXEndTriggerName = "StopKeyDoorParticle";

		public SkinnedMeshRenderer CorruptionSkin;

		private float lastInvertval = Time.realtimeSinceStartup;

		private float temporartyBlindnessTime;

		private bool temporaryBlindessDone = false;

		private float scanningWidth;

		private float scanningWidthDefault = 150f;

		private float scanningWidthBlindness = 0f;

		private bool enemyHasBeenKilled = false;

		public void SetConfigValues()
		{
			if (volumeGet > 1f)
			{
				drConVolume = 1f;
			}
			else if (volumeGet < 0.1f)
			{
				drConVolume = 0.1f;
			}
			else
			{
				drConVolume = volumeGet;
			}
			if (roamSpeedGet > 8f)
			{
				drConRoamSpeed = 8f;
			}
			else if (roamSpeedGet < 4f)
			{
				drConRoamSpeed = 4f;
			}
			else
			{
				drConRoamSpeed = roamSpeedGet;
			}
			if (chaseSpeedGet > 10f)
			{
				drConChaseSpeed = 10f;
			}
			else if (roamSpeedGet < 5f)
			{
				drConChaseSpeed = 5f;
			}
			else
			{
				drConChaseSpeed = chaseSpeedGet;
			}
			if (damageGet > 15)
			{
				drConDamage = 15f;
			}
			else if (damageGet < 5)
			{
				drConDamage = 5f;
			}
			else
			{
				drConDamage = damageGet;
			}
			if (healthGet > 6)
			{
				drConHealth = 6;
			}
			else if (healthGet < 3)
			{
				drConHealth = 3;
			}
			else
			{
				drConHealth = healthGet;
			}
			drConCanCorrupt = canCorruptGet;
			if (drConCanCorrupt)
			{
				drConInstantCorrupt = instantCorruptGet;
			}
			else
			{
				drConInstantCorrupt = false;
			}
			if (corruptionTimeGet > 160f)
			{
				drConCorruptTimeMax = 160f;
			}
			else if (corruptionTimeGet < 50f)
			{
				drConCorruptTimeMax = 50f;
			}
			else
			{
				drConCorruptTimeMax = corruptionTimeGet;
			}
		}

		public override void Start()
		{
			//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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			((EnemyAI)this).Start();
			audioSource = ((Component)this).GetComponent<AudioSource>();
			SetConfigValues();
			canBecomeCorrupted = drConCanCorrupt;
			keyVFXBeginTrigger.name = keyVFXBeginTriggerName;
			keyVFXEndTrigger.name = keyVFXEndTriggerName;
			base.agent.acceleration = 300f;
			base.agent.angularSpeed = 180f;
			base.agent.speed = drConRoamSpeed;
			setChaseSpeedNumber = drConChaseSpeed;
			base.agent.stoppingDistance = 1.5f;
			triggerDuration = triggerDurationDefault;
			spawnPos = ((Component)this).transform.position;
			base.isOutside = ((Component)this).transform.position.y > -80f;
			mainEntrancePosition = RoundManager.Instance.GetNavMeshPosition(RoundManager.FindMainEntrancePosition(true, base.isOutside), default(NavMeshHit), 5f, -1);
			if (base.isOutside)
			{
				if (base.allAINodes == null || base.allAINodes.Length == 0)
				{
					base.allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
				}
				if ((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
				{
					((EnemyAI)this).EnableEnemyMesh(!StartOfRound.Instance.hangarDoorsClosed || !GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom, false);
				}
			}
			else if (base.allAINodes == null || base.allAINodes.Length == 0)
			{
				base.allAINodes = GameObject.FindGameObjectsWithTag("AINode");
			}
			base.path1 = new NavMeshPath();
			base.openDoorSpeedMultiplier = 500f;
			drConSearchRoutine = new AISearchRoutine();
			if (drConInstantCorrupt)
			{
				corruptedDrCon = true;
				DoAnimationClientRpc("IdlingC");
				base.enemyHP = 1000;
				CorruptionSkin.SetBlendShapeWeight(0, 100f);
				SetCorruptedConInitialValues();
			}
			else
			{
				DoAnimationClientRpc("Idling");
				currentAttackTime = 0f;
				currentIdleTime = 0f;
				base.enemyHP = drConHealth;
			}
			currentIdleTime = maxIdleTime + 1f;
			SwitchState(State.Idle);
		}

		public void StartAnimVFX()
		{
			visualEffects.SendEvent(keyVFXBeginTrigger.name);
		}

		public void EndAnimVFX()
		{
			visualEffects.SendEvent(keyVFXEndTrigger.name);
		}

		public override void DoAIInterval()
		{
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_071d: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: 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 (StartOfRound.Instance.livingPlayers == 0 || base.isEnemyDead || enemyHasBeenKilled || (Object)(object)GameNetworkManager.Instance == (Object)null)
			{
				lastInvertval = Time.realtimeSinceStartup;
				audioSource.loop = false;
				audioSource.Stop();
			}
			else
			{
				if (corruptionTimeFinal)
				{
					return;
				}
				if (corruptedDrCon)
				{
					switch (base.currentBehaviourStateIndex)
					{
					case 0:
					{
						if (base.stunNormalizedTimer > 0f)
						{
							base.agent.speed = 0f;
						}
						else if (standingStill)
						{
							base.agent.speed = 0f;
						}
						else
						{
							roamingTime -= Time.realtimeSinceStartup - lastInvertval;
							base.openDoorSpeedMultiplier = 5f;
							base.agent.speed = 6f;
						}
						base.movingTowardsTargetPlayer = false;
						base.agent.stoppingDistance = 3f;
						base.addPlayerVelocityToDestination = 0f;
						PlayerControllerB targetPlayer2 = base.targetPlayer;
						if (roamingTime <= 16f && drConSearchRoutine.inProgress && (Object)(object)base.targetPlayer == (Object)null)
						{
							((EnemyAI)this).StopSearch(drConSearchRoutine, true);
							lastInvertval = Time.realtimeSinceStartup;
						}
						else if (roamingTime > 3f && roamingTime < 15f && !drConSearchRoutine.inProgress && (Object)(object)base.targetPlayer == (Object)null && goToIdle)
						{
							standingStill = true;
							DoAnimationClientRpc("IdlingC");
							float time = base.creatureVoice.time;
							base.creatureVoice.volume = 0.35f;
							base.creatureVoice.clip = AudioClipCorruptedIdling;
							base.creatureVoice.Play();
							base.creatureVoice.time = time;
							lastInvertval = Time.realtimeSinceStartup;
						}
						else if (!((Object)(object)base.targetPlayer != (Object)null) && (Object)(object)base.targetPlayer == (Object)null && !drConSearchRoutine.inProgress && roamingTime <= 0f)
						{
							if (!standingStill)
							{
								goToIdle = Random.Range(1, 3) == 1;
								roamingTime = Random.Range(20f, 27f);
								((EnemyAI)this).StartSearch(spawnPos, drConSearchRoutine);
								lastInvertval = Time.realtimeSinceStartup;
								break;
							}
							standingStill = false;
							goToIdle = false;
							roamingTime = Random.Range(19f, 24f);
							DoAnimationClientRpc("RoamingC");
							float time2 = base.creatureVoice.time;
							base.creatureVoice.volume = 0.5f;
							base.creatureVoice.clip = AudioClipCorruptedRoaming;
							base.creatureVoice.Play();
							base.creatureVoice.time = time2;
							lastInvertval = Time.realtimeSinceStartup;
						}
						break;
					}
					case 1:
						base.agent.speed = 0f;
						lastInvertval = Time.realtimeSinceStartup;
						base.movingTowardsTargetPlayer = false;
						break;
					case 2:
					{
						base.agent.stoppingDistance = 0f;
						base.agent.avoidancePriority = 50;
						base.openDoorSpeedMultiplier = 500f;
						DrConCollider.isTrigger = true;
						base.addPlayerVelocityToDestination = 1f;
						if (inKillingAnim)
						{
							base.agent.speed = 0f;
						}
						else
						{
							base.agent.speed = Mathf.Clamp(base.agent.speed + (Time.realtimeSinceStartup - lastInvertval) * 1.1f, 5.5f, 14.3f);
						}
						if (conTargets.Count <= 0)
						{
							ToIdle();
							break;
						}
						PlayerControllerB targetPlayer = base.targetPlayer;
						float num = float.PositiveInfinity;
						foreach (PlayerControllerB conTarget in conTargets)
						{
							bool flag = conTarget.isInsideFactory == !base.isOutside;
							if (!conTarget.isPlayerDead)
							{
								if (((EnemyAI)this).PlayerIsTargetable(conTarget, false, true) && Vector3.Distance(((Component)conTarget).transform.position, ((Component)this).transform.position) < num)
								{
									num = Vector3.Magnitude(((Component)conTarget).transform.position - ((Component)this).transform.position);
									base.targetPlayer = conTarget;
								}
							}
							else
							{
								AddTargetToList((int)conTarget.actualClientId, remove: true);
							}
						}
						if ((Object)(object)base.targetPlayer != (Object)null)
						{
							if (drConSearchRoutine.inProgress)
							{
								((EnemyAI)this).StopSearch(drConSearchRoutine, true);
							}
							if ((Object)(object)base.targetPlayer != (Object)(object)targetPlayer)
							{
								((EnemyAI)this).ChangeOwnershipOfEnemy(base.targetPlayer.actualClientId);
							}
							if (base.targetPlayer.isInsideFactory != !base.isOutside)
							{
								if (Vector3.Distance(((Component)this).transform.position, mainEntrancePosition) < 2f)
								{
									TeleportEnemy(RoundManager.FindMainEntrancePosition(true, !base.isOutside), !base.isOutside);
									base.agent.speed = 0f;
								}
								else
								{
									base.movingTowardsTargetPlayer = false;
									((EnemyAI)this).SetDestinationToPosition(mainEntrancePosition, false);
								}
							}
							else
							{
								((EnemyAI)this).SetMovingTowardsTargetPlayer(base.targetPlayer);
							}
						}
						else if (conTargets.Count <= 0)
						{
							ToIdle();
						}
						break;
					}
					default:
						lastInvertval = Time.realtimeSinceStartup;
						break;
					}
				}
				else
				{
					if (corruptedDrCon)
					{
						return;
					}
					switch (base.currentBehaviourStateIndex)
					{
					case 0:
						base.addPlayerVelocityToDestination = 0f;
						if (!drConSearchRoutine.inProgress)
						{
							((EnemyAI)this).StartSearch(((Component)this).transform.position, drConSearchRoutine);
						}
						break;
					case 1:
						base.addPlayerVelocityToDestination = 0f;
						if (!drConSearchRoutine.inProgress)
						{
							((EnemyAI)this).StartSearch(((Component)this).transform.position, drConSearchRoutine);
						}
						break;
					case 2:
						base.addPlayerVelocityToDestination = 1f;
						if (lostPlayerInChase)
						{
							base.movingTowardsTargetPlayer = false;
							if (!drConSearchRoutine.inProgress)
							{
								drConSearchRoutine.searchWidth = 30f;
								((EnemyAI)this).StartSearch(lastPositionOfSeenPlayer, drConSearchRoutine);
							}
						}
						else if (drConSearchRoutine.inProgress)
						{
							((EnemyAI)this).StopSearch(drConSearchRoutine, true);
							base.movingTowardsTargetPlayer = true;
						}
						break;
					}
				}
			}
		}

		public void TeleportEnemy(Vector3 pos, bool setOutside)
		{
			//IL_0006: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_003a: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(pos, default(NavMeshHit), 5f, -1);
			if (((NetworkBehaviour)this).IsOwner)
			{
				((Behaviour)base.agent).enabled = false;
				((Component)this).transform.position = navMeshPosition;
				((Behaviour)base.agent).enabled = true;
			}
			else
			{
				((Component)this).transform.position = navMeshPosition;
			}
			base.serverPosition = navMeshPosition;
			SetEnemyOutside(setOutside);
			EntranceTeleport val = RoundManager.FindMainEntranceScript(setOutside);
			if (val.doorAudios != null && val.doorAudios.Length != 0)
			{
				val.entrancePointAudio.PlayOneShot(val.doorAudios[0]);
				WalkieTalkie.TransmitOneShotAudio(val.entrancePointAudio, val.doorAudios[0], 1f);
			}
		}

		public IEnumerator SetCorruptionFunc()
		{
			((EnemyAI)this).StopSearch(drConSearchRoutine, true);
			base.agent.speed = 0f;
			base.enemyHP = 1000;
			audioSource.Stop();
			base.creatureVoice.Stop();
			DoAnimationClientRpc("CorruptionTransition");
			yield return (object)new WaitForSeconds(3f);
			DoAnimationClientRpc("CorruptionFinish");
			CorruptionSkin.SetBlendShapeWeight(0, 100f);
			yield return (object)new WaitUntil((Func<bool>)(() => !corruptionTimeFinal));
			spawnPos = ((Component)this).transform.position;
			yield return (object)new WaitForSeconds(0.5f);
			SetCorruptedConInitialValues();
			base.creatureVoice.Stop();
			base.creatureAnimator.speed = 1f;
			observedState = 0;
			farAudio.volume = 0f;
			DrConCollider.isTrigger = true;
			base.creatureVoice.volume = drConVolume;
			base.creatureVoice.clip = AudioClipCorruptedIdling;
			standingStill = true;
			DoAnimationClientRpc("IdlingC");
			((EnemyAI)this).SwitchToBehaviourState(0);
		}

		public void CorruptionFinished()
		{
			corruptionTimeFinal = false;
		}

		public override void Update()
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e17: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e3e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d45: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).Update();
			if (base.isEnemyDead || enemyHasBeenKilled || corruptionTimeFinal)
			{
				return;
			}
			if (!((NetworkBehaviour)this).IsOwner)
			{
				base.inSpecialAnimation = false;
			}
			if (drConCanCorrupt && !corruptedDrCon && !drConInstantCorrupt)
			{
				float num = Mathf.InverseLerp(0f, drConCorruptTimeMax, currentUntilCorruptionTime);
				CorruptionSkin.SetBlendShapeWeight(0, num * 100f);
			}
			if (currentUntilCorruptionTime >= drConCorruptTimeMax && attackingPlayerCoroutine == null && !corruptedDrCon && !corruptionTimeFinal)
			{
				if (!corruptionCoroutine)
				{
					corruptionCoroutine = true;
					((MonoBehaviour)this).StartCoroutine(SetCorruptionFunc());
				}
				corruptionTimeFinal = true;
				corruptedDrCon = true;
			}
			if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(((Component)this).transform.position + Vector3.up * 0.25f, 50f, 25, 5f) && !base.isEnemyDead)
			{
				if (base.currentBehaviourStateIndex == 2)
				{
					GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.8f, 1f);
				}
				else
				{
					GameNetworkManager.Instance.localPlayerController.IncreaseFearLevelOverTime(0.8f, 0.25f);
				}
			}
			if (corruptedDrCon)
			{
				bool flag = GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(stareTransform.position, 18f, 40, -1f);
				if (flag)
				{
					float num2 = Quaternion.Angle(((Component)GameNetworkManager.Instance.localPlayerController.gameplayCamera).transform.rotation, stareTransform.rotation);
					if (!(num2 <= 135f))
					{
						flag = false;
					}
				}
				if (flag)
				{
					lookingAtDrConTime += Time.deltaTime;
					if (lookingAtDrConTime >= stareToTriggerTime)
					{
						GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(1.25f, true);
						if (conTargets.Count < 60)
						{
							AddTargetToList((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
						}
						if (base.currentBehaviourStateIndex == 0)
						{
							((EnemyAI)this).SwitchToBehaviourState(1);
						}
					}
				}
				else
				{
					lookingAtDrConTime = Mathf.Clamp(lookingAtDrConTime - Time.deltaTime, 0f, triggeringTime);
					if (GameNetworkManager.Instance.localPlayerController.HasLineOfSightToPosition(((Component)this).transform.position + Vector3.up * 1f, 30f, 60, -1f) && base.currentBehaviourStateIndex == 0)
					{
						if (!base.thisNetworkObject.IsOwner)
						{
							((EnemyAI)this).ChangeOwnershipOfEnemy(GameNetworkManager.Instance.localPlayerController.actualClientId);
						}
						if (Vector3.Distance(((Component)this).transform.position, ((Component)GameNetworkManager.Instance.localPlayerController).transform.position) < 10f)
						{
							GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.65f, true);
						}
						else
						{
							GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.25f, true);
						}
					}
				}
				switch (base.currentBehaviourStateIndex)
				{
				case 0:
					if (observedState != 0)
					{
						SetCorruptedConInitialValues();
						base.creatureVoice.Stop();
						base.creatureAnimator.speed = 1f;
						observedState = 0;
						farAudio.volume = 0f;
						DrConCollider.isTrigger = true;
						base.creatureVoice.volume = drConVolume;
						base.creatureVoice.clip = AudioClipCorruptedIdling;
					}
					if (!base.creatureVoice.isPlaying)
					{
						base.creatureVoice.volume = drConVolume;
						base.creatureVoice.clip = AudioClipCorruptedIdling;
						base.creatureVoice.Play();
					}
					break;
				case 1:
					if (observedState != 1)
					{
						base.creatureAnimator.speed = 1f;
						observedState = 1;
						standingStill = false;
						DrConCollider.isTrigger = true;
						DoAnimationClientRpc("TriggeringC");
						base.creatureVoice.Stop();
						farAudio.volume = drConVolume;
						farAudio.pitch = Random.Range(0.85f, 1.15f);
						farAudio.PlayOneShot(AudioClipCorruptedTriggering);
						base.agent.speed = 0f;
						triggeringTime = triggerDuration;
					}
					if (!base.creatureVoice.isPlaying)
					{
						base.creatureVoice.volume = drConVolume;
						base.creatureVoice.clip = AudioClipCorruptedTriggering;
						base.creatureVoice.Play();
					}
					triggeringTime -= Time.deltaTime;
					if (triggeringTime <= 0f)
					{
						((EnemyAI)this).SwitchToBehaviourState(2);
					}
					break;
				case 2:
					DrConCollider.isTrigger = true;
					if (observedState != 2)
					{
						DrConCollider.isTrigger = true;
						observedState = 2;
						DoAnimationClientRpc("ChasingC");
						base.creatureVoice.Stop();
						farAudio.Stop();
						farAudio.volume = drConVolume;
						farAudio.clip = AudioClipCorruptedChasing;
						farAudio.Play();
					}
					if (!base.creatureVoice.isPlaying)
					{
						base.creatureVoice.volume = drConVolume;
						base.creatureVoice.clip = AudioClipCorruptedChasing;
						base.creatureVoice.Play();
					}
					base.creatureAnimator.speed = Mathf.Clamp(base.creatureAnimator.speed * 1.5f, 1f, 5f);
					break;
				}
			}
			else
			{
				if (corruptedDrCon)
				{
					return;
				}
				ObserveState();
				CalculateAgentSpeed();
				currentUntilCorruptionTime += Time.deltaTime;
				currentIdleTime += Time.deltaTime;
				if (temporartyBlindnessTime <= 1.5f && !temporaryBlindessDone)
				{
					temporartyBlindnessTime += Time.deltaTime;
					scanningWidth = scanningWidthBlindness;
				}
				else if (temporartyBlindnessTime >= 1.5f && !temporaryBlindessDone)
				{
					scanningWidth = scanningWidthDefault;
					temporaryBlindessDone = true;
				}
				switch (base.currentBehaviourStateIndex)
				{
				case 0:
				{
					if (punchAttack)
					{
						break;
					}
					if (enteredChaseMode)
					{
						enteredChaseMode = false;
						drConSearchRoutine.searchWidth = 25f;
						beginningChasingThisClient = false;
						noticePlayerTimer = 0f;
					}
					if (currentIdleTime > maxIdleTime)
					{
						((EnemyAI)this).SwitchToBehaviourState(1);
						break;
					}
					if (checkLineofSightInterval <= 0.05f)
					{
						checkLineofSightInterval += Time.deltaTime;
						break;
					}
					checkLineofSightInterval = 0f;
					if (!temporaryBlindessDone)
					{
						break;
					}
					PlayerControllerB val4 = ((EnemyAI)this).CheckLineOfSightForPlayer(scanningWidth, 60, -1);
					if ((Object)(object)val4 == (Object)(object)GameNetworkManager.Instance.localPlayerController && temporaryBlindessDone)
					{
						noticePlayerTimer = Mathf.Clamp(noticePlayerTimer + 0.05f, 0f, 10f);
						if (noticePlayerTimer > 0.2f && !beginningChasingThisClient)
						{
							beginningChasingThisClient = true;
							BeginChasingPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
							((EnemyAI)this).ChangeOwnershipOfEnemy(val4.actualClientId);
						}
					}
					else
					{
						noticePlayerTimer -= Time.deltaTime;
					}
					break;
				}
				case 1:
				{
					if (punchAttack)
					{
						break;
					}
					if (enteredChaseMode)
					{
						enteredChaseMode = false;
						drConSearchRoutine.searchWidth = 25f;
						beginningChasingThisClient = false;
						noticePlayerTimer = 0f;
					}
					if (currentIdleTime > maxIdleTime * 3f)
					{
						((EnemyAI)this).SwitchToBehaviourState(0);
						break;
					}
					if (checkLineofSightInterval <= 0.05f)
					{
						checkLineofSightInterval += Time.deltaTime;
						break;
					}
					checkLineofSightInterval = 0f;
					if (!temporaryBlindessDone)
					{
						break;
					}
					PlayerControllerB val3 = ((EnemyAI)this).CheckLineOfSightForPlayer(scanningWidth, 60, -1);
					if ((Object)(object)val3 == (Object)(object)GameNetworkManager.Instance.localPlayerController && temporaryBlindessDone)
					{
						noticePlayerTimer = Mathf.Clamp(noticePlayerTimer + 0.05f, 0f, 10f);
						if (noticePlayerTimer > 0.2f && !beginningChasingThisClient)
						{
							beginningChasingThisClient = true;
							BeginChasingPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
							((EnemyAI)this).ChangeOwnershipOfEnemy(val3.actualClientId);
						}
					}
					else
					{
						noticePlayerTimer -= Time.deltaTime;
					}
					break;
				}
				case 2:
				{
					if (punchAttack)
					{
						break;
					}
					if (!enteredChaseMode)
					{
						enteredChaseMode = true;
						lostPlayerInChase = false;
						checkLineofSightInterval = 0f;
						beginningChasingThisClient = false;
					}
					if (checkLineofSightInterval <= 0.075f)
					{
						checkLineofSightInterval += Time.deltaTime;
						break;
					}
					checkLineofSightInterval = 0f;
					if (!temporaryBlindessDone)
					{
						break;
					}
					if (!attackingPlayer && (Object)(object)base.targetPlayer != (Object)null && attackingPlayerCoroutine == null && base.currentBehaviourStateIndex == 2 && Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < 3f)
					{
						attackingPlayer = true;
						punchAttack = true;
						attackingPlayerCoroutine = ((MonoBehaviour)this).StartCoroutine(AttackingPlayerAnimation((int)base.targetPlayer.playerClientId));
						AttackPlayerServerRpc((int)base.targetPlayer.playerClientId);
					}
					if (!base.creatureVoice.isPlaying && !lostPlayerInChase)
					{
						base.creatureVoice.pitch = Random.Range(0.9f, 1.1f);
						base.creatureVoice.PlayOneShot(AudioClipChasing[Random.Range(0, AudioClipChasing.Length)]);
					}
					if (base.inSpecialAnimation)
					{
						break;
					}
					if (lostPlayerInChase)
					{
						PlayerControllerB val = ((EnemyAI)this).CheckLineOfSightForPlayer(180f, 60, -1);
						if (Object.op_Implicit((Object)(object)val) && temporaryBlindessDone)
						{
							noticePlayerTimer = 0f;
							lostPlayerInChase = false;
							if ((Object)(object)val != (Object)(object)base.targetPlayer)
							{
								((EnemyAI)this).SetMovingTowardsTargetPlayer(val);
								attackingPlayer = false;
								((EnemyAI)this).ChangeOwnershipOfEnemy(val.actualClientId);
							}
						}
						else
						{
							noticePlayerTimer -= 0.075f;
							if (noticePlayerTimer < -15f)
							{
								((EnemyAI)this).SwitchToBehaviourState(1);
							}
						}
						break;
					}
					PlayerControllerB val2 = ((EnemyAI)this).CheckLineOfSightForPlayer(180f, 55, -1);
					if ((Object)(object)val2 != (Object)null && temporaryBlindessDone)
					{
						noticePlayerTimer = 0f;
						lastPositionOfSeenPlayer = ((Component)val2).transform.position;
						if ((Object)(object)val2 != (Object)(object)base.targetPlayer)
						{
							base.targetPlayer = val2;
							attackingPlayer = false;
							((EnemyAI)this).ChangeOwnershipOfEnemy(base.targetPlayer.actualClientId);
						}
					}
					else
					{
						noticePlayerTimer += 0.075f;
						if (noticePlayerTimer > 1.8f)
						{
							lostPlayerInChase = true;
						}
					}
					break;
				}
				}
				int currentBehaviourStateIndex = base.currentBehaviourStateIndex;
				if ((Object)(object)base.targetPlayer != (Object)null && currentBehaviourStateIndex == 2 && Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < 4f)
				{
					turnCompass.LookAt(((Component)base.targetPlayer.gameplayCamera).transform.position);
					((Component)this).transform.rotation = Quaternion.Lerp(((Component)this).transform.rotation, Quaternion.Euler(new Vector3(0f, turnCompass.eulerAngles.y, 0f)), 12f * Time.deltaTime);
				}
			}
		}

		public void SetEnemyOutside(bool outside = false)
		{
			//IL_0010: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			base.isOutside = outside;
			mainEntrancePosition = RoundManager.Instance.GetNavMeshPosition(RoundManager.FindMainEntrancePosition(true, outside), default(NavMeshHit), 5f, -1);
			if (outside)
			{
				base.allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
			}
			else
			{
				base.allAINodes = GameObject.FindGameObjectsWithTag("AINode");
			}
		}

		public override void OnCollideWithPlayer(Collider other)
		{
			if (!corruptedDrCon || !Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<PlayerControllerB>()))
			{
				return;
			}
			((EnemyAI)this).OnCollideWithPlayer(other);
			if (!inKillingAnim && !base.isEnemyDead && base.currentBehaviourStateIndex == 2)
			{
				PlayerControllerB val = ((EnemyAI)this).MeetsStandardPlayerCollisionConditions(other, false, false);
				if ((Object)(object)val != (Object)null)
				{
					inKillingAnim = true;
					((MonoBehaviour)this).StartCoroutine(KillPlayerAnimFunc((int)val.playerClientId));
					KillPlayerServerRpc((int)val.playerClientId);
				}
			}
		}

		private IEnumerator AttackingPlayerAnimation(int playerId)
		{
			attackingDone = false;
			attackTriggerBool = false;
			_ = StartOfRound.Instance.allPlayerScripts[playerId];
			if (!base.isEnemyDead)
			{
				base.agent.speed = 0f;
				base.creatureVoice.pitch = Random.Range(0.9f, 1.1f);
				base.creatureVoice.Stop();
				base.creatureVoice.loop = false;
				switch (Random.Range(0, 3))
				{
				case 0:
					DoAnimationClientRpc("Attacking1");
					break;
				case 1:
					DoAnimationClientRpc("Attacking2");
					break;
				case 2:
					DoAnimationClientRpc("Attacking3");
					break;
				case 3:
					DoAnimationClientRpc("Attacking4");
					break;
				}
				yield return (object)new WaitUntil((Func<bool>)(() => attackTriggerBool));
				AttackHitClientRpc();
				yield return (object)new WaitUntil((Func<bool>)(() => attackingDone));
				base.movingTowardsTargetPlayer = false;
				base.agent.isStopped = true;
				base.agent.speed = 0f;
				yield return (object)new WaitForSeconds(0.3f);
				punchAttack = false;
				base.agent.isStopped = false;
				attackingPlayer = false;
				attackingPlayerCoroutine = null;
				((EnemyAI)this).SwitchToBehaviourState(0);
			}
		}

		private IEnumerator KillPlayerAnimFunc(int playerId)
		{
			inKillingAnim = true;
			PlayerControllerB playerScript = StartOfRound.Instance.allPlayerScripts[playerId];
			if (base.isOutside && ((Component)this).transform.position.y < -80f)
			{
				SetEnemyOutside();
			}
			else if (!base.isOutside && ((Component)this).transform.position.y > -80f)
			{
				SetEnemyOutside(outside: true);
			}
			int pAmount = conTargets.Count;
			playerScript.KillPlayer(((Component)playerScript).transform.position, true, (CauseOfDeath)0, 1, default(Vector3));
			AddTargetToList(playerId, remove: true);
			base.creatureSFX.PlayOneShot(AudioClipCorruptedKilling);
			DoAnimationClientRpc("KillingC");
			if (pAmount - 1 <= 0)
			{
				ToIdle();
			}
			yield return (object)new WaitForSeconds(1f);
			inKillingAnim = false;
		}

		private void SetCorruptedConInitialValues()
		{
			base.creatureAnimator.speed = 1f;
			DrConCollider = ((Component)this).gameObject.GetComponentInChildren<Collider>();
			base.targetPlayer = null;
			inKillingAnim = false;
			conTargets.Clear();
			DrConCollider.isTrigger = true;
			base.creatureVoice.Stop();
			farAudio.volume = 0f;
			farAudio.Stop();
		}

		private void CalculateAgentSpeed()
		{
			//IL_0007: 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_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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)this).transform.position - previousPosition;
			float num = ((Vector3)(ref val)).magnitude / (Time.deltaTime / 1.4f);
			if (velocityInterval <= 0f)
			{
				previousVelocity = averageVelocity;
				velocityInterval = 0.05f;
				velocityAverageCount += 1f;
				if (velocityAverageCount > 5f)
				{
					averageVelocity += (num - averageVelocity) / 3f;
				}
				else
				{
					averageVelocity += num;
					if (velocityAverageCount == 2f)
					{
						averageVelocity /= velocityAverageCount;
					}
				}
			}
			else
			{
				velocityInterval -= Time.deltaTime;
			}
			if (((NetworkBehaviour)this).IsOwner && averageVelocity - num > Mathf.Clamp(num * 0.17f, 2f, 100f) && ((num > 3f) & (base.currentBehaviourStateIndex == 2)))
			{
				agentSpeedWithNegative *= 0.2f;
			}
			previousPosition = ((Component)this).transform.position;
			if (base.currentBehaviourStateIndex == 0)
			{
				base.agent.speed = 0f;
			}
			else if (base.currentBehaviourStateIndex == 1)
			{
				base.agent.speed = drConRoamSpeed;
				base.agent.acceleration = 150f;
			}
			else
			{
				if (base.currentBehaviourStateIndex != 2)
				{
					return;
				}
				if (!attackMovement)
				{
					if (setChaseSpeedNumber < 14f)
					{
						setChaseSpeedNumber += 1.5f;
					}
					base.agent.speed = Mathf.Clamp(setChaseSpeedNumber, drConChaseSpeed, drConChaseSpeed * 1.25f);
					base.agent.acceleration = 350f;
				}
				else
				{
					setChaseSpeedNumber = 5f;
					base.agent.speed = drConChaseSpeed;
					base.agent.acceleration = 200f;
				}
			}
		}

		public void ObserveState()
		{
			if (base.currentBehaviourStateIndex == observedState)
			{
				return;
			}
			if (base.enemyHP <= 0)
			{
				audioSource.Stop();
				return;
			}
			switch (base.currentBehaviourStateIndex)
			{
			case 0:
				currentIdleTime = 0f;
				base.creatureVoice.clip = AudioClipIdle;
				base.creatureVoice.loop = true;
				base.creatureVoice.volume = drConVolume;
				base.creatureVoice.Play();
				DoAnimationClientRpc("Idling");
				break;
			case 1:
				base.creatureVoice.clip = AudioClipRoaming;
				base.creatureVoice.loop = true;
				base.creatureVoice.volume = drConVolume;
				base.creatureVoice.Play();
				DoAnimationClientRpc("Roaming");
				break;
			case 2:
				base.creatureVoice.loop = false;
				base.creatureVoice.volume = drConVolume;
				base.creatureVoice.PlayOneShot(AudioClipChasingFirst);
				DoAnimationClientRpc("Chasing");
				break;
			}
			observedState = base.currentBehaviourStateIndex;
		}

		public override void FinishedCurrentSearchRoutine()
		{
			((EnemyAI)this).FinishedCurrentSearchRoutine();
			drConSearchRoutine.searchWidth = Mathf.Clamp(drConSearchRoutine.searchWidth + 10f, 1f, 100f);
		}

		public void AttackTriggerFunction()
		{
			attackTriggerBool = true;
		}

		public void AttackDoneAnimation()
		{
			attackingDone = true;
		}

		[ClientRpc]
		public void AttackHitClientRpc()
		{
			//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_00c4: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3429520421u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3429520421u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			int num = 8;
			Collider[] array = Physics.OverlapBox(attackArea.position, attackArea.localScale, Quaternion.identity, num);
			if (array.Length == 0)
			{
				return;
			}
			Collider[] array2 = array;
			foreach (Collider val3 in array2)
			{
				PlayerControllerB val4 = ((EnemyAI)this).MeetsStandardPlayerCollisionConditions(val3, false, false);
				if ((Object)(object)val4 != (Object)null)
				{
					val4.DamagePlayer((int)drConDamage, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
					attackTriggerBool = false;
				}
			}
		}

		[ClientRpc]
		public void AttackHitKillClientRpc()
		{
			//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_00c4: 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_011f: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2762657426u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2762657426u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			int num = 8;
			Collider[] array = Physics.OverlapBox(attackArea.position, attackArea.localScale, Quaternion.identity, num);
			if (array.Length == 0)
			{
				return;
			}
			Collider[] array2 = array;
			foreach (Collider val3 in array2)
			{
				PlayerControllerB val4 = ((EnemyAI)this).MeetsStandardPlayerCollisionConditions(val3, false, false);
				if ((Object)(object)val4 != (Object)null)
				{
					val4.DropBlood(Vector3.forward, true, false);
					val4.DropBlood(Vector3.left, true, false);
					val4.DropBlood(Vector3.right, true, false);
					val4.DropBlood(Vector3.up, true, false);
					val4.DropBlood(Vector3.back, true, false);
					val4.DropBlood(Vector3.down, true, false);
					val4.KillPlayer(Vector3.zero, true, (CauseOfDeath)0, 1, default(Vector3));
					val4.DamagePlayer(100, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
					val4.snapToServerPosition = false;
					val4.disableLookInput = false;
					attackTriggerBool = false;
				}
			}
		}

		public IEnumerator KillingEnemyAnimation()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => attackingPlayerCoroutine == null));
			if (attackingPlayerCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(attackingPlayerCoroutine);
			}
			if (base.searchCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(base.searchCoroutine);
			}
			((EnemyAI)this).KillEnemyOnOwnerClient(false);
		}

		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.creatureVoice.Stop();
				base.creatureSFX.Stop();
				base.creatureVoice.loop = false;
			}
			else if (!corruptedDrCon)
			{
				base.enemyHP -= force;
				agentSpeedWithNegative = Random.Range(-2.8f, -2f);
				lastTimeHit = Time.realtimeSinceStartup;
				averageVelocity = 0f;
				if (((NetworkBehaviour)this).IsOwner && base.enemyHP <= 0)
				{
					enemyHasBeenKilled = true;
					((MonoBehaviour)this).StartCoroutine(KillingEnemyAnimation());
				}
			}
		}

		public void Footsteps()
		{
			if (corruptedDrCon)
			{
				base.creatureSFX.pitch = Random.Range(0.85f, 1.15f);
				base.creatureSFX.PlayOneShot(AudioClipCorruptedFootstep[Random.Range(0, AudioClipCorruptedFootstep.Length)]);
			}
			else
			{
				base.creatureSFX.pitch = Random.Range(0.9f, 1.1f);
				base.creatureSFX.PlayOneShot(AudioClipFootstep[Random.Range(0, AudioClipFootstep.Length)]);
			}
		}

		public void DeathEscape(int audioValue)
		{
			base.creatureVoice.loop = false;
			base.creatureVoice.Stop();
			base.creatureVoice.pitch = 1f;
			base.creatureVoice.PlayOneShot(AudioClipDeathEscape[audioValue]);
		}

		public void SwitchState(State state)
		{
			((EnemyAI)this).SwitchToBehaviourState((int)state);
		}

		public void ToIdle()
		{
			((EnemyAI)this).SwitchToBehaviourState(0);
			ToIdleOnLocalClient();
			ToIdleServerRpc();
		}

		public void ToIdleOnLocalClient()
		{
			standingStill = true;
			roamingTime = Random.Range(30f, 40f);
			DoAnimationClientRpc("IdlingC");
		}

		public void AddTargetToList(int playerId, bool remove = false)
		{
			PlayerControllerB item = StartOfRound.Instance.allPlayerScripts[playerId];
			if (remove)
			{
				if (!conTargets.Contains(item))
				{
					return;
				}
			}
			else if (conTargets.Contains(item))
			{
				return;
			}
			AddTargetToListOnLocalClient(playerId, remove);
			AddTargetToListServerRpc(playerId, remove);
		}

		[ClientRpc]
		public void DoAnimationClientRpc(string animationName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(753452582u, val, (RpcDelivery)0);
				bool flag = animationName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(animationName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 753452582u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.creatureAnimator.SetTrigger(animationName);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BeginChasingPlayerServerRpc(int playerObjectId)
		{
			//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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0108: 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_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_011d: 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)
			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(3913425985u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerObjectId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3913425985u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					ServerRpcParams val3 = default(ServerRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendServerRpc(537851232u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerObjectId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val4, 537851232u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					BeginChasingPlayerClientRpc(playerObjectId);
				}
			}
		}

		[ClientRpc]
		public void BeginChasingPlayerClientRpc(int playerObjectId)
		{
			//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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0108: 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_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_011d: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3352743374u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerObjectId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3352743374u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					ClientRpcParams val3 = default(ClientRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendClientRpc(1631869031u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerObjectId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val4, 1631869031u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					((EnemyAI)this).SwitchToBehaviourStateOnLocalClient(2);
					((EnemyAI)this).SetMovingTowardsTargetPlayer(StartOfRound.Instance.allPlayerScripts[playerObjectId]);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AttackPlayerServerRpc(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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0108: 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_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_011d: 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)
			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(3516531879u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3516531879u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					ServerRpcParams val3 = default(ServerRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendServerRpc(3631905316u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val4, 3631905316u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					AttackPlayerClientRpc(playerId);
				}
			}
		}

		[ClientRpc]
		public void AttackPlayerClientRpc(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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0108: 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_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_011d: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1828436753u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1828436753u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					ClientRpcParams val3 = default(ClientRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendClientRpc(2705285129u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val4, 2705285129u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager2.IsClient || networkManager2.IsHost) && !((NetworkBehaviour)this).IsOwner && attackingPlayerCoroutine == null)
				{
					((MonoBehaviour)this).StartCoroutine(AttackingPlayerAnimation(playerId));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void KillPlayerServerRpc(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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0108: 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_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_011d: 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)
			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(1760674640u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1760674640u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					ServerRpcParams val3 = default(ServerRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendServerRpc(3215422204u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val4, 3215422204u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					KillPlayerClientRpc(playerId);
				}
			}
		}

		[ClientRpc]
		private void KillPlayerClientRpc(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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0108: 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_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_011d: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4091319884u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4091319884u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					ClientRpcParams val3 = default(ClientRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendClientRpc(3211178542u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val4, 3211178542u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					((MonoBehaviour)this).StartCoroutine(KillPlayerAnimFunc(playerId));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddTargetToListServerRpc(int playerId, bool remove)
		{
			//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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Invalid comparison between Unknown and I4
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Invalid comparison between Unknown and I4
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: 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(816674038u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref remove, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 816674038u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					ServerRpcParams val3 = default(ServerRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendServerRpc(2423799401u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerId);
					((FastBufferWriter)(ref val4)).WriteValueSafe<bool>(ref remove, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val4, 2423799401u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					AddTargetToListClientRpc(playerId, remove);
				}
			}
		}

		[ClientRpc]
		public void AddTargetToListClientRpc(int playerId, bool remove)
		{
			//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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Invalid comparison between Unknown and I4
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Invalid comparison between Unknown and I4
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3152307392u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref remove, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3152307392u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					ClientRpcParams val3 = default(ClientRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendClientRpc(2631100579u, val3, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val4, playerId);
					((FastBufferWriter)(ref val4)).WriteValueSafe<bool>(ref remove, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val4, 2631100579u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					AddTargetToListOnLocalClient(playerId, remove);
				}
			}
		}

		public void AddTargetToListOnLocalClient(int playerId, bool remove)
		{
			PlayerControllerB item = StartOfRound.Instance.allPlayerScripts[playerId];
			if (remove)
			{
				if (conTargets.Contains(item))
				{
					conTargets.Remove(item);
				}
			}
			else if (!conTargets.Contains(item))
			{
				conTargets.Add(item);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ToIdleServerRpc()
		{
			//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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Invalid comparison between Unknown and I4
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			//IL_00f8: 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)
			//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_0115: 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(579481616u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 579481616u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					ServerRpcParams val3 = default(ServerRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendServerRpc(543789041u, val3, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val4, 543789041u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					ToIdleClientRpc();
				}
			}
		}

		[ClientRpc]
		private void ToIdleClientRpc()
		{
			//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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Invalid comparison between Unknown and I4
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			//IL_00f8: 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)
			//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_0115: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2984798264u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2984798264u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager2 != null && networkManager2.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager2.IsServer || networkManager2.IsHost))
				{
					ClientRpcParams val3 = default(ClientRpcParams);
					FastBufferWriter val4 = ((NetworkBehaviour)this).__beginSendClientRpc(3186420411u, val3, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val4, 3186420411u, val3, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager2.IsClient || networkManager2.IsHost))
				{
					ToIdleOnLocalClient();
				}
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_DrConEnemyAI()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00c7: 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: Expected O, but got Unknown
			//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_00fd: Expected O, but got Unknown
			//IL_011d: 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)
			//IL_0128: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table = NetworkManager.__rpc_func_table;
			object obj = <>O.<0>____rpc_handler_537851232;
			if (obj == null)
			{
				RpcReceiveHandler val = __rpc_handler_537851232;
				<>O.<0>____rpc_handler_537851232 = val;
				obj = (object)val;
			}
			_rpc_func_table.Add(537851232u, (RpcReceiveHandler)obj);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table2 = NetworkManager.__rpc_func_table;
			object obj2 = <>O.<1>____rpc_handler_1631869031;
			if (obj2 == null)
			{
				RpcReceiveHandler val2 = __rpc_handler_1631869031;
				<>O.<1>____rpc_handler_1631869031 = val2;
				obj2 = (object)val2;
			}
			_rpc_func_table2.Add(1631869031u, (RpcReceiveHandler)obj2);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table3 = NetworkManager.__rpc_func_table;
			object obj3 = <>O.<2>____rpc_handler_3631905316;
			if (obj3 == null)
			{
				RpcReceiveHandler val3 = __rpc_handler_3631905316;
				<>O.<2>____rpc_handler_3631905316 = val3;
				obj3 = (object)val3;
			}
			_rpc_func_table3.Add(3631905316u, (RpcReceiveHandler)obj3);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table4 = NetworkManager.__rpc_func_table;
			object obj4 = <>O.<3>____rpc_handler_2705285129;
			if (obj4 == null)
			{
				RpcReceiveHandler val4 = __rpc_handler_2705285129;
				<>O.<3>____rpc_handler_2705285129 = val4;
				obj4 = (object)val4;
			}
			_rpc_func_table4.Add(2705285129u, (RpcReceiveHandler)obj4);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table5 = NetworkManager.__rpc_func_table;
			object obj5 = <>O.<4>____rpc_handler_3215422204;
			if (obj5 == null)
			{
				RpcReceiveHandler val5 = __rpc_handler_3215422204;
				<>O.<4>____rpc_handler_3215422204 = val5;
				obj5 = (object)val5;
			}
			_rpc_func_table5.Add(3215422204u, (RpcReceiveHandler)obj5);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table6 = NetworkManager.__rpc_func_table;
			object obj6 = <>O.<5>____rpc_handler_3211178542;
			if (obj6 == null)
			{
				RpcReceiveHandler val6 = __rpc_handler_3211178542;
				<>O.<5>____rpc_handler_3211178542 = val6;
				obj6 = (object)val6;
			}
			_rpc_func_table6.Add(3211178542u, (RpcReceiveHandler)obj6);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table7 = NetworkManager.__rpc_func_table;
			object obj7 = <>O.<6>____rpc_handler_543789041;
			if (obj7 == null)
			{
				RpcReceiveHandler val7 = __rpc_handler_543789041;
				<>O.<6>____rpc_handler_543789041 = val7;
				obj7 = (object)val7;
			}
			_rpc_func_table7.Add(543789041u, (RpcReceiveHandler)obj7);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table8 = NetworkManager.__rpc_func_table;
			object obj8 = <>O.<7>____rpc_handler_3186420411;
			if (obj8 == null)
			{
				RpcReceiveHandler val8 = __rpc_handler_3186420411;
				<>O.<7>____rpc_handler_3186420411 = val8;
				obj8 = (object)val8;
			}
			_rpc_func_table8.Add(3186420411u, (RpcReceiveHandler)obj8);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table9 = NetworkManager.__rpc_func_table;
			object obj9 = <>O.<8>____rpc_handler_2423799401;
			if (obj9 == null)
			{
				RpcReceiveHandler val9 = __rpc_handler_2423799401;
				<>O.<8>____rpc_handler_2423799401 = val9;
				obj9 = (object)val9;
			}
			_rpc_func_table9.Add(2423799401u, (RpcReceiveHandler)obj9);
			Dictionary<uint, RpcReceiveHandler> _rpc_func_table10 = NetworkManager.__rpc_func_table;
			object obj10 = <>O.<9>____rpc_handler_2631100579;
			if (obj10 == null)
			{
				RpcReceiveHandler val10 = __rpc_handler_2631100579;
				<>O.<9>____rpc_handler_2631100579 = val10;
				obj10 = (object)val10;
			}
			_rpc_func_table10.Add(2631100579u, (RpcReceiveHandler)obj10);
		}

		private static void __rpc_handler_537851232(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerObjectId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerObjectId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)1;
				((DrConAI)(object)target).BeginChasingPlayerServerRpc(playerObjectId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1631869031(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerObjectId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerObjectId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)2;
				((DrConAI)(object)target).BeginChasingPlayerClientRpc(playerObjectId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3631905316(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)1;
				((DrConAI)(object)target).AttackPlayerServerRpc(playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2705285129(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)2;
				((DrConAI)(object)target).AttackPlayerClientRpc(playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3215422204(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)1;
				((DrConAI)(object)target).KillPlayerServerRpc(playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3211178542(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)2;
				((DrConAI)(object)target).KillPlayerClientRpc(playerId);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_543789041(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)1;
				((DrConAI)(object)target).ToIdleServerRpc();
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3186420411(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)2;
				((DrConAI)(object)target).ToIdleClientRpc();
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2423799401(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: 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_0033: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				bool remove = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref remove, default(ForPrimitives));
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)1;
				((DrConAI)(object)target).AddTargetToListServerRpc(playerId, remove);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2631100579(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_001e: 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_0033: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)(DrConAI)(object)target).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				bool remove = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref remove, default(ForPrimitives));
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)2;
				((DrConAI)(object)target).AddTargetToListClientRpc(playerId, remove);
				((NetworkBehaviour)(DrConAI)(object)target).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_DrConAI()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing