using System;
using System.Linq;
using EntityStates;
using EntityStates.AI;
using HG;
using JetBrains.Annotations;
using RoR2.Navigation;
using UnityEngine;
using UnityEngine.Networking;

namespace RoR2.CharacterAI;

[RequireComponent(typeof(CharacterMaster))]
public class BaseAI : MonoBehaviour, IManagedMonoBehaviour
{
	[Serializable]
	public class Target
	{
		private readonly BaseAI owner;

		private bool unset = true;

		private GameObject _gameObject;

		private float losCheckTimer;

		public HurtBox bestHurtBox;

		private HurtBoxGroup hurtBoxGroup;

		private HurtBox mainHurtBox;

		private int bullseyeCount;

		private Vector3? lastKnownBullseyePosition;

		private Run.FixedTimeStamp lastKnownBullseyePositionTime = Run.FixedTimeStamp.negativeInfinity;

		public bool hasLoS;

		public GameObject gameObject
		{
			get
			{
				return _gameObject;
			}
			set
			{
				if ((object)value != _gameObject)
				{
					_gameObject = value;
					characterBody = gameObject?.GetComponent<CharacterBody>();
					healthComponent = characterBody?.healthComponent;
					hurtBoxGroup = characterBody?.hurtBoxGroup;
					bullseyeCount = (hurtBoxGroup ? hurtBoxGroup.bullseyeCount : 0);
					mainHurtBox = (hurtBoxGroup ? hurtBoxGroup.mainHurtBox : null);
					bestHurtBox = mainHurtBox;
					hasLoS = false;
					unset = !_gameObject;
				}
			}
		}

		public CharacterBody characterBody { get; private set; }

		public HealthComponent healthComponent { get; private set; }

		public Target([NotNull] BaseAI owner)
		{
			this.owner = owner;
		}

		public void Update()
		{
			if ((bool)gameObject)
			{
				hasLoS = (bool)bestHurtBox && owner.HasLOS(bestHurtBox.transform.position);
				if (bullseyeCount > 1 && !hasLoS)
				{
					bestHurtBox = GetBestHurtBox(out hasLoS);
				}
			}
		}

		public bool TestLOSNow()
		{
			if ((bool)bestHurtBox)
			{
				return owner.HasLOS(bestHurtBox.transform.position);
			}
			return false;
		}

		public bool GetBullseyePosition(out Vector3 position)
		{
			if ((bool)characterBody && (bool)owner.body && (characterBody.GetVisibilityLevel(owner.body) >= VisibilityLevel.Revealed || lastKnownBullseyePositionTime.timeSince >= 2f))
			{
				if ((bool)bestHurtBox)
				{
					lastKnownBullseyePosition = bestHurtBox.transform.position;
				}
				else
				{
					lastKnownBullseyePosition = null;
				}
				lastKnownBullseyePositionTime = Run.FixedTimeStamp.now;
			}
			if (lastKnownBullseyePosition.HasValue)
			{
				position = lastKnownBullseyePosition.Value;
				return true;
			}
			position = (gameObject ? gameObject.transform.position : Vector3.zero);
			return false;
		}

		private HurtBox GetBestHurtBox(out bool hadLoS)
		{
			if ((bool)owner && (bool)owner.bodyInputBank && (bool)hurtBoxGroup)
			{
				Vector3 aimOrigin = owner.bodyInputBank.aimOrigin;
				HurtBox hurtBox = null;
				float num = float.PositiveInfinity;
				HurtBox[] hurtBoxes = hurtBoxGroup.hurtBoxes;
				foreach (HurtBox hurtBox2 in hurtBoxes)
				{
					if (!hurtBox2 || !hurtBox2.transform || !hurtBox2.isBullseye)
					{
						continue;
					}
					Vector3 position = hurtBox2.transform.position;
					if (CheckLoS(aimOrigin, hurtBox2.transform.position))
					{
						float sqrMagnitude = (position - aimOrigin).sqrMagnitude;
						if (sqrMagnitude < num)
						{
							num = sqrMagnitude;
							hurtBox = hurtBox2;
						}
					}
				}
				if ((bool)hurtBox)
				{
					hadLoS = true;
					return hurtBox;
				}
			}
			hadLoS = false;
			return mainHurtBox;
		}

