1203 lines
47 KiB
C#
1203 lines
47 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using UnityEngine;
|
|
|
|
namespace Invector.vCharacterController.AI
|
|
{
|
|
public static class ProtectedMethodInvekerHelper
|
|
{
|
|
/// <summary>
|
|
/// Invoke all method that contains the <see cref="vInitAIAttribute"/>
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="target"></param>
|
|
public static void InvokeInitAI<T>(this T target) where T : vControlAI
|
|
{
|
|
var methods = target.GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic
|
|
).Where(m => m.GetCustomAttributes(typeof(vInitAIAttribute), false).Length > 0)
|
|
.ToArray();
|
|
for (int i = 0; i < methods.Length; i++)
|
|
{
|
|
try
|
|
{
|
|
methods[i].Invoke(target, null);
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
}
|
|
[SelectionBase]
|
|
[vClassHeader("AI BASIC CONTROLLER", iconName = "AI-icon")]
|
|
public partial class vControlAI : vAIMotor, vIControlAI
|
|
{
|
|
#region Inspector Variables
|
|
[vEditorToolbar("Start")]
|
|
public bool disableAgentOnStart = true;
|
|
|
|
[vEditorToolbar("Agent", order = 5)]
|
|
[SerializeField] protected bool useNavMeshAgent = true;
|
|
[SerializeField] protected vAIUpdateQuality updatePathQuality = vAIUpdateQuality.Medium;
|
|
[SerializeField][Range(1f, 10f)] protected float aceleration = 8f;
|
|
[SerializeField][Range(0.05f, 10f)] protected float _stopingDistance = 0.2f;
|
|
[Header("Increase StoppingDistance by speed")]
|
|
[SerializeField][Range(0.05f, 10f)] protected float _walkingStopingDistance = 0.0f;
|
|
[SerializeField][Range(0.05f, 10f)] protected float _runningStopingDistance = 0.1f;
|
|
[SerializeField][Range(0.05f, 10f)] protected float _sprintingStopingDistance = 0.15f;
|
|
|
|
[vEditorToolbar("Waypoint", order = 6)]
|
|
[vHelpBox("You can create a new WaypointArea at the Invector/AIController/Components/Create new WaypointArea", vHelpBoxAttribute.MessageType.Info)]
|
|
[SerializeField] protected vWaypointArea _waypointArea;
|
|
[SerializeField] protected float _changeWaypointDistance;
|
|
[SerializeField] protected bool _invertWaypointsOrder;
|
|
[SerializeField] protected bool _randomStartingPoint = true;
|
|
[SerializeField] protected bool _randomWaypoint = true;
|
|
[SerializeField] protected bool startUsingSpecificWaypoint = false;
|
|
[SerializeField] protected int startWaypointIndex;
|
|
[SerializeField] protected bool startUsingNearWayPoint = false;
|
|
[SerializeField] protected bool _selfStartingPoint;
|
|
[SerializeField] protected Transform _customStartingPoint;
|
|
|
|
[vEditorToolbar("Detection", order = 7)]
|
|
[vHelpBox("Use a empty trasform inside the headBone transform as reference to the character Eyes", vHelpBoxAttribute.MessageType.None)]
|
|
public Transform detectionPointReference;
|
|
[SerializeField, vEnumFlag] public vAISightMethod sightMethod = vAISightMethod.Center | vAISightMethod.Top;
|
|
[SerializeField] protected vAIUpdateQuality findTargetUpdateQuality = vAIUpdateQuality.High;
|
|
[SerializeField] protected vAIUpdateQuality canseeTargetUpdateQuality = vAIUpdateQuality.Medium;
|
|
[SerializeField, Tooltip("find target with current target found")] protected bool findOtherTarget = false;
|
|
|
|
[SerializeField][Range(1, 100)] protected int maxTargetsDetection = 10;
|
|
[SerializeField] protected float _changeTargetDelay = 2f;
|
|
[SerializeField] protected bool findTargetByDistance = true;
|
|
[SerializeField] protected float _fieldOfView = 90f;
|
|
[SerializeField] protected float _minDistanceToDetect = 3f;
|
|
[SerializeField] protected float _maxDistanceToDetect = 6f;
|
|
[SerializeField][vReadOnly] protected bool _hasPositionOfTheTarget;
|
|
[SerializeField][vReadOnly] protected bool _targetInLineOfSight;
|
|
[vHelpBox("Considerer maxDistanceToDetect value + lostTargetDistance", vHelpBoxAttribute.MessageType.None)]
|
|
[SerializeField] protected float _lostTargetDistance = 4f;
|
|
[SerializeField] protected float _timeToLostWithoutSight = 5f;
|
|
|
|
[Header("--- Layers to Detect ----")]
|
|
[SerializeField] protected LayerMask _detectLayer;
|
|
[SerializeField] protected vTagMask _detectTags;
|
|
[SerializeField] protected LayerMask _obstacles = 1 << 0;
|
|
[vEditorToolbar("Targets")]
|
|
[vSeparator("Inside Range")]
|
|
[SerializeField] protected List<vAITarget> targetsInRange = new List<vAITarget>();
|
|
[vSeparator("Current")]
|
|
[SerializeField] protected vAITarget _currentTarget;
|
|
[vSeparator("Storage")]
|
|
[SerializeField] protected List<vAITarget> _secundaryTargets = new List<vAITarget>();
|
|
[vEditorToolbar("Debug")]
|
|
[vHelpBox("Debug Options")]
|
|
[SerializeField] protected bool _debugVisualDetection;
|
|
[SerializeField] protected bool _debugRaySight;
|
|
[SerializeField] protected bool _debugLastTargetPosition;
|
|
[SerializeField] protected vAIReceivedDamegeInfo _receivedDamage = new vAIReceivedDamegeInfo();
|
|
|
|
|
|
internal vAIHeadtrack _headtrack;
|
|
protected Collider[] targetsBuffer;
|
|
|
|
public List<vAITarget> secundaryTargets { get=> _secundaryTargets; set=> _secundaryTargets=value; }
|
|
protected Vector3 _lastTargetPosition;
|
|
protected int _currentWaypoint;
|
|
|
|
protected float lostTargetTime;
|
|
protected Vector3 lastValidDestination;
|
|
protected UnityEngine.AI.NavMeshHit navHit;
|
|
protected float changeTargetTime;
|
|
|
|
public virtual void CreatePrimaryComponents()
|
|
{
|
|
if (GetComponent<Rigidbody>() == null)
|
|
{
|
|
gameObject.AddComponent<Rigidbody>();
|
|
var rigidbody = GetComponent<Rigidbody>();
|
|
rigidbody.mass = 50f;
|
|
rigidbody.constraints = RigidbodyConstraints.FreezeRotation;
|
|
}
|
|
|
|
if (GetComponent<CapsuleCollider>() == null)
|
|
{
|
|
var capsuler = gameObject.AddComponent<CapsuleCollider>();
|
|
animator = GetComponent<Animator>();
|
|
if (animator)
|
|
{
|
|
var foot = animator.GetBoneTransform(HumanBodyBones.LeftFoot);
|
|
var hips = animator.GetBoneTransform(HumanBodyBones.Hips);
|
|
var height = (float)System.Math.Round(Vector3.Distance(foot.position, hips.position) * 2f, 2);
|
|
capsuler.height = height;
|
|
capsuler.center = new Vector3(0, (float)System.Math.Round(capsuler.height * 0.5f, 2), 0);
|
|
capsuler.radius = (float)System.Math.Round(capsuler.height * 0.15f, 2);
|
|
}
|
|
}
|
|
if (GetComponent<UnityEngine.AI.NavMeshAgent>() == null) gameObject.AddComponent<UnityEngine.AI.NavMeshAgent>();
|
|
}
|
|
|
|
public virtual void CreateSecondaryComponents()
|
|
{
|
|
|
|
}
|
|
|
|
protected bool isWaypointStarted;
|
|
#endregion
|
|
|
|
#region NavMeshAgent Variables
|
|
|
|
protected Vector3 _destination;
|
|
protected Vector3 lasDestination;
|
|
|
|
[HideInInspector] public UnityEngine.AI.NavMeshAgent navMeshAgent;
|
|
protected UnityEngine.AI.NavMeshHit navMeshHit;
|
|
protected float updatePathTime;
|
|
protected float updateFindTargetTime;
|
|
protected float canseeTargetUpdateTime;
|
|
protected float timeToResetOutDistance;
|
|
protected float forceUpdatePathTime;
|
|
protected bool isOutOfDistance;
|
|
protected int findAgentDestinationRadius;
|
|
#endregion
|
|
|
|
#region OVERRIDE METHODS. AI
|
|
|
|
protected override void OnDrawGizmos()
|
|
{
|
|
base.OnDrawGizmos();
|
|
if (_debugLastTargetPosition)
|
|
{
|
|
if (currentTarget.transform && _hasPositionOfTheTarget)
|
|
{
|
|
var color = _targetInLineOfSight ? Color.green : Color.red;
|
|
color.a = 0.2f;
|
|
Gizmos.color = color;
|
|
Gizmos.DrawLine(transform.position + Vector3.up * 1.5f, lastTargetPosition + Vector3.up * 1.5f);
|
|
color.a = 1;
|
|
Gizmos.color = color;
|
|
Gizmos.DrawLine(lastTargetPosition, lastTargetPosition + Vector3.up * 1.5f);
|
|
var forward = (lastTargetPosition - transform.position).normalized;
|
|
forward.y = 0;
|
|
var right = Quaternion.AngleAxis(90, Vector3.up) * forward;
|
|
var p1 = lastTargetPosition + Vector3.up * 1.5f - forward;
|
|
var p2 = lastTargetPosition + Vector3.up * 1.5f + forward * 0.5f + right * 0.25f;
|
|
var p3 = lastTargetPosition + Vector3.up * 1.5f + forward * 0.5f - right * 0.25f;
|
|
Gizmos.DrawLine(p1, p2);
|
|
Gizmos.DrawLine(p1, p3);
|
|
Gizmos.DrawLine(p3, p2);
|
|
Gizmos.DrawSphere(lastTargetPosition + Vector3.up * 1.5f, 0.1f);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void Start()
|
|
{
|
|
_receivedDamage = new vAIReceivedDamegeInfo();
|
|
changeWaypointDistance = _changeWaypointDistance;
|
|
selfStartPosition = (!_selfStartingPoint && _customStartingPoint) ? _customStartingPoint.position : transform.position;
|
|
_destination = transform.position;
|
|
lasDestination = _destination;
|
|
navMeshAgent = GetComponent<UnityEngine.AI.NavMeshAgent>();
|
|
if (!navMeshAgent) return;
|
|
navMeshAgent.updatePosition = false;
|
|
navMeshAgent.updateRotation = false;
|
|
if (isOnNavMesh) navMeshAgent.enabled = true;
|
|
RotateTo(transform.forward);
|
|
|
|
if (currentTarget.transform != null) currentTarget.InitTarget(currentTarget.transform);
|
|
_headtrack = GetComponent<vAIHeadtrack>();
|
|
targetsBuffer = new Collider[maxTargetsDetection];
|
|
base.Start();
|
|
aiComponents = new Dictionary<System.Type, vIAIComponent>();
|
|
|
|
var _aiComponents = GetComponents<vIAIComponent>();
|
|
|
|
for (int i = 0; i < _aiComponents.Length; i++)
|
|
{
|
|
if (!aiComponents.ContainsKey(_aiComponents[i].ComponentType))
|
|
{
|
|
aiComponents.Add(_aiComponents[i].ComponentType, _aiComponents[i]);
|
|
}
|
|
}
|
|
StartCoroutine(AlignDetectionPoint());
|
|
|
|
this.InvokeInitAI();
|
|
}
|
|
|
|
protected virtual IEnumerator AlignDetectionPoint()
|
|
{
|
|
yield return new WaitForSeconds(.1f);
|
|
if (detectionPointReference) detectionPointReference.rotation = transform.rotation;
|
|
}
|
|
|
|
protected override void UpdateAI()
|
|
{
|
|
base.UpdateAI();
|
|
CalcMovementDirection();
|
|
|
|
HandleTarget();
|
|
if (receivedDamage != null) receivedDamage.Update();
|
|
|
|
}
|
|
|
|
public override void ResetRagdoll()
|
|
{
|
|
base.ResetRagdoll();
|
|
if (_headtrack) _headtrack.canLook = true;
|
|
}
|
|
|
|
public override void EnableRagdoll()
|
|
{
|
|
base.EnableRagdoll();
|
|
if (_headtrack) _headtrack.canLook = false;
|
|
}
|
|
|
|
public override void RemoveComponents()
|
|
{
|
|
base.RemoveComponents();
|
|
if (removeComponentsAfterDie)
|
|
Destroy(navMeshAgent);
|
|
}
|
|
|
|
protected override void OnAnimatorMove()
|
|
{
|
|
try {
|
|
if (Time.deltaTime == 0 || animator == null) return;
|
|
|
|
if (!customAction && useNavMeshAgent && navMeshAgent && navMeshAgent.enabled)
|
|
{
|
|
navMeshAgent.velocity = ((animator.deltaPosition) / Time.deltaTime) * Mathf.Clamp(remainingDistanceWithoutAgent - stopingDistance, 0, 1f);
|
|
//navMeshAgent.speed = Mathf.Clamp((float)System.Math.Round((double)(animator.deltaPosition / Time.deltaTime).magnitude , 2), 0.5f, maxSpeed);
|
|
navMeshAgent.speed = Mathf.Lerp(navMeshAgent.speed, maxSpeed, aceleration * Time.deltaTime);
|
|
navMeshAgent.nextPosition = animator.rootPosition;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogException(e, this);
|
|
}
|
|
base.OnAnimatorMove();
|
|
}
|
|
|
|
public override void Stop()
|
|
{
|
|
base.Stop();
|
|
if (useNavMeshAgent && navMeshAgent && navMeshAgent.isOnNavMesh && !navMeshAgent.isStopped)
|
|
{
|
|
//_turnOnSpotDirection = transform.forward;
|
|
//temporaryDirection = transform.forward;
|
|
navMeshAgent.isStopped = true;
|
|
this.destination = transform.position;
|
|
ForceUpdatePath();
|
|
navMeshAgent.ResetPath();
|
|
}
|
|
}
|
|
|
|
public override void DisableAIController()
|
|
{
|
|
if (disableAgentOnStart && navMeshAgent)
|
|
navMeshAgent.enabled = false;
|
|
base.DisableAIController();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region METHODS. AIAgent/Interfaces
|
|
|
|
#region Protected methods
|
|
|
|
protected virtual Dictionary<System.Type, vIAIComponent> aiComponents { get; set; }
|
|
|
|
protected virtual vWaypoint GetWaypoint()
|
|
{
|
|
if (waypointArea == null) return null;
|
|
var waypoints = waypointArea.GetValidPoints(_invertWaypointsOrder);
|
|
|
|
if (!isWaypointStarted)
|
|
{
|
|
if (startUsingSpecificWaypoint)
|
|
_currentWaypoint = startWaypointIndex % waypoints.Count;
|
|
|
|
else if (startUsingNearWayPoint)
|
|
_currentWaypoint = GetNearPointIndex();
|
|
|
|
else if (_randomWaypoint)
|
|
_currentWaypoint = UnityEngine.Random.Range(0, waypoints.Count);
|
|
else _currentWaypoint = 0;
|
|
|
|
}
|
|
|
|
if (isWaypointStarted)
|
|
{
|
|
if (_randomWaypoint)
|
|
_currentWaypoint = UnityEngine.Random.Range(0, waypoints.Count);
|
|
else
|
|
_currentWaypoint++;
|
|
|
|
}
|
|
|
|
if (!isWaypointStarted)
|
|
{
|
|
isWaypointStarted = true;
|
|
visitedWaypoints = new List<vWaypoint>();
|
|
}
|
|
|
|
if (_currentWaypoint >= waypoints.Count)
|
|
_currentWaypoint = 0;
|
|
|
|
if (waypoints.Count == 0)
|
|
return null;
|
|
|
|
if (visitedWaypoints.Count == waypoints.Count)
|
|
visitedWaypoints.Clear();
|
|
|
|
if (visitedWaypoints.Contains(waypoints[_currentWaypoint]))
|
|
return null;
|
|
|
|
return waypoints[_currentWaypoint];
|
|
}
|
|
|
|
public virtual int GetNearPointIndex()
|
|
{
|
|
var waypoint = waypointArea.GetValidPoints(_invertWaypointsOrder);
|
|
int targetWay = 0;
|
|
var dist = Mathf.Infinity;
|
|
for (int i = 0; i < waypoint.Count; i++)
|
|
{
|
|
var d = Vector3.Distance(transform.position, waypoint[i].position);
|
|
if (d < dist)
|
|
{
|
|
targetWay = i;
|
|
dist = d;
|
|
}
|
|
}
|
|
return targetWay;
|
|
}
|
|
|
|
protected virtual float GetUpdateTimeFromQuality(vAIUpdateQuality quality)
|
|
{
|
|
return quality == vAIUpdateQuality.VeryLow ? 2 : quality == vAIUpdateQuality.Low ? 1f : quality == vAIUpdateQuality.Medium ? 0.75f : quality == vAIUpdateQuality.High ? .25f : 0.1f;
|
|
}
|
|
|
|
protected virtual Vector3 destination
|
|
{
|
|
get
|
|
{
|
|
return _destination;
|
|
}
|
|
set
|
|
{
|
|
_destination = value;
|
|
}
|
|
}
|
|
|
|
protected virtual void UpdateAgentPath()
|
|
{
|
|
updatePathTime -= Time.deltaTime;
|
|
if (updatePathTime > 0 && forceUpdatePathTime <= 0f && navMeshAgent.hasPath) return;
|
|
forceUpdatePathTime -= Time.deltaTime;
|
|
updatePathTime = GetUpdateTimeFromQuality(updatePathQuality);
|
|
|
|
if (!isDead && !isJumping && isGrounded)
|
|
{
|
|
var destin = _destination;
|
|
|
|
if ((movementSpeed != vAIMovementSpeed.Idle && destin != lasDestination) || !navMeshAgent.hasPath)
|
|
{
|
|
if (navMeshAgent.enabled && navMeshAgent.isOnNavMesh)
|
|
{
|
|
if (UnityEngine.AI.NavMesh.SamplePosition(destin, out navHit, _capsuleCollider.radius + findAgentDestinationRadius, navMeshAgent.areaMask) && (navHit.position - navMeshAgent.destination).magnitude > stopingDistance)
|
|
{
|
|
navMeshAgent.destination = (navHit.position);
|
|
lasDestination = destin;
|
|
}
|
|
else if ((navHit.position - navMeshAgent.destination).magnitude > stopingDistance)
|
|
{
|
|
findAgentDestinationRadius++;
|
|
if (findAgentDestinationRadius >= 10)
|
|
{
|
|
findAgentDestinationRadius = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void CalcMovementDirection()
|
|
{
|
|
if (isDead || isJumping) return;
|
|
|
|
if (useNavMeshAgent && navMeshAgent)
|
|
{
|
|
ControlNavMeshAgent();
|
|
UpdateAgentPath();
|
|
}
|
|
|
|
bool forceMovement = !navMeshAgent.hasPath && remainingDistanceWithoutAgent > navMeshAgent.stoppingDistance + _capsuleCollider.radius;
|
|
var dir = !forceMovement && navMeshAgent != null && navMeshAgent.enabled && useNavMeshAgent ? desiredVelocity * (!isInDestination ? 1 : 0) :
|
|
((new Vector3(destination.x, transform.position.y, destination.z) - transform.position).normalized * Mathf.Clamp(remainingDistanceWithoutAgent - stopingDistance, 0, 1f));
|
|
//Convert Direction to Input
|
|
var movementInput = transform.InverseTransformDirection(dir);
|
|
|
|
if (useNavMeshAgent && navMeshAgent.enabled)
|
|
{
|
|
var data = navMeshAgent.currentOffMeshLinkData;
|
|
if (navMeshAgent.isOnOffMeshLink)
|
|
{
|
|
dir = (data.endPos - transform.position);
|
|
movementInput = transform.InverseTransformDirection(dir);
|
|
}
|
|
}
|
|
|
|
if (movementInput.magnitude > 0.1f)
|
|
{
|
|
|
|
if (temporaryDirectionTime <= 0 && isStrafing == false)
|
|
SetMovementInput(movementInput, aceleration);
|
|
else
|
|
SetMovementInput(movementInput, temporaryDirectionTime <= 0 ? transform.forward : temporaryDirection, aceleration);
|
|
}
|
|
else input = Vector3.zero;
|
|
if (!isGrounded || isJumping || isRolling) navMeshAgent.enabled = false;
|
|
}
|
|
|
|
public virtual Vector3 desiredVelocity => navMeshAgent.desiredVelocity;
|
|
|
|
protected virtual void CheckAgentDistanceFromAI()
|
|
{
|
|
if (!useNavMeshAgent || !navMeshAgent || !navMeshAgent.enabled) return;
|
|
if (Vector3.Distance(transform.position, navMeshAgent.nextPosition) > stopingDistance * 1.5f && !isOutOfDistance)
|
|
{
|
|
timeToResetOutDistance = 3f;
|
|
isOutOfDistance = true;
|
|
}
|
|
if (isOutOfDistance)
|
|
{
|
|
timeToResetOutDistance -= Time.deltaTime;
|
|
if (timeToResetOutDistance <= 0)
|
|
{
|
|
isOutOfDistance = false;
|
|
if (Vector3.Distance(transform.position, navMeshAgent.nextPosition) > stopingDistance)
|
|
{
|
|
navMeshAgent.enabled = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
protected virtual void ControlNavMeshAgent()
|
|
{
|
|
if (isDead) return;
|
|
if (useNavMeshAgent && navMeshAgent)
|
|
navMeshAgent.stoppingDistance = stopingDistance;
|
|
if (Time.deltaTime == 0 || navMeshAgent.enabled == false)
|
|
{
|
|
if (!ragdolled && !isJumping && isGrounded && !navMeshAgent.enabled && isOnNavMesh)
|
|
{
|
|
navMeshAgent.enabled = true;
|
|
}
|
|
}
|
|
|
|
if (navMeshAgent.enabled && isOnJumpLink && !isJumping && isGrounded)
|
|
{
|
|
var jumpDir = navMeshAgent.currentOffMeshLinkData.endPos - transform.position;
|
|
var jumpTarget = transform.position + jumpDir.normalized * (jumpDir.magnitude + stopingDistance);
|
|
JumpTo(jumpTarget);
|
|
}
|
|
|
|
if (isJumping || !isGrounded || ragdolled)
|
|
navMeshAgent.enabled = false;
|
|
CheckAgentDistanceFromAI();
|
|
}
|
|
|
|
protected virtual bool CheckCanSeeTarget()
|
|
{
|
|
if (currentTarget != null && currentTarget.transform != null && currentTarget.collider == null && InFOVAngle(currentTarget.transform.position, _fieldOfView))
|
|
{
|
|
if (sightMethod == 0) return true;
|
|
var eyesPoint = detectionPointReference ? detectionPointReference.position : transform.position + Vector3.up * (selfCollider.bounds.size.y * 0.8f);
|
|
if (!Physics.Linecast(eyesPoint, currentTarget.transform.position, _obstacles))
|
|
{
|
|
if (_debugRaySight)
|
|
Debug.DrawLine(eyesPoint, currentTarget.transform.position, Color.green, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (_debugRaySight)
|
|
Debug.DrawLine(eyesPoint, currentTarget.transform.position, Color.red, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
}
|
|
}
|
|
else if (currentTarget.collider) return CheckCanSeeTarget(currentTarget.collider);
|
|
|
|
return false;
|
|
}
|
|
|
|
protected virtual bool CheckCanSeeTarget(Collider target)
|
|
{
|
|
if (target != null && InFOVAngle(target.bounds.center, _fieldOfView))
|
|
{
|
|
if (sightMethod == 0) return true;
|
|
var detectionPoint = detectionPointReference ? detectionPointReference.position : transform.position + Vector3.up * (selfCollider.bounds.size.y * 0.8f);
|
|
if (sightMethod.Contains<vAISightMethod>(vAISightMethod.Center))
|
|
if (!Physics.Linecast(detectionPoint, target.bounds.center, _obstacles))
|
|
{
|
|
if (_debugRaySight) Debug.DrawLine(detectionPoint, target.bounds.center, Color.green, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (_debugRaySight) Debug.DrawLine(detectionPoint, target.bounds.center, Color.red, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
}
|
|
if (sightMethod.Contains<vAISightMethod>(vAISightMethod.Top))
|
|
if (!Physics.Linecast(detectionPoint, target.transform.position + Vector3.up * target.bounds.size.y * 0.9f, _obstacles))
|
|
{
|
|
if (_debugRaySight) Debug.DrawLine(detectionPoint, target.transform.position + Vector3.up * target.bounds.size.y * 0.9f, Color.green, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (_debugRaySight) Debug.DrawLine(detectionPoint, target.transform.position + Vector3.up * target.bounds.size.y * 0.9f, Color.red, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
}
|
|
if (sightMethod.Contains<vAISightMethod>(vAISightMethod.Bottom))
|
|
if (!Physics.Linecast(detectionPoint, target.transform.position + Vector3.up * target.bounds.size.y * 0.1f, _obstacles))
|
|
{
|
|
if (_debugRaySight) Debug.DrawLine(detectionPoint, target.transform.position + Vector3.up * target.bounds.size.y * 0.1f, Color.green, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (_debugRaySight) Debug.DrawLine(detectionPoint, target.transform.position + Vector3.up * target.bounds.size.y * 0.1f, Color.red, GetUpdateTimeFromQuality(canseeTargetUpdateQuality));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected virtual bool InFOVAngle(Vector3 viewPoint, float fieldOfView)
|
|
{
|
|
var eyesPoint = (detectionPointReference ? detectionPointReference.position : _capsuleCollider.bounds.center);
|
|
if (Vector3.Distance(eyesPoint, viewPoint) < _minDistanceToDetect) return true;
|
|
if (Vector3.Distance(eyesPoint, viewPoint) > _maxDistanceToDetect) return false;
|
|
|
|
var lookDirection = viewPoint - eyesPoint;
|
|
var rot = Quaternion.LookRotation(lookDirection, Vector3.up);
|
|
var detectionAngle = detectionPointReference ? detectionPointReference.eulerAngles : transform.eulerAngles;
|
|
var newAngle = rot.eulerAngles - detectionAngle;
|
|
var fovAngleY = newAngle.NormalizeAngle().y;
|
|
var fovAngleX = newAngle.NormalizeAngle().x;
|
|
if (fovAngleY <= (fieldOfView * 0.5f) && fovAngleY >= -(fieldOfView * 0.5f) && fovAngleX <= (fieldOfView * 0.5f) && fovAngleX >= -(fieldOfView * 0.5f))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
protected virtual void HandleTarget()
|
|
{
|
|
if (_hasPositionOfTheTarget && currentTarget.transform) lastTargetPosition = currentTarget.transform.position;
|
|
canseeTargetUpdateTime -= Time.deltaTime;
|
|
if (canseeTargetUpdateTime > 0) return;
|
|
if (currentTarget != null && currentTarget.transform)
|
|
{
|
|
_targetInLineOfSight = CheckCanSeeTarget();
|
|
if (!_targetInLineOfSight || targetDistance >= (_maxDistanceToDetect + _lostTargetDistance))
|
|
{
|
|
if (lostTargetTime < Time.time)
|
|
{
|
|
_hasPositionOfTheTarget = false;
|
|
lostTargetTime = Time.time + _timeToLostWithoutSight;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lostTargetTime = Time.time + _timeToLostWithoutSight;
|
|
_hasPositionOfTheTarget = true;
|
|
currentTarget.isLost = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_targetInLineOfSight = false;
|
|
_hasPositionOfTheTarget = false;
|
|
}
|
|
HandleLostTarget();
|
|
HandleTargetsInRange();
|
|
canseeTargetUpdateTime = GetUpdateTimeFromQuality(canseeTargetUpdateQuality);
|
|
}
|
|
|
|
protected virtual void HandleLostTarget()
|
|
{
|
|
if (currentTarget != null && currentTarget.transform != null)
|
|
{
|
|
if ((currentTarget.isDead || targetDistance > (_maxDistanceToDetect + _lostTargetDistance) || (!targetInLineOfSight && !_hasPositionOfTheTarget)))
|
|
{
|
|
if (currentTarget.isFixedTarget)
|
|
currentTarget.isLost = true;
|
|
else
|
|
currentTarget.ClearTarget();
|
|
}
|
|
else if ((currentTarget.transform == null || !currentTarget.transform.gameObject.activeSelf || targetDistance > (_maxDistanceToDetect + _lostTargetDistance) || (!targetInLineOfSight && !_hasPositionOfTheTarget)))
|
|
{
|
|
if (currentTarget.isFixedTarget)
|
|
currentTarget.isLost = true;
|
|
else
|
|
currentTarget.ClearTarget();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void HandleTargetsInRange()
|
|
{
|
|
for (int i = 0; i < targetsInRange.Count; i++)
|
|
{
|
|
var t = targetsInRange[i];
|
|
if (t.transform)
|
|
{
|
|
if (t.transform == currentTarget.transform) _currentTarget=t;
|
|
var distance = Vector3.Distance(t.transform.position, transform.position);
|
|
if (distance > _maxDistanceToDetect + _lostTargetDistance)
|
|
{
|
|
targetsInRange.RemoveAt(i);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
targetsInRange.RemoveAt(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual bool IsInLayerMask(int layer, LayerMask layermask)
|
|
{
|
|
return layermask == (layermask | (1 << layer));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public methods
|
|
|
|
public float fieldOfView { get => _fieldOfView; set => _fieldOfView = value; }
|
|
|
|
public float minDistanceToDetect { get => _minDistanceToDetect; set => _minDistanceToDetect = value; }
|
|
|
|
public float maxDistanceToDetect { get => _maxDistanceToDetect; set => _maxDistanceToDetect = value; }
|
|
|
|
public vAISightMethod SightMethod { get => sightMethod; set => sightMethod = value; }
|
|
|
|
public vAIUpdateQuality UpdatePathQuality { get => updatePathQuality; set => updatePathQuality = value; }
|
|
|
|
public vAIUpdateQuality FindTargetUpdateQuality { get => findTargetUpdateQuality; set => findTargetUpdateQuality = value; }
|
|
|
|
public vAIUpdateQuality CanseeTargetUpdateQuality { get => canseeTargetUpdateQuality; set => canseeTargetUpdateQuality = value; }
|
|
|
|
public virtual void SetDetectionLayer(LayerMask mask)
|
|
{
|
|
_detectLayer = mask;
|
|
}
|
|
|
|
public virtual void SetDetectionTags(List<string> tags)
|
|
{
|
|
_detectTags = tags;
|
|
}
|
|
|
|
public virtual void SetObstaclesLayer(LayerMask mask)
|
|
{
|
|
_obstacles = mask;
|
|
}
|
|
|
|
public virtual void SetLineOfSight(float fov = -1, float minDistToDetect = -1, float maxDistToDetect = -1, float lostTargetDistance = -1)
|
|
{
|
|
if (fov != -1) _fieldOfView = fov;
|
|
if (minDistToDetect != -1) _minDistanceToDetect = minDistToDetect;
|
|
if (maxDistToDetect != -1) _maxDistanceToDetect = maxDistToDetect;
|
|
if (lostTargetDistance != -1) _lostTargetDistance = lostTargetDistance;
|
|
}
|
|
|
|
public virtual vAIReceivedDamegeInfo receivedDamage { get { return _receivedDamage; } protected set { _receivedDamage = value; } }
|
|
|
|
public virtual bool targetInLineOfSight { get { return _targetInLineOfSight; } }
|
|
|
|
public virtual vAITarget currentTarget { get { return _currentTarget; } protected set { _currentTarget = value; } }
|
|
|
|
public virtual Vector3 lastTargetPosition
|
|
{
|
|
get
|
|
{
|
|
return _lastTargetPosition;
|
|
}
|
|
protected set
|
|
{
|
|
_lastTargetPosition = value;
|
|
}
|
|
}
|
|
|
|
public virtual float targetDistance
|
|
{
|
|
get
|
|
{
|
|
if (currentTarget == null || currentTarget.isDead) return Mathf.Infinity;
|
|
return Vector3.Distance(currentTarget.transform.position, transform.position);
|
|
}
|
|
}
|
|
|
|
public virtual List<vAITarget> GetTargetsInRange()
|
|
{
|
|
return targetsInRange;
|
|
}
|
|
|
|
public virtual void FindTarget()
|
|
{
|
|
FindSpecificTarget(_detectTags, _detectLayer, true);
|
|
}
|
|
|
|
public virtual void FindTarget(bool checkForObstacles)
|
|
{
|
|
FindSpecificTarget(_detectTags, _detectLayer, checkForObstacles);
|
|
}
|
|
|
|
public virtual void FindSpecificTarget(List<string> m_detectTags, LayerMask m_detectLayer, bool checkForObstables = true)
|
|
{
|
|
if (updateFindTargetTime > Time.time) return;
|
|
updateFindTargetTime = Time.time + GetUpdateTimeFromQuality(findTargetUpdateQuality);
|
|
|
|
int targetsCount = Physics.OverlapSphereNonAlloc(transform.position + transform.up, _maxDistanceToDetect, targetsBuffer, m_detectLayer);
|
|
|
|
if (targetsCount > 0)
|
|
{
|
|
|
|
Transform target = currentTarget != null && _hasPositionOfTheTarget ? currentTarget.transform : null;
|
|
var _targetDistance = target && targetInLineOfSight ? targetDistance : Mathf.Infinity;
|
|
bool targetFound = false;
|
|
for (int i = 0; i < targetsCount; i++)
|
|
{
|
|
if (targetsBuffer[i] != null && targetsBuffer[i].transform != transform && m_detectTags.Contains(targetsBuffer[i].gameObject.tag))
|
|
{
|
|
///Add new target in range
|
|
if(!targetsInRange.Exists(t=>t.transform == targetsBuffer[i].transform))
|
|
{
|
|
vAITarget t = new vAITarget(targetsBuffer[i].transform);
|
|
|
|
if(t.isDead==false) targetsInRange.Add(new vAITarget(targetsBuffer[i]));
|
|
}
|
|
if (!findOtherTarget && currentTarget.transform) continue;
|
|
if (currentTarget.transform && currentTarget.isFixedTarget && !findOtherTarget) continue;
|
|
///Store new target
|
|
if ( (findTargetByDistance || !targetFound) && (!checkForObstables || CheckCanSeeTarget(targetsBuffer[i])))
|
|
{
|
|
if (findTargetByDistance)
|
|
{
|
|
var newTargetDistance = Vector3.Distance(targetsBuffer[i].transform.position, transform.position);
|
|
|
|
if (newTargetDistance < _targetDistance)
|
|
{
|
|
target = targetsBuffer[i].transform;
|
|
targetFound = true;
|
|
_targetDistance = newTargetDistance;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
targetFound = true;
|
|
target = targetsBuffer[i].transform;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentTarget == null || target != null && target != currentTarget.transform)
|
|
{
|
|
if (target != null)
|
|
SetCurrentTarget(targetsInRange.Find(t=>t==target));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public virtual bool TryGetTarget(out vAITarget target)
|
|
{
|
|
return TryGetTarget(_detectTags, out target);
|
|
}
|
|
|
|
public virtual bool TryGetTarget(string tag, out vAITarget target)
|
|
{
|
|
var ts = targetsInRange.FindAll(c => c != null && c.transform!=null && c.transform.gameObject.CompareTag(tag));
|
|
if (ts != null && ts.Count > 1)
|
|
{
|
|
ts= ts.OrderBy(t => Vector3.Distance(t.transform.position, transform.position)).ToList();
|
|
}
|
|
|
|
if (ts != null && ts.Count > 0)
|
|
{
|
|
target = ts[0];
|
|
return true;
|
|
}
|
|
target = null;
|
|
return false;
|
|
}
|
|
|
|
public virtual bool TryGetTarget(List<string> detectTags, out vAITarget target)
|
|
{
|
|
var ts = targetsInRange.FindAll(c => c != null && c.transform != null && detectTags.Contains(c.transform.gameObject.tag));
|
|
|
|
if (ts != null && ts.Count > 1)
|
|
{
|
|
ts = ts.OrderBy(t => Vector3.Distance(t.transform.position, transform.position)).ToList();
|
|
}
|
|
|
|
if (ts != null && ts.Count > 0)
|
|
{
|
|
target = ts[0];
|
|
return true;
|
|
}
|
|
target = null;
|
|
return false;
|
|
}
|
|
|
|
public virtual void SetCurrentTarget(Transform target)
|
|
{
|
|
SetCurrentTarget(target, false);
|
|
}
|
|
public virtual void SetCurrentTarget(vAITarget target)
|
|
{
|
|
SetCurrentTarget(target, false);
|
|
}
|
|
public virtual void SetCurrentTarget(Transform target, bool overrideCanseTarget)
|
|
{
|
|
if (target == null) return;
|
|
changeTargetTime = _changeTargetDelay + Time.time;
|
|
currentTarget.InitTarget(target);
|
|
if (overrideCanseTarget)
|
|
{
|
|
currentTarget.isLost = false;
|
|
_targetInLineOfSight = true;
|
|
_hasPositionOfTheTarget = true;
|
|
}
|
|
updateFindTargetTime = 0f;
|
|
updatePathTime = 0f;
|
|
lastTargetPosition = target.position;
|
|
LookToTarget(target, 2);
|
|
}
|
|
public virtual void SetCurrentTarget(vAITarget target, bool overrideCanseTarget)
|
|
{
|
|
if (target.transform == null) return;
|
|
changeTargetTime = _changeTargetDelay + Time.time;
|
|
currentTarget = target;
|
|
if (overrideCanseTarget)
|
|
{
|
|
currentTarget.isLost = false;
|
|
_targetInLineOfSight = true;
|
|
_hasPositionOfTheTarget = true;
|
|
}
|
|
updateFindTargetTime = 0f;
|
|
updatePathTime = 0f;
|
|
lastTargetPosition = target.transform.position;
|
|
LookToTarget(target, 2);
|
|
}
|
|
|
|
public virtual void RemoveCurrentTarget()
|
|
{
|
|
currentTarget.ClearTarget();
|
|
}
|
|
|
|
public virtual void LookAround()
|
|
{
|
|
if (_headtrack) _headtrack.LookAround();
|
|
}
|
|
|
|
public virtual void LookTo(Vector3 point, float stayLookTime = 1, float offsetLookHeight = -1)
|
|
{
|
|
if (_headtrack) _headtrack.LookAtPoint(point, stayLookTime, offsetLookHeight);
|
|
}
|
|
|
|
public virtual void LookToTarget(Transform target, float stayLookTime = 1, float offsetLookHeight = -1)
|
|
{
|
|
if (_headtrack) _headtrack.LookAtTarget(target, stayLookTime, offsetLookHeight);
|
|
}
|
|
|
|
public virtual void SetSpeed(vAIMovementSpeed movementSpeed)
|
|
{
|
|
if (this.movementSpeed != movementSpeed)
|
|
{
|
|
if (movementSpeed == vAIMovementSpeed.Idle)
|
|
{
|
|
Stop();
|
|
|
|
}
|
|
base.movementSpeed = movementSpeed;
|
|
}
|
|
}
|
|
|
|
public virtual bool isInDestination
|
|
{
|
|
get
|
|
{
|
|
if (useNavMeshAgent && (remainingDistance <= stopingDistance || navMeshAgent.hasPath && remainingDistance > stopingDistance && desiredVelocity.magnitude < 0.1f)) return true;
|
|
return remainingDistance <= stopingDistance;
|
|
}
|
|
}
|
|
|
|
public virtual bool isMoving
|
|
{
|
|
get
|
|
{
|
|
return input.sqrMagnitude > 0.1f;
|
|
}
|
|
}
|
|
|
|
public virtual float remainingDistance
|
|
{
|
|
get
|
|
{
|
|
return navMeshAgent && navMeshAgent.enabled && useNavMeshAgent && isOnNavMesh ? navMeshAgent.remainingDistance : remainingDistanceWithoutAgent;
|
|
}
|
|
}
|
|
|
|
protected virtual float remainingDistanceWithoutAgent
|
|
{
|
|
get
|
|
{
|
|
return Vector3.Distance(transform.position, new Vector3(destination.x, transform.position.y, destination.z));
|
|
}
|
|
}
|
|
|
|
public virtual Collider selfCollider
|
|
{
|
|
get { return _capsuleCollider; }
|
|
}
|
|
|
|
public virtual bool isOnJumpLink
|
|
{
|
|
get
|
|
{
|
|
if (!useNavMeshAgent) return false;
|
|
if (navMeshAgent.isOnOffMeshLink && navMeshAgent.currentOffMeshLinkData.linkType == UnityEngine.AI.OffMeshLinkType.LinkTypeJumpAcross) return true;
|
|
var linkData = navMeshAgent.currentOffMeshLinkData.offMeshLink;
|
|
if (linkData != null)
|
|
{
|
|
if (linkData.area == UnityEngine.AI.NavMesh.GetAreaFromName("Jump"))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public virtual bool isOnNavMesh
|
|
{
|
|
get
|
|
{
|
|
if (!useNavMeshAgent) return false;
|
|
if (navMeshAgent.enabled) return navMeshAgent.isOnNavMesh;
|
|
|
|
if (UnityEngine.AI.NavMesh.SamplePosition(transform.position, out navMeshHit, _capsuleCollider.radius, navMeshAgent.areaMask))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public virtual void MoveTo(Vector3 newDestination, vAIMovementSpeed speed = vAIMovementSpeed.Walking)
|
|
{
|
|
if (isStrafing) updatePathTime = 0;
|
|
SetFreeLocomotion();
|
|
SetSpeed(speed);
|
|
var dir = newDestination - transform.position;
|
|
dir.y = 0;
|
|
this.destination = newDestination;
|
|
temporaryDirection = transform.forward;
|
|
|
|
temporaryDirectionTime = 0;
|
|
}
|
|
|
|
public virtual void StrafeMoveTo(Vector3 newDestination, Vector3 targetDirection, vAIMovementSpeed speed = vAIMovementSpeed.Walking)
|
|
{
|
|
if (useNavMeshAgent && navMeshAgent && navMeshAgent.isOnNavMesh && navMeshAgent.isStopped) navMeshAgent.isStopped = false;
|
|
SetStrafeLocomotion();
|
|
SetSpeed(speed);
|
|
destination = newDestination;
|
|
temporaryDirection = targetDirection;
|
|
temporaryDirectionTime = 2f;
|
|
}
|
|
|
|
public virtual void StrafeMoveTo(Vector3 newDestination, vAIMovementSpeed speed = vAIMovementSpeed.Walking)
|
|
{
|
|
if (useNavMeshAgent && navMeshAgent && navMeshAgent.isOnNavMesh && navMeshAgent.isStopped) navMeshAgent.isStopped = false;
|
|
SetStrafeLocomotion();
|
|
SetSpeed(speed);
|
|
destination = newDestination;
|
|
}
|
|
|
|
public virtual void RotateTo(Vector3 targetDirection)
|
|
{
|
|
|
|
targetDirection.y = 0;
|
|
if (Vector3.Angle(transform.forward, targetDirection) > 20)
|
|
{
|
|
temporaryDirection = targetDirection;
|
|
temporaryDirectionTime = 2f;
|
|
}
|
|
}
|
|
|
|
public virtual Vector3 targetDestination
|
|
{
|
|
get { return _destination; }
|
|
}
|
|
|
|
public virtual float stopingDistance { get { return stopingDistanceRelativeToSpeed + _stopingDistance; } set { _stopingDistance = value; } }
|
|
|
|
protected virtual float stopingDistanceRelativeToSpeed
|
|
{
|
|
get
|
|
{
|
|
return movementSpeed == vAIMovementSpeed.Idle ? 1 : movementSpeed == vAIMovementSpeed.Running ? _runningStopingDistance : movementSpeed == vAIMovementSpeed.Sprinting ? _sprintingStopingDistance : _walkingStopingDistance;
|
|
}
|
|
}
|
|
|
|
public virtual Vector3 selfStartPosition { get; set; }
|
|
|
|
public virtual vWaypointArea waypointArea
|
|
{
|
|
get
|
|
{
|
|
return _waypointArea;
|
|
}
|
|
set
|
|
{
|
|
if (value != null && value != _waypointArea)
|
|
{
|
|
var waypoints = value.GetValidPoints();
|
|
if (_randomStartingPoint)
|
|
_currentWaypoint = UnityEngine.Random.Range(0, waypoints.Count);
|
|
}
|
|
_waypointArea = value;
|
|
}
|
|
}
|
|
|
|
public virtual vWaypoint targetWaypoint { get; protected set; }
|
|
|
|
public virtual List<vWaypoint> visitedWaypoints { get; set; }
|
|
|
|
public virtual bool selfStartingPoint { get { return _selfStartingPoint; } protected set { _selfStartingPoint = value; } }
|
|
|
|
public virtual float changeWaypointDistance { get; protected set; }
|
|
|
|
public virtual bool customStartPoint
|
|
{
|
|
get
|
|
{
|
|
return !selfStartingPoint && _customStartingPoint != null;
|
|
}
|
|
}
|
|
|
|
public virtual Vector3 customStartPosition
|
|
{
|
|
get
|
|
{
|
|
return customStartPoint ? _customStartingPoint.position : transform.position;
|
|
}
|
|
}
|
|
public virtual void NextWayPoint()
|
|
{
|
|
targetWaypoint = GetWaypoint();
|
|
}
|
|
|
|
public override void TakeDamage(vDamage damage)
|
|
{
|
|
base.TakeDamage(damage);
|
|
|
|
if (damage.damageValue > 0)
|
|
{
|
|
//Check condition to add a new target
|
|
if (!currentTarget.transform || (currentTarget.transform && !currentTarget.isFixedTarget || (currentTarget.isFixedTarget && findOtherTarget)))
|
|
{
|
|
//Check if new target is in detections settings
|
|
if (damage.sender && IsInLayerMask(damage.sender.gameObject.layer, _detectLayer) && _detectTags.Contains(damage.sender.gameObject.tag))
|
|
{
|
|
SetCurrentTarget(damage.sender, false);
|
|
}
|
|
}
|
|
receivedDamage.UpdateDamage(damage);
|
|
|
|
updatePathTime = 0f;
|
|
}
|
|
}
|
|
|
|
public virtual void ForceUpdatePath(float timeInUpdate = 1f)
|
|
{
|
|
forceUpdatePathTime = timeInUpdate;
|
|
}
|
|
|
|
public virtual bool HasComponent<T>() where T : vIAIComponent
|
|
{
|
|
if (aiComponents == null) return false;
|
|
return aiComponents.ContainsKey(typeof(T));
|
|
}
|
|
|
|
public virtual T GetAIComponent<T>() where T : vIAIComponent
|
|
{
|
|
return aiComponents.ContainsKey(typeof(T)) ? (T)aiComponents[typeof(T)] : default(T);
|
|
}
|
|
|
|
protected List<Collider> triggers = new List<Collider>();
|
|
|
|
float checkTriggerFrequency;
|
|
|
|
protected override void OnTriggerEnter(Collider other)
|
|
{
|
|
base.OnTriggerEnter(other);
|
|
if (!triggers.Contains(other)) triggers.Add(other);
|
|
}
|
|
|
|
protected override void OnTriggerExit(Collider other)
|
|
{
|
|
if (triggers.Contains(other)) triggers.Remove(other);
|
|
}
|
|
|
|
protected override void OnTriggerStay(Collider other)
|
|
{
|
|
base.OnTriggerStay(other);
|
|
|
|
if (checkTriggerFrequency < Time.time)
|
|
{
|
|
triggers = triggers.FindAll(c => c != null);
|
|
checkTriggerFrequency = Time.time + 2f;
|
|
}
|
|
}
|
|
|
|
public bool IsInTriggerWithTag(string tag)
|
|
{
|
|
return triggers.Exists(c => c != null && c.gameObject.CompareTag(tag));
|
|
}
|
|
|
|
public bool IsInTriggerWithName(string name)
|
|
{
|
|
return triggers.Exists(c => c != null && c.gameObject.name.Equals(name));
|
|
}
|
|
|
|
public bool IsInTriggerWithTag(string tag, out Collider result)
|
|
{
|
|
var _c = triggers.Find(c => c != null && c.gameObject.CompareTag(tag));
|
|
result = _c;
|
|
return _c != null;
|
|
}
|
|
|
|
public bool IsInTriggerWithName(string name, out Collider result)
|
|
{
|
|
var _c = triggers.Find(c => c != null && c.gameObject.name.Equals(name));
|
|
result = _c;
|
|
return _c != null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|