		public void Reset()
		{
			if (!unset)
			{
				_gameObject = null;
				characterBody = null;
				healthComponent = null;
				hurtBoxGroup = null;
				bullseyeCount = 0;
				mainHurtBox = null;
				bestHurtBox = mainHurtBox;
				hasLoS = false;
				unset = true;
				losCheckTimer = 0f;
			}
		}
	}

	public struct SkillDriverEvaluation
	{
		public AISkillDriver dominantSkillDriver;

		public Target target;

		public Target aimTarget;

		public float separationSqrMagnitude;
	}

	public struct BodyInputs
	{
		public Vector3 desiredAimDirection;

		public Vector3 moveVector;

		public bool pressSprint;

		public bool pressJump;

		public bool pressSkill1;

		public bool pressSkill2;

		public bool pressSkill3;

		public bool pressSkill4;

		public bool pressActivateEquipment;
	}

	public bool showDebugStateChanges;

	[Tooltip("If true, this character can spot enemies behind itself.")]
	public bool fullVision;

	[Tooltip("If true, this AI will not be allowed to retaliate against damage received from a source on its own team.")]
	public bool neverRetaliateFriendlies;

	public float enemyAttentionDuration = 5f;

	public MapNodeGroup.GraphType desiredSpawnNodeGraphType;

	[Tooltip("The state machine to run while the body exists.")]
	public EntityStateMachine stateMachine;

	public SerializableEntityStateType scanState;

	public bool isHealer;

	public float enemyAttention;

	public float aimVectorDampTime = 0.2f;

	public float aimVectorMaxSpeed = 6f;

	private float aimVelocity;

	private float targetRefreshTimer;

	private const float targetRefreshInterval = 0.5f;

	public LocalNavigator localNavigator = new LocalNavigator();

	public string selectedSkilldriverName;

	private const float maxVisionDistance = float.PositiveInfinity;

	[Tooltip("If true and this AI remains off-screen from players until its first shot, that shot will miss. The desired skill must handle this behaviour itself. If not this will do nothing")]
	public bool shouldMissFirstOffScreenShot;

	private float offScreenUpdateTimer;

	private const float offScreenUpdateInterval = 0.25f;

	public static readonly NodeGraphNavigationSystem nodeGraphNavigationSystem = new NodeGraphNavigationSystem();

	private BroadNavigationSystem _broadNavigationSystem;

	private BroadNavigationSystem.Agent _broadNavigationAgent = BroadNavigationSystem.Agent.invalid;

	public bool forceUpdateEveryFrame;

	public HurtBox debugEnemyHurtBox;

	private BullseyeSearch enemySearch = new BullseyeSearch();

	private BullseyeSearch buddySearch = new BullseyeSearch();

	private float skillDriverUpdateTimer;

	private const float skillDriverMinUpdateInterval = 1f / 6f;

	private const float skillDriverMaxUpdateInterval = 0.2f;

	public SkillDriverEvaluation skillDriverEvaluation;

	protected BodyInputs bodyInputs;

	public CharacterMaster master { get; protected set; }

	public CharacterBody body { get; protected set; }

	public Transform bodyTransform { get; protected set; }

	public CharacterDirection bodyCharacterDirection { get; protected set; }

	public CharacterMotor bodyCharacterMotor { get; protected set; }

	public InputBankTest bodyInputBank { get; protected set; }

	public HealthComponent bodyHealthComponent { get; protected set; }

	public SkillLocator bodySkillLocator { get; protected set; }

	public NetworkIdentity networkIdentity { get; protected set; }

	public AISkillDriver[] skillDrivers { get; protected set; }

	public bool hasAimConfirmation { get; private set; }

	public bool hasAimTarget
	{
		get
		{
			if (skillDriverEvaluation.aimTarget != null)
			{
				return skillDriverEvaluation.aimTarget.gameObject;
			}
			return false;
		}
	}

	private BroadNavigationSystem broadNavigationSystem
	{
		get
		{
			return _broadNavigationSystem;
		}
		set
		{
			if (_broadNavigationSystem != value)
			{
				_broadNavigationSystem?.ReturnAgent(ref _broadNavigationAgent);
				_broadNavigationSystem = value;
				_broadNavigationSystem?.RequestAgent(ref _broadNavigationAgent);
			}
		}
	}

	public BroadNavigationSystem.Agent broadNavigationAgent => _broadNavigationAgent;

	public bool AlwaysUpdate => forceUpdateEveryFrame;

	public Target currentEnemy { get; private set; }

	public Target leader { get; private set; }

	private Target buddy { get; set; }

	public Target customTarget { get; private set; }

	public event Action<CharacterBody> onBodyDiscovered;

	public event Action<CharacterBody> onBodyLost;

	[ContextMenu("Toggle broad navigation debug drawing")]
	private void ToggleBroadNavigationDebugDraw()
	{
		if (broadNavigationSystem is NodeGraphNavigationSystem)
		{
			NodeGraphNavigationSystem.Agent agent = (NodeGraphNavigationSystem.Agent)broadNavigationAgent;
			agent.drawPath = !agent.drawPath;
		}
	}

	public void SetBroadNavigationDebugDrawEnabled(bool newBroadNavigationDebugDrawEnabled)
	{
		if (broadNavigationSystem is NodeGraphNavigationSystem)
		{
			NodeGraphNavigationSystem.Agent agent = (NodeGraphNavigationSystem.Agent)broadNavigationAgent;
			agent.drawPath = newBroadNavigationDebugDrawEnabled;
		}
	}

	protected void Awake()
	{
		targetRefreshTimer = 0.5f;
		master = GetComponent<CharacterMaster>();
		stateMachine = GetComponent<EntityStateMachine>();
		stateMachine.enabled = false;
		networkIdentity = GetComponent<NetworkIdentity>();
		skillDrivers = GetComponents<AISkillDriver>();
		currentEnemy = new Target(this);
		leader = new Target(this);
		buddy = new Target(this);
		customTarget = new Target(this);
		broadNavigationSystem = nodeGraphNavigationSystem;
	}

	protected void OnDestroy()
	{
		broadNavigationSystem = null;
	}

	protected void Start()
	{
		if (!Util.HasEffectiveAuthority(networkIdentity))
		{
			base.enabled = false;
			if ((bool)stateMachine)
			{
				stateMachine.enabled = false;
			}
		}
		if (NetworkServer.active)
		{
			skillDriverUpdateTimer = UnityEngine.Random.value;
		}
	}

	protected void FixedUpdate()
	{
		ManagedFixedUpdate(Time.fixedDeltaTime);
	}

	public void ManagedFixedUpdate(float deltaTime)
	{
		enemyAttention -= deltaTime;
		targetRefreshTimer -= deltaTime;
		skillDriverUpdateTimer -= deltaTime;
		if ((bool)body)
		{
			if (shouldMissFirstOffScreenShot)
			{
				offScreenUpdateTimer -= deltaTime;
				if (offScreenUpdateTimer <= 0f)
				{
					offScreenUpdateTimer = 0.25f;
					shouldMissFirstOffScreenShot = OffScreenMissHelper.IsPositionOffScreen(body.transform.position);
				}
			}
			broadNavigationAgent.ConfigureFromBody(body);
			if (skillDriverUpdateTimer <= 0f)
			{
				if ((bool)skillDriverEvaluation.dominantSkillDriver && skillDriverEvaluation.dominantSkillDriver.resetCurrentEnemyOnNextDriverSelection)
				{
					currentEnemy.Reset();
					targetRefreshTimer = 0f;
				}
				if (!currentEnemy.gameObject && targetRefreshTimer <= 0f)
				{
					targetRefreshTimer = 0.5f;
					HurtBox hurtBox = null;
					hurtBox = FindEnemyHurtBox(float.PositiveInfinity, fullVision, filterByLoS: true);
					if ((bool)hurtBox && (bool)hurtBox.healthComponent)
					{
						currentEnemy.gameObject = hurtBox.healthComponent.gameObject;
						currentEnemy.bestHurtBox = hurtBox;
					}
					if ((bool)currentEnemy.gameObject)
					{
						enemyAttention = enemyAttentionDuration;
					}
				}
				BeginSkillDriver(EvaluateSkillDrivers());
			}
		}
		_broadNavigationAgent.currentPosition = GetNavigationStartPos();
		UpdateBodyInputs();
		UpdateBodyAim(deltaTime);
		debugEnemyHurtBox = currentEnemy.bestHurtBox;
	}

	private void BeginSkillDriver(SkillDriverEvaluation newSkillDriverEvaluation)
	{
		if ((bool)skillDriverEvaluation.dominantSkillDriver)
		{
			_ = skillDriverEvaluation.dominantSkillDriver.customName;
		}
		skillDriverEvaluation = newSkillDriverEvaluation;
		skillDriverUpdateTimer = UnityEngine.Random.Range(1f / 6f, 0.2f);
		if ((bool)skillDriverEvaluation.dominantSkillDriver)
		{
			_ = showDebugStateChanges;
			selectedSkilldriverName = skillDriverEvaluation.dominantSkillDriver.customName;
			if (skillDriverEvaluation.dominantSkillDriver.driverUpdateTimerOverride >= 0f)
			{
				skillDriverUpdateTimer = skillDriverEvaluation.dominantSkillDriver.driverUpdateTimerOverride;
			}
			skillDriverEvaluation.dominantSkillDriver.OnSelected();
		}
		else
		{
			_ = showDebugStateChanges;
			selectedSkilldriverName = "";
		}
	}

	public virtual void OnBodyStart(CharacterBody newBody)
	{
		body = newBody;
		bodyTransform = newBody.transform;
		bodyCharacterDirection = newBody.GetComponent<CharacterDirection>();
		bodyCharacterMotor = newBody.GetComponent<CharacterMotor>();
		bodyInputBank = newBody.GetComponent<InputBankTest>();
		bodyHealthComponent = newBody.GetComponent<HealthComponent>();
		bodySkillLocator = newBody.GetComponent<SkillLocator>();
		localNavigator.SetBody(newBody);
		_broadNavigationAgent.enabled = true;
		if ((bool)stateMachine && Util.HasEffectiveAuthority(networkIdentity))
		{
			stateMachine.enabled = true;
			stateMachine.SetNextState(EntityStateCatalog.InstantiateState(ref scanState));
		}
		base.enabled = true;
		if ((bool)bodyCharacterDirection)
		{
			bodyInputs.desiredAimDirection = bodyCharacterDirection.forward;
		}
		else
		{
			bodyInputs.desiredAimDirection = bodyTransform.forward;
		}
		if ((bool)bodyInputBank)
		{
			bodyInputBank.aimDirection = bodyInputs.desiredAimDirection;
		}
		this.onBodyDiscovered?.Invoke(newBody);
	}

	public virtual void OnBodyDeath(CharacterBody characterBody)
	{
		OnBodyLost(characterBody);
	}

	public virtual void OnBodyDestroyed(CharacterBody characterBody)
	{
		OnBodyLost(characterBody);
	}

	public virtual void OnBodyLost(CharacterBody characterBody)
	{
		if ((object)body != null)
		{
			base.enabled = false;
			body = null;
			bodyTransform = null;
			bodyCharacterDirection = null;
			bodyCharacterMotor = null;
			bodyInputBank = null;
			bodyHealthComponent = null;
			bodySkillLocator = null;
			localNavigator.SetBody(null);
			_broadNavigationAgent.enabled = false;
			if ((bool)stateMachine)
			{
				stateMachine.enabled = false;
				stateMachine.SetNextState(new Idle());
			}
			this.onBodyLost?.Invoke(characterBody);
		}
	}

	public virtual void OnBodyDamaged(DamageReport damageReport)
	{
		DamageInfo damageInfo = damageReport.damageInfo;
		if ((bool)damageInfo.attacker && (bool)body && (!currentEnemy.gameObject || enemyAttention <= 0f) && damageInfo.attacker != body.gameObject && (!neverRetaliateFriendlies || !damageReport.isFriendlyFire))
		{
			currentEnemy.gameObject = damageInfo.attacker;
			enemyAttention = enemyAttentionDuration;
		}
	}

	[Obsolete]
	public virtual bool HasLOS(Vector3 start, Vector3 end)
	{
		if (!body)
		{
			return false;
		}
		Vector3 direction = end - start;
		float magnitude = direction.magnitude;
		if (body.visionDistance < magnitude)
		{
			return false;
		}
		Ray ray = default(Ray);
		ray.origin = start;
		ray.direction = direction;
		RaycastHit hitInfo;
		return !Physics.Raycast(ray, out hitInfo, magnitude, LayerIndex.world.mask);
	}

	public virtual bool HasLOS(Vector3 end)
	{
		if (!body || !bodyInputBank)
		{
			return false;
		}
		Vector3 aimOrigin = bodyInputBank.aimOrigin;
		Vector3 direction = end - aimOrigin;
		float magnitude = direction.magnitude;
		if (body.visionDistance < magnitude)
		{
			return false;
		}
		Ray ray = default(Ray);
		ray.origin = aimOrigin;
		ray.direction = direction;
		RaycastHit hitInfo;
		return !Physics.Raycast(ray, out hitInfo, magnitude, LayerIndex.world.mask);
	}

	private Vector3? GetNavigationStartPos()
	{
		if (!body)
		{
			return null;
		}
		return body.footPosition;
	}

	public NodeGraph GetDesiredSpawnNodeGraph()
	{
		return SceneInfo.instance.GetNodeGraph(desiredSpawnNodeGraphType);
	}

	public void SetGoalPosition(Vector3? goalPos)
	{
		BroadNavigationSystem.Agent agent = broadNavigationAgent;
		agent.goalPosition = goalPos;
	}

	public void SetGoalPosition(Target goalTarget)
	{
		Vector3? goalPosition = null;
		if (goalTarget.GetBullseyePosition(out var position))
		{
			Vector3 value = position;
			goalPosition = value;
		}
		SetGoalPosition(goalPosition);
	}

	public void DebugDrawPath(Color color, float duration)
	{
		if (broadNavigationSystem is NodeGraphNavigationSystem)
		{
			((NodeGraphNavigationSystem.Agent)broadNavigationAgent).DebugDrawPath(color, duration);
		}
	}

	private static bool CheckLoS(Vector3 start, Vector3 end)
	{
		Vector3 direction = end - start;
		RaycastHit hitInfo;
		return !Physics.Raycast(start, direction, out hitInfo, direction.magnitude, LayerIndex.world.mask, QueryTriggerInteraction.Ignore);
	}

	public HurtBox GetBestHurtBox(GameObject target)
	{
		HurtBoxGroup hurtBoxGroup = target.GetComponent<CharacterBody>()?.hurtBoxGroup;
		if ((bool)hurtBoxGroup && hurtBoxGroup.bullseyeCount > 1 && (bool)bodyInputBank)
		{
			Vector3 aimOrigin = bodyInputBank.aimOrigin;
			HurtBox hurtBox = null;
			float num = float.PositiveInfinity;
			HurtBox[] hurtBoxes = hurtBoxGroup.hurtBoxes;
			foreach (HurtBox hurtBox2 in hurtBoxes)
			{
				if (!hurtBox2.isBullseye)
				{
					continue;
				}
				Vector3 position = hurtBox2.transform.position;
				if (CheckLoS(aimOrigin, hurtBox2.transform.position))
				{
					float sqrMagnitude = (position - aimOrigin).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						hurtBox = hurtBox2;
					}
				}
			}
			if ((bool)hurtBox)
			{
				return hurtBox;
			}
		}
		return Util.FindBodyMainHurtBox(target);
	}

	public void ForceAcquireNearestEnemyIfNoCurrentEnemy()
	{
		if ((bool)currentEnemy.gameObject)
		{
			return;
		}
		if (!body)
		{
			Debug.LogErrorFormat("BaseAI.ForceAcquireNearestEnemyIfNoCurrentEnemy for CharacterMaster '{0}' failed: AI has no body to search from.", base.gameObject.name);
			return;
		}
		HurtBox hurtBox = FindEnemyHurtBox(float.PositiveInfinity, full360Vision: true, filterByLoS: false);
		if ((bool)hurtBox && (bool)hurtBox.healthComponent)
		{
			currentEnemy.gameObject = hurtBox.healthComponent.gameObject;
			currentEnemy.bestHurtBox = hurtBox;
		}
	}

	private HurtBox FindEnemyHurtBox(float maxDistance, bool full360Vision, bool filterByLoS)
	{
		if (!body)
		{
			return null;
		}
		enemySearch.viewer = body;
		enemySearch.teamMaskFilter = TeamMask.allButNeutral;
		enemySearch.teamMaskFilter.RemoveTeam(master.teamIndex);
		enemySearch.sortMode = BullseyeSearch.SortMode.Distance;
		enemySearch.minDistanceFilter = 0f;
		enemySearch.maxDistanceFilter = maxDistance;
		enemySearch.searchOrigin = bodyInputBank.aimOrigin;
		enemySearch.searchDirection = bodyInputBank.aimDirection;
		enemySearch.maxAngleFilter = (full360Vision ? 180f : 90f);
		enemySearch.filterByLoS = filterByLoS;
		enemySearch.RefreshCandidates();
		return enemySearch.GetResults().FirstOrDefault();
	}

	public bool GameObjectPassesSkillDriverFilters(Target target, AISkillDriver skillDriver, out float separationSqrMagnitude)
	{
		separationSqrMagnitude = 0f;
		if (!target.gameObject)
		{
			return false;
		}
		float num = 1f;
		if ((bool)target.healthComponent)
		{
			num = target.healthComponent.combinedHealthFraction;
		}
		if (num < skillDriver.minTargetHealthFraction || num > skillDriver.maxTargetHealthFraction)
		{
			return false;
		}
		float num2 = 0f;
		if ((bool)body)
		{
			num2 = body.radius;
		}
		float num3 = 0f;
		if ((bool)target.characterBody)
		{
			num3 = target.characterBody.radius;
		}
		Vector3 vector = (bodyInputBank ? bodyInputBank.aimOrigin : bodyTransform.position);
		target.GetBullseyePosition(out var position);
		float sqrMagnitude = (position - vector).sqrMagnitude;
		separationSqrMagnitude = sqrMagnitude - num3 * num3 - num2 * num2;
		if (separationSqrMagnitude < skillDriver.minDistanceSqr || separationSqrMagnitude > skillDriver.maxDistanceSqr)
		{
			return false;
		}
		if (skillDriver.selectionRequiresTargetLoS && !target.hasLoS)
		{
			return false;
		}
		return true;
	}

	private void UpdateTargets()
	{
		currentEnemy.Update();
		leader.Update();
	}

	protected SkillDriverEvaluation? EvaluateSingleSkillDriver(in SkillDriverEvaluation currentSkillDriverEvaluation, AISkillDriver aiSkillDriver, float myHealthFraction)
	{
		if (!body || !bodySkillLocator)
		{
			return null;
		}
		float separationSqrMagnitude = float.PositiveInfinity;
		if (aiSkillDriver.noRepeat && currentSkillDriverEvaluation.dominantSkillDriver == aiSkillDriver)
		{
			return null;
		}
		if (aiSkillDriver.maxTimesSelected >= 0 && aiSkillDriver.timesSelected >= aiSkillDriver.maxTimesSelected)
		{
			return null;
		}
		Target target = null;
		if (aiSkillDriver.requireEquipmentReady && body.equipmentSlot.stock <= 0)
		{
			return null;
		}
		if (aiSkillDriver.skillSlot != SkillSlot.None)
		{
			GenericSkill skill = bodySkillLocator.GetSkill(aiSkillDriver.skillSlot);
			if (aiSkillDriver.requireSkillReady && (!skill || !skill.IsReady()))
			{
				return null;
			}
			if ((bool)aiSkillDriver.requiredSkill && (!skill || !(skill.skillDef == aiSkillDriver.requiredSkill)))
			{
				return null;
			}
		}
		if (aiSkillDriver.minUserHealthFraction > myHealthFraction || aiSkillDriver.maxUserHealthFraction < myHealthFraction)
		{
			return null;
		}
		if ((bool)bodyCharacterMotor && !bodyCharacterMotor.isGrounded && aiSkillDriver.selectionRequiresOnGround)
		{
			return null;
		}
		switch (aiSkillDriver.moveTargetType)
		{
		case AISkillDriver.TargetType.CurrentEnemy:
			if (GameObjectPassesSkillDriverFilters(currentEnemy, aiSkillDriver, out separationSqrMagnitude))
			{
				target = currentEnemy;
			}
			break;
		case AISkillDriver.TargetType.NearestFriendlyInSkillRange:
			if ((bool)bodyInputBank)
			{
				buddySearch.teamMaskFilter = TeamMask.none;
				buddySearch.teamMaskFilter.AddTeam(master.teamIndex);
				buddySearch.sortMode = BullseyeSearch.SortMode.Distance;
				buddySearch.minDistanceFilter = aiSkillDriver.minDistanceSqr;
				buddySearch.maxDistanceFilter = aiSkillDriver.maxDistance;
				buddySearch.searchOrigin = bodyInputBank.aimOrigin;
				buddySearch.searchDirection = bodyInputBank.aimDirection;
				buddySearch.maxAngleFilter = 180f;
				buddySearch.filterByLoS = aiSkillDriver.activationRequiresTargetLoS;
				buddySearch.RefreshCandidates();
				if ((bool)body)
				{
					buddySearch.FilterOutGameObject(body.gameObject);
				}
				buddySearch.FilterCandidatesByHealthFraction(aiSkillDriver.minTargetHealthFraction, aiSkillDriver.maxTargetHealthFraction);
				HurtBox hurtBox = buddySearch.GetResults().FirstOrDefault();
				if ((bool)hurtBox && (bool)hurtBox.healthComponent)
				{
					buddy.gameObject = hurtBox.healthComponent.gameObject;
					buddy.bestHurtBox = hurtBox;
				}
				if (GameObjectPassesSkillDriverFilters(buddy, aiSkillDriver, out separationSqrMagnitude))
				{
					target = buddy;
				}
			}
			break;
		case AISkillDriver.TargetType.CurrentLeader:
			if (GameObjectPassesSkillDriverFilters(leader, aiSkillDriver, out separationSqrMagnitude))
			{
				target = leader;
			}
			break;
		case AISkillDriver.TargetType.Custom:
			if (GameObjectPassesSkillDriverFilters(customTarget, aiSkillDriver, out separationSqrMagnitude))
			{
				target = customTarget;
			}
			break;
		}
		if (target == null)
		{
			return null;
		}
		Target target2 = null;
		if (aiSkillDriver.aimType != 0)
		{
			bool flag = aiSkillDriver.selectionRequiresAimTarget;
			switch (aiSkillDriver.aimType)
			{
			case AISkillDriver.AimType.AtMoveTarget:
				target2 = target;
				break;
			case AISkillDriver.AimType.AtCurrentEnemy:
				target2 = currentEnemy;
				break;
			case AISkillDriver.AimType.AtCurrentLeader:
				target2 = leader;
				break;
			default:
				flag = false;
				break;
			}
			if (flag && (target2 == null || !target2.gameObject))
			{
				return null;
			}
		}
		SkillDriverEvaluation value = default(SkillDriverEvaluation);
		value.dominantSkillDriver = aiSkillDriver;
		value.target = target;
		value.aimTarget = target2;
		value.separationSqrMagnitude = separationSqrMagnitude;
		return value;
	}

	public SkillDriverEvaluation EvaluateSkillDrivers()
	{
		UpdateTargets();
		float myHealthFraction = 1f;
		if ((bool)bodyHealthComponent)
		{
			myHealthFraction = bodyHealthComponent.combinedHealthFraction;
		}
		if ((bool)bodySkillLocator)
		{
			if ((bool)this.skillDriverEvaluation.dominantSkillDriver && (bool)this.skillDriverEvaluation.dominantSkillDriver.nextHighPriorityOverride)
			{
				SkillDriverEvaluation? skillDriverEvaluation = EvaluateSingleSkillDriver(in this.skillDriverEvaluation, this.skillDriverEvaluation.dominantSkillDriver.nextHighPriorityOverride, myHealthFraction);
				if (skillDriverEvaluation.HasValue)
				{
					return skillDriverEvaluation.Value;
				}
			}
			for (int i = 0; i < skillDrivers.Length; i++)
			{
				AISkillDriver aISkillDriver = skillDrivers[i];
				if (aISkillDriver.enabled)
				{
					SkillDriverEvaluation? skillDriverEvaluation2 = EvaluateSingleSkillDriver(in this.skillDriverEvaluation, aISkillDriver, myHealthFraction);
					if (skillDriverEvaluation2.HasValue)
					{
						return skillDriverEvaluation2.Value;
					}
				}
			}
		}
		return default(SkillDriverEvaluation);
	}

	protected void UpdateBodyInputs()
	{
		if (stateMachine.state is BaseAIState baseAIState)
		{
			bodyInputs = baseAIState.GenerateBodyInputs(in bodyInputs);
		}
		if ((bool)bodyInputBank)
		{
			bodyInputBank.skill1.PushState(bodyInputs.pressSkill1);
			bodyInputBank.skill2.PushState(bodyInputs.pressSkill2);
			bodyInputBank.skill3.PushState(bodyInputs.pressSkill3);
			bodyInputBank.skill4.PushState(bodyInputs.pressSkill4);
			bodyInputBank.jump.PushState(bodyInputs.pressJump);
			bodyInputBank.sprint.PushState(bodyInputs.pressSprint);
			bodyInputBank.activateEquipment.PushState(bodyInputs.pressActivateEquipment);
			bodyInputBank.moveVector = bodyInputs.moveVector;
		}
	}

	protected void UpdateBodyAim(float deltaTime)
	{
		hasAimConfirmation = false;
		if ((bool)bodyInputBank)
		{
			Vector3 aimDirection = bodyInputBank.aimDirection;
			Vector3 desiredAimDirection = bodyInputs.desiredAimDirection;
			if (desiredAimDirection != Vector3.zero)
			{
				Quaternion target = Util.QuaternionSafeLookRotation(desiredAimDirection);
				Vector3 vector = Util.SmoothDampQuaternion(Util.QuaternionSafeLookRotation(aimDirection), maxSpeed: aimVectorMaxSpeed, target: target, currentVelocity: ref aimVelocity, smoothTime: aimVectorDampTime, deltaTime: deltaTime) * Vector3.forward;
				bodyInputBank.aimDirection = vector;
				hasAimConfirmation = Vector3.Dot(vector, desiredAimDirection) >= 0.95f;
			}
		}
	}

	[ConCommand(commandName = "ai_draw_path", flags = ConVarFlags.Cheat, helpText = "Enables or disables the drawing of the specified AI's broad navigation path. Format: ai_draw_path <CharacterMaster selector> <0/1>")]
	private static void CCAiDrawPath(ConCommandArgs args)
	{
		CharacterMaster argCharacterMasterInstance = args.GetArgCharacterMasterInstance(0);
		args.GetArgBool(1);
		if (!argCharacterMasterInstance)
		{
			throw new ConCommandException("Could not find target.");
		}
		BaseAI component = argCharacterMasterInstance.GetComponent<BaseAI>();
		if (!component)
		{
			throw new ConCommandException("Target has no AI.");
		}
		component.ToggleBroadNavigationDebugDraw();
	}
}