//Update HP bar rotations
protected virtual void Navigate()
{
//FROM DEAD EARTH TUTORIAL
//**************************************************************************************
HasPath = navAgent.hasPath;
PathPending = navAgent.pathPending;
PathStale = navAgent.isPathStale;
PathStatus = navAgent.pathStatus;
Vector3 localDesiredVelocity = transform.InverseTransformVector(navAgent.desiredVelocity);
float angle = Mathf.Atan2(localDesiredVelocity.x, localDesiredVelocity.z) * Mathf.Rad2Deg;
smoothAngle = Mathf.MoveTowardsAngle(smoothAngle, angle, 80.0f * Time.deltaTime);
float speed = localDesiredVelocity.z;
animator.SetFloat(angleHash, smoothAngle);
animator.SetFloat(speedHash, speed, 0.1f, Time.deltaTime);
if (navAgent.desiredVelocity.sqrMagnitude > Mathf.Epsilon)
{
if (!MixedMode || (MixedMode && Mathf.Abs(angle) < 80f && animator.GetCurrentAnimatorStateInfo(0).IsName("Base Layer.Locomotion")))
{
Quaternion lookRotation = Quaternion.LookRotation(navAgent.desiredVelocity, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, 5.0f * Time.deltaTime);
}
}
if (PathStatus == NavMeshPathStatus.PathInvalid && !PathPending || PathStatus == NavMeshPathStatus.PathPartial && !PathPending)
{
navAgent.SetDestination(target);
}
}
public void Update()
{
pathStatus = navMeshAgent.pathStatus;
HandleRotation();
MoveAgent();
EnemyStateMachine();
}
// Update is called once per frame
void Update () {
if (agent.enabled) agent.SetDestination (targetPosition.position);
//destination = agent.destination; //For debugging with the Inspector
destination = agent.path.corners[1];
status = agent.path.status;
data = agent.nextOffMeshLinkData;
if (agent.isOnOffMeshLink && linkTime == 0) {
linkTime = Time.time;
}
if (controller.controllable) {
if (Vector3.Distance (targetPosition.position, gameObject.transform.position) > agent.stoppingDistance) {
//controller.xin = (targetPosition.position.x - gameObject.transform.position.x);
//controller.zin = (targetPosition.position.z - gameObject.transform.position.z);
controller.xin = Mathf.Max (Mathf.Min ((agent.path.corners [1].x - gameObject.transform.position.x), 1f), -1f);
controller.zin = Mathf.Max (Mathf.Min ((agent.path.corners [1].z - gameObject.transform.position.z), 1f), -1f);
} else
controller.xin = controller.zin = 0;
if (agent.path.corners [1].y - gameObject.transform.position.y > 0.5) {
agent.enabled = false;
controller.jumpin = 1;
} else if (controller.GroundCheck ()) {
agent.enabled = true;
controller.jumpin = 0;
}
if (Time.time - linkTime >= .5 && linkTime != 0) {
agent.enabled = false;
linkTime = 0;
}
} else {
controller.xin = controller.zin = 0;
}
var nav = GetComponent<NavMeshAgent>(); //Debug Path Line
if( nav == null || nav.path == null )
return;
var line = this.GetComponent<LineRenderer>();
if( line == null )
{
line = this.gameObject.AddComponent<LineRenderer>();
line.material = new Material( Shader.Find( "Sprites/Default" ) ) { color = Color.yellow };
line.SetWidth( 0.5f, 0.5f );
line.SetColors( Color.yellow, Color.yellow );
}
var path = nav.path;
line.SetVertexCount( path.corners.Length );
for( int i = 0; i < path.corners.Length; i++ )
{
line.SetPosition( i, path.corners[ i ] );
}
}
// Update is called once per frame
void Update()
{
if (DestinationPicker.newDestination)
{
state = State.WALKING;
// Debug.Log("dest ? " + DestinationPicker.newDestination + " " + DestinationPicker.destination);
navMeshAgent.destination = DestinationPicker.destination;
}
if (state == State.WALKING)
{
NavMeshPathStatus status = navMeshAgent.pathStatus;
float dist = navMeshAgent.remainingDistance;
if (!navMeshAgent.pathPending &&
status == NavMeshPathStatus.PathComplete &&
dist <= navMeshAgent.stoppingDistance * 2)
{
state = State.READY;
DestinationPicker.newDestination = false;
if (PointNClickable.clicked != null)
{
PointNClickable.clicked.PreClick();
AudioSource sfx = PointNClickable.clicked.Interact();
if (sfx != null)
{
sfx.transform.position = PointNClickable.clicked.transform.position;
sfx.Play();
}
PointNClickable.clicked = null;
}
}
}
}
protected virtual void Update()
{
status = agent.pathStatus;
// switch(currentState)
// {
// case UnitState.Standby: StandbyState(); break;
// case UnitState.Move: MoveState(); break;
// case UnitState.Chase: ChaseState(); break;
// case UnitState.Attack: AttackState(); break;
// case UnitState.Dead: DeadState(); break;
// }
switch (currentState)
{
case UnitState.Standby: StandbyState(); break;
case UnitState.Hold: HoldState(); break;
case UnitState.Move: MoveState(); break;
case UnitState.Chase: ChaseState(); break;
case UnitState.Attack: AttackState(); break;
case UnitState.Dead: DeadState(); break;
case UnitState.None: break;
}
}
// ---------------------------------------------------------
// Name : Update
// Desc : Called each frame by Unity
// ---------------------------------------------------------
void Update()
{
// Copy NavMeshAgents state into inspector visible variables
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
// If agent is on an offmesh link then perform a jump
if (_navAgent.isOnOffMeshLink)
{
StartCoroutine(Jump(1.0f));
return;
}
// If we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if path is stale regenerate path
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid /*|| PathStatus==NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
// Update is called once per frame
void Update()
{
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
float stopDistance = _navAgent.stoppingDistance;
bool destinationReached = _navAgent.remainingDistance <= stopDistance; // Distance to destination is zero. Needs new path
if (_navAgent.isOnOffMeshLink)
{
StartCoroutine(Jump(1.0f));
return;
}
if ((destinationReached && !PathPending) || (PathStatus == NavMeshPathStatus.PathInvalid))
{
SetNextDestination(true);
}
else if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
// Update is called once per frame
void Update()
{
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
if (_navAgent.isOnOffMeshLink)
{
StartCoroutine(Jump(1.0f));
return;
}
// If we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if path is stale regenerate path
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid)
{
SetNextDestination(true);
}
else
// regenerate destination if path is stale
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
// ---------------------------------------------------------
// Name : Update
// Desc : Called each frame by Unity
// ---------------------------------------------------------
void Update()
{
int turnOnSpot;
// Copy NavMeshAgents state into inspector visible variables
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
// Perform corss product on forard vector and desired velocity vector. If both inputs are Unit length
// the resulting vector's magnitude will be Sin(theta) where theta is the angle between the vectors.
Vector3 cross = Vector3.Cross(transform.forward, _navAgent.desiredVelocity.normalized);
// If y component is negative it is a negative rotation else a positive rotation
float horizontal = (cross.y < 0) ? -cross.magnitude : cross.magnitude;
// Scale into the 2.32 range for our animator
horizontal = Mathf.Clamp(horizontal * 2.32f, -2.32f, 2.32f);
// If we have slowed down and the angle between forward vector and desired vector is greater than 10 degrees
if (_navAgent.desiredVelocity.magnitude < 1.0f && Vector3.Angle(transform.forward, _navAgent.steeringTarget - transform.position) > 10.0f)
{
// Stop the nav agent (approx) and assign either -1 or +1 to turnOnSpot based on sign on horizontal
_navAgent.speed = 0.1f;
turnOnSpot = (int)Mathf.Sign(horizontal);
}
else
{
// Otherwise it is a small angle so set Agent's speed to normal and reset turnOnSpot
_navAgent.speed = _originalMaxSpeed;
turnOnSpot = 0;
}
// Send the data calculated above into the animator parameters
_animator.SetFloat("Horizontal", horizontal, 0.1f, Time.deltaTime);
_animator.SetFloat("Vertical", _navAgent.desiredVelocity.magnitude, 0.1f, Time.deltaTime);
_animator.SetInteger("TurnOnSpot", turnOnSpot);
// If agent is on an offmesh link then perform a jump
/*if (_navAgent.isOnOffMeshLink)
* {
* StartCoroutine( Jump( 1.0f) );
* return;
* }*/
// If we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if path is stale regenerate path
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid /*|| PathStatus==NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
static int IntToEnum(IntPtr L)
{
int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
NavMeshPathStatus o = (NavMeshPathStatus)arg0;
LuaScriptMgr.Push(L, o);
return(1);
}
private void Update()
{
NavMeshPathStatus status = agente.pathStatus;
//tDistancia.text = "Distancia a la meta: " + agente.remainingDistance;
tDistancia.text = "Distancia a la meta: " + Vector3.Distance(agente.pathEndPosition, transform.position);
//Debug.Log("Estatus ruta: " +status.ToString());
agente.SetDestination(meta.position);
}
public void In(
[FriendlyName("Agent", "The NavMeshAgent agent.")] NavMeshAgent agent,
[FriendlyName("Destination", "The Destination to navigate towards.")] out Vector3 destination,
[FriendlyName("Stopping Distance", "Stop within this distance from the target position.")] out float stoppingDistance,
[FriendlyName("Velocity", "The current velocity of the NavMeshAgent component.")] out Vector3 velocity,
[FriendlyName("Next Position", "The next position on the path.")] out Vector3 nextPosition,
[FriendlyName("Steering Target", "The current steering target - usually the next corner or end point of the current path. (Read Only)")] out Vector3 steeringTarget,
[FriendlyName("Desired Velocity", "The desired velocity of the agent including any potential contribution from avoidance. (Read Only)")] out Vector3 desiredVelocity,
[FriendlyName("Remaining Distance", "Remaining distance along the current path - or infinity when not known. (Read Only)")] out float remainingDistance,
[FriendlyName("Base Offset", "The relative vertical displacement of the owning GameObject.")] out float baseOffset,
[FriendlyName("Is On Off Mesh Link", "Is agent currently positioned on an OffMeshLink. (Read Only)")] out bool isOnOffMeshLink,
[FriendlyName("Current Off Mesh Link Data", "The current OffMeshLinkData.")] out OffMeshLinkData currentOffMeshLinkData,
[FriendlyName("Auto Traverse Off Mesh Link", "Automate movement onto and off of OffMeshLinks.")] out bool autoTraverseOffMeshLink,
[FriendlyName("Auto Repath", "Attempt to acquire a new path if the existing path becomes invalid or if the agent reaches the end of a partial and stale path.")] out bool autoRepath,
[FriendlyName("Has Path", "Does the agent currently have a path. (Read Only)")] out bool hasPath,
[FriendlyName("Path Pending", "A path is being computed, but not yet ready. (Read Only)")] out bool pathPending,
[FriendlyName("Is Path Stale", "Is the current path stale. (Read Only) \n\nWhen true, the path may no longer be valid or optimal. This flag will be set if: there are any changes to the walkableMask, if any OffMeshLink is enabled or disabled, or if the costs for the NavMeshLayers have been changed.")] out bool isPathStale,
[FriendlyName("Path Status", "Query the state of the current path.")] out NavMeshPathStatus pathStatus,
[FriendlyName("Path", "Set or get a copy of the current path.")] out NavMeshPath path,
[FriendlyName("Walkable Mask", "Specifies which NavMesh layers are passable (bitfield). Changing walkableMask will make the path stale (see isPathStale)")] out int walkableMask,
[FriendlyName("Speed", "Maximum movement speed.")] out float speed,
[FriendlyName("Angular Speed", "Maximum rotation speed in (deg/s).")] out float angularSpeed,
[FriendlyName("Acceleration", "Maximum acceleration.")] out float acceleration,
[FriendlyName("Update Position", "Should the agent update the transform position.")] out bool updatePosition,
[FriendlyName("Update Rotation", "Should the agent update the transform orientation.")] out bool updateRotation,
[FriendlyName("Radius", "Agent avoidance radius.")] out float radius,
[FriendlyName("Height", "Agent height.")] out float height,
[FriendlyName("Obstacle Avoidance Type", "The level of quality of avoidance.")] out ObstacleAvoidanceType obstacleAvoidanceType
)
{
destination = agent.destination;
stoppingDistance = agent.stoppingDistance;
velocity = agent.velocity;
nextPosition = agent.nextPosition;
steeringTarget = agent.steeringTarget;
desiredVelocity = agent.desiredVelocity;
remainingDistance = agent.remainingDistance;
baseOffset = agent.baseOffset;
isOnOffMeshLink = agent.isOnOffMeshLink;
currentOffMeshLinkData = agent.currentOffMeshLinkData;
autoTraverseOffMeshLink = agent.autoTraverseOffMeshLink;
autoRepath = agent.autoRepath;
hasPath = agent.hasPath;
pathPending = agent.pathPending;
isPathStale = agent.isPathStale;
pathStatus = agent.pathStatus;
path = agent.path;
walkableMask = agent.walkableMask;
speed = agent.speed;
angularSpeed = agent.angularSpeed;
acceleration = agent.acceleration;
updatePosition = agent.updatePosition;
updateRotation = agent.updateRotation;
radius = agent.radius;
height = agent.height;
obstacleAvoidanceType = agent.obstacleAvoidanceType;
}
void OnDestinationArrive()
{
if (onDestinationArrive != null)
{
onDestinationArrive();
}
// endEventPlayerPlay.EndPlay("end nav");
// endEventPlayerPlay = null;
pathStatus = NavMeshPathStatus.PathInvalid;
}
void FindRandomPointPatrol()
{
Vector3 randomPosition = Random.insideUnitSphere * wanderArea;
randomPosition.y = transform.position.y;
agent.SetDestination(randomPosition);
navMeshPathStatus = agent.pathStatus;
pathPending = agent.pathPending;
}
// ---------------------------------------------------------
// Name : Update
// Desc : Called each frame by Unity
// ---------------------------------------------------------
void Update()
{
// Copy NavMeshAgents state into inspector visible variables
hasPath = agent.hasPath;
pathPending = agent.pathPending;
pathStale = agent.isPathStale;
pathStatus = agent.pathStatus;
// Transform agents desired velocity into local space
Vector3 localDesiredVelocity = transform.InverseTransformVector(agent.desiredVelocity);
// Get angle in degrees we need to turn to reach the desired velocity direction
float angle = Mathf.Atan2(localDesiredVelocity.x, localDesiredVelocity.z) * Mathf.Rad2Deg;
// Smoothly interpolate towards the new angle
smoothangle = Mathf.MoveTowardsAngle(smoothangle, angle, 80.0f * Time.deltaTime);
// Speed is simply the amount of desired velocity projected onto our own forward vector
float speed = localDesiredVelocity.z;
// Set animator parameters
animator.SetFloat("Angle", smoothangle);
animator.SetFloat("Speed", speed, 0.1f, Time.deltaTime);
if (agent.desiredVelocity.sqrMagnitude > Mathf.Epsilon)
{
if (!mixedMode ||
(mixedMode && Mathf.Abs(angle) < 80.0f && animator.GetCurrentAnimatorStateInfo(0).IsName("Base Layer.Locomotion")))
{
Quaternion lookRotation = Quaternion.LookRotation(agent.desiredVelocity, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, 5.0f * Time.deltaTime);
}
}
// If agent is on an offmesh link then perform a jump
/*if (_navAgent.isOnOffMeshLink)
* {
* StartCoroutine( Jump( 1.0f) );
* return;
* }*/
// If we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if path is stale regenerate path
if ((agent.remainingDistance <= agent.stoppingDistance && !pathPending) || pathStatus == NavMeshPathStatus.PathInvalid /*|| PathStatus==NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else
if (agent.isPathStale)
{
SetNextDestination(false);
}
}
private void Update()
{
#if UNITY_EDITOR
DebugRenderPath();
#endif
_pathStatus = _agent.pathStatus;
_pathPending = _agent.pathPending;
_hasPath = _agent.hasPath;
_isPathStale = _agent.isPathStale;
}
public void DisableAgent()
{
if (sender != null)
{
pathStatus = NavMeshPathStatus.PathInvalid;
ServerSend.ActivatePlayerMovement(sender.playerCharacter.id, sender.playerInstance.transform.position);
player = null;
sender = null;
agent.enabled = false;
}
}
public void In(
[FriendlyName("Agent", "The NavMeshAgent you wish to get the current path from.")] NavMeshAgent agent,
[FriendlyName("Path", "The agent's current NavMeshPath.")] out NavMeshPath path,
[FriendlyName("Corners", "Corner points of path. (Read Only)"), SocketState(false, false)] out Vector3[] corners,
[FriendlyName("Status", "Status of the path. (Read Only)"), SocketState(false, false)] out NavMeshPathStatus status
)
{
path = agent.path;
corners = path.corners;
status = path.status;
}
void Update()
{
int turnOnSpot;
// Rendo visibili queste variabili nell'inspector per vedere come si
// comporta lo stato del NavMeshAgent
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
// Eseguo il prodotto matriciale tra i vettori forward e speed (spazio tempo)
// Se entrambi i valori dei due input corrispondono la magnitude del vettore risultante
// sarà Sin(theta) dove Theta è l'angolo tra i vettori
Vector3 cross = Vector3.Cross(transform.forward, _navAgent.desiredVelocity.normalized);
// Se Y è negativo allora la anche rotazione è negativa
float horizontal = (cross.y < 0)? -cross.magnitude : cross.magnitude;
horizontal = Mathf.Clamp(horizontal * 2.32f, -2.32f, 2.32f);
if (_navAgent.desiredVelocity.magnitude < 1.0f && Vector3.Angle(transform.forward, _navAgent.steeringTarget - transform.position) > 10.0f)
{
// Ferma il navAgent e assegna -1 o +1 a turnOnSpot in base a horizontal
_navAgent.speed = 0.1f;
turnOnSpot = (int)Mathf.Sign(horizontal);
}
else
{
// Altrimenti l'angolo è ridotto e omposto la velocità del navAgent
// su Normal e resetto turnOnSpot
_navAgent.speed = _originalMaxSpeed;
turnOnSpot = 0;
}
// Setto i dati che sono stati calcolati nei parametri dell'animator
_animator.SetFloat("Horizontal", horizontal, 0.1f, Time.deltaTime);
_animator.SetFloat("Vertical", _navAgent.desiredVelocity.magnitude, 0.1f, Time.deltaTime);
_animator.SetInteger("TurnOnSpot", turnOnSpot);
// Se non c'è un Path e PathPending è false allora imposto il Waypoint successivo come target
// altrimenti se il Path è vecchio rigenero tutto il percorso
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == UnityEngine.AI.NavMeshPathStatus.PathInvalid /*|| PathStatus==NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
void Update()
{
status = agent.pathStatus;
switch (currentState)
{
case UnitState.Idle: IdleState(); break;
case UnitState.Move: MoveState(); break;
case UnitState.Chase: ChaseState(); break;
case UnitState.Attack: AttackState(); break;
}
}
// ---------------------------------------------------------
// Name : Update
// Desc : Called each frame by Unity
// ---------------------------------------------------------
void Update()
{
int turnOnSpot;
// Copy NavMeshAgents state into inspector visible variables
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
Vector3 cross = Vector3.Cross(transform.forward, _navAgent.desiredVelocity.normalized);
float horizontal = (cross.y < 0) ? -cross.magnitude : cross.magnitude;
horizontal = Mathf.Clamp(horizontal * 2.32f, -2.32f, 2.32f);
if (_navAgent.desiredVelocity.magnitude < 1.0f && (Vector3.Angle(transform.forward, _navAgent.desiredVelocity) > 10.0f || !HasPath))
{
_navAgent.speed = 0.1f;
turnOnSpot = (int)Mathf.Sign(horizontal);
}
else
{
_navAgent.speed = _originalMaxSpeed;
turnOnSpot = 0;
}
_animator.SetFloat("Horizontal", horizontal, 0.1f, Time.deltaTime);
_animator.SetFloat("Vertical", _navAgent.desiredVelocity.magnitude, 0.1f, Time.deltaTime);
_animator.SetInteger("TurnOnSpot", turnOnSpot);
// If agent is on an offmesh link then perform a jump
/*if (_navAgent.isOnOffMeshLink)
* {
* StartCoroutine(Jump(1.0f));
* return;
* }*/
// If we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if path is stale regenerate path
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid /*|| PathStatus==NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
void WaitForValidPath()
{
Quaternion lookAtPlayer = Quaternion.LookRotation(player.transform.position - transform.position, Vector3.up);
transform.rotation = Quaternion.Euler(0, lookAtPlayer.eulerAngles.y, 0);
// update path to player
NMAgent.SetDestination(player.transform.position);
pathStatus = NMAgent.pathStatus;
gotPath = NMAgent.hasPath;
pathPending = NMAgent.pathPending;
// check if path is valid
if (NMAgent.pathStatus == NavMeshPathStatus.PathComplete)
{
// if yes, figure out if enemy should be attacking or chasing
if (Vector3.Distance(player.transform.position, transform.position) > attackDistance)
{
currentState = State.ATTACKING;
attackTimer = 0;
NMAgent.isStopped = true;
animator.SetBool("isIdle", false);
animator.SetBool("isAttacking", true);
}
else
{
currentState = State.CHASING;
attackTimer = 0;
NMAgent.speed = chaseSpeed;
NMAgent.isStopped = false;
animator.SetBool("isIdle", false);
animator.SetBool("isChasing", true);
}
}
else if (pathPending == false)
{
/*Note: For some reason when the player enters an unreachable area, then becomes reachable again,
* the path will not be recalculated until the player crosses into a second reachable pathing node.
* This helps a little bit, I think. I re-baked the map after so it ended up not really mattering anyway.*/
NavMeshPath path = new NavMeshPath();
if (NMAgent.CalculatePath(player.transform.position, path))
{
NMAgent.SetPath(path);
}
}
}
// ---------------------------------------------------------
// Name : Update
// Desc : Called each frame by Unity
// ---------------------------------------------------------
void Update()
{
// Copy NavMeshAgents state into inspector visible variables
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
Vector3 localDesiredVelocity = transform.InverseTransformVector(_navAgent.desiredVelocity);
float angle = Mathf.Atan2(localDesiredVelocity.x, localDesiredVelocity.z) * Mathf.Rad2Deg;
_smoothAngle = Mathf.MoveTowardsAngle(_smoothAngle, angle, 80.0f * Time.deltaTime);
float speed = localDesiredVelocity.z;
_animator.SetFloat("Angle", _smoothAngle);
_animator.SetFloat("Speed", speed, 0.1f, Time.deltaTime);
if (_navAgent.desiredVelocity.sqrMagnitude > Mathf.Epsilon)
{
if (!MixedMode ||
(MixedMode && Mathf.Abs(angle) < 80.0f && _animator.GetCurrentAnimatorStateInfo(0).IsName("Base Layer.Locomotion")))
{
Quaternion lookRotation = Quaternion.LookRotation(_navAgent.desiredVelocity, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, 5.0f * Time.deltaTime);
}
}
// If agent is on an offmesh link then perform a jump
/*if (_navAgent.isOnOffMeshLink)
* {
* StartCoroutine(Jump(1.0f));
* return;
* }*/
// If we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if path is stale regenerate path
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid /*|| PathStatus==NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
public virtual TaskStatus OnUpdate()
{
if (Object.op_Equality((Object)this._partner, (Object)null))
{
return((TaskStatus)1);
}
if (!Singleton <Resources> .IsInstance())
{
return((TaskStatus)3);
}
AgentProfile agentProfile = Singleton <Resources> .Instance.AgentProfile;
LocomotionProfile locomotionProfile = Singleton <Resources> .Instance.LocomotionProfile;
Vector3 destination = this.DesiredPosition(this._partner);
if ((double)agentProfile.RestDistance <= (double)Vector3.Distance(destination, this._merchant.Position))
{
this.SetDestination(destination);
this._moved = true;
}
else
{
NavMeshPathStatus pathStatus = this._navMeshAgent.get_pathStatus();
if (pathStatus == 1 || pathStatus == 2)
{
if ((double)Vector3.Distance(this._merchant.Position, this._partner.Position) < (double)agentProfile.RestDistance)
{
this.Stop();
if (this._merchant.IsRunning)
{
this._merchant.IsRunning = false;
}
}
}
else if (!this._navMeshAgent.get_pathPending())
{
if ((double)this._navMeshAgent.get_remainingDistance() < (double)agentProfile.RestDistance && this._merchant.IsRunning)
{
this._merchant.IsRunning = false;
}
if (this._moved && (double)this._navMeshAgent.get_remainingDistance() < (double)this._navMeshAgent.get_stoppingDistance())
{
this.Stop();
this._moved = false;
}
}
}
return((TaskStatus)3);
}
// Update is called once per frame
private void Update()
{
NavMeshPathStatus pathStatus = _agent.pathStatus;
// If current path is unable to be complete, get a new one
if (pathStatus != NavMeshPathStatus.PathComplete)
{
GetNewPath();
}
// If walker has reached destination, get a new path
if (Mathf.RoundToInt(_agent.remainingDistance) == 0)
{
GetNewPath();
}
}
private void Update()
{
hasPath = agent.hasPath;
pathPending = agent.pathPending;
pathStale = agent.isPathStale;
pathStatus = agent.pathStatus;
if ((agent.remainingDistance <= agent.stoppingDistance && !pathPending) || pathStatus == NavMeshPathStatus.PathInvalid)
{
SetNextDestination(true);
}
else if (agent.isPathStale)
{
SetNextDestination(false);
}
}
void Update()
{
// Rendo visibili queste variabili nell'inspector per vedere come si
// comporta lo stato del NavMeshAgent
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
// Converto la l'agent speed in local space
Vector3 localDesiredVelocity = transform.InverseTransformVector(_navAgent.desiredVelocity);
// Ottengo l'angolo in gradi per quanto devo girare per raggiungere la DesiredVelocity
float angle = Mathf.Atan2(localDesiredVelocity.x, localDesiredVelocity.z) * Mathf.Rad2Deg;
_smoothAngle = Mathf.MoveTowardsAngle(_smoothAngle, angle, 80.0f * Time.deltaTime);
// La Speed è la desiredVelocity proiettata dul nostro Forward Vector
float speed = localDesiredVelocity.z;
// Setto i parametri dell'animator
_animator.SetFloat("Angle", _smoothAngle);
_animator.SetFloat("Speed", speed, 0.1f, Time.deltaTime);
if (_navAgent.desiredVelocity.sqrMagnitude > Mathf.Epsilon)
{
if (!MixedMode ||
(MixedMode && Mathf.Abs(angle) < 80.0f && _animator.GetCurrentAnimatorStateInfo(0).IsName("Base Layer.Locomotion")))
{
Quaternion lookRotation = Quaternion.LookRotation(_navAgent.desiredVelocity, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, 5.0f * Time.deltaTime);
}
}
// Se non c'è un Path e PathPending è false allora imposto il Waypoint successivo come target
// altrimenti se il Path è vecchio rigenero tutto il percorso
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid)
{
SetNextDestination(true);
}
else
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
// Update is called once per frame
void Update()
{
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
if (_navAgent.isOnOffMeshLink)
{
if (_navAgent.isOnOffMeshLink)
{
StartCoroutine(Jump(1.0f));
return;
}
}
// if we don't have a path and one isn't pending then set the next
// waypoint as the target, otherwise if the path is stale regenerate path
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) || PathStatus == NavMeshPathStatus.PathInvalid /*|| PathStatus == NavMeshPathStatus.PathPartial*/)
{
SetNextDestination(true);
}
else
if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
IEnumerator Jump(float duration)
{
OffMeshLinkData data = _navAgent.currentOffMeshLinkData;
Vector3 startPos = _navAgent.transform.position;
Vector3 endPos = data.endPos + (_navAgent.baseOffset * Vector3.up);
float time = 0.0f;
while (time < duration)
{
float t = time / duration;
_navAgent.transform.position = Vector3.Lerp(startPos, endPos, t) + (JumpCurve.Evaluate(t) * Vector3.up);
time += Time.deltaTime;
yield return(null);
}
_navAgent.CompleteOffMeshLink();
}
}
// Update is called once per frame
void Update()
{
//* keep all of the agents navigation information current
HasPath = _navAgent.hasPath;
PathPending = _navAgent.pathPending;
PathStale = _navAgent.isPathStale;
PathStatus = _navAgent.pathStatus;
//set up OffMeshLink
if (_navAgent.isOnOffMeshLink)
{
if (_navAgent.isOnOffMeshLink)
{
StartCoroutine(Jump(1.0f));
return;
}
}
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !PathPending) ||
PathStatus == NavMeshPathStatus.PathInvalid)
{
SetNextDestination(true);
}
else if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
IEnumerator Jump(float duration)
{
OffMeshLinkData data = _navAgent.currentOffMeshLinkData;
Vector3 startPos = _navAgent.transform.position;
Vector3 endPos = data.endPos + (_navAgent.baseOffset * Vector3.up);
float time = 0.0f;
while (time < duration)
{
float t = time / duration;
_navAgent.transform.position = Vector3.Lerp(startPos, endPos, t) + (JumpCurve.Evaluate(t) * Vector3.up);
time += Time.deltaTime;
yield return(null);
}
_navAgent.CompleteOffMeshLink();
}
}
// Update is called once per frame
void Update()
{
int turnOnSpot;
hasPath = _navAgent.hasPath;
pathPending = _navAgent.pathPending;
pathStale = _navAgent.isPathStale;
pathStatus = _navAgent.pathStatus;
Vector3 cross = Vector3.Cross(transform.forward, _navAgent.desiredVelocity.normalized);
float horizontal = (cross.y < 0) ? -cross.magnitude : cross.magnitude; // figuring out if its a left or right turn
horizontal = Mathf.Clamp(horizontal * 2.32f, -2.32F, 2.32f);
if (_navAgent.desiredVelocity.magnitude < 0.75f && Vector3.Angle(transform.forward, _navAgent.desiredVelocity) > 10.0f)
{
_navAgent.speed = 0.1f;
turnOnSpot = (int)Mathf.Sign(horizontal);
}
else
{
_navAgent.speed = _originalMaxSpeed;
turnOnSpot = 0;
}
_animator.SetFloat("horizontal", horizontal, 0.1f, Time.deltaTime);
_animator.SetFloat("vertical", _navAgent.desiredVelocity.magnitude, 0.1f, Time.deltaTime);
_animator.SetInteger("turnOnSpot", turnOnSpot);
//if (_navAgent.isOnOffMeshLink)
//{
// StartCoroutine(Jump(1.0f));
// return;
//}
if ((_navAgent.remainingDistance <= _navAgent.stoppingDistance && !pathPending) || (pathStatus == NavMeshPathStatus.PathInvalid))
{
SetNextDestination(true);
}
else if (_navAgent.isPathStale)
{
SetNextDestination(false);
}
}
void Update()
{
int turnOnSpot = 0;
HasPath = navAgent.hasPath;
PathPending = navAgent.pathPending;
PathStale = navAgent.isPathStale;
PathStatus = navAgent.pathStatus;
Vector3 cross = Vector3.Cross(transform.forward, navAgent.desiredVelocity.normalized);
float horizontal = cross.y < 0 ? -cross.magnitude : cross.magnitude;
horizontal = Mathf.Clamp(horizontal * 2.32f, -2.32f, 2.32f);
if (navAgent.velocity.magnitude < 1.0f && Vector3.Angle(transform.forward, navAgent.desiredVelocity) > 10.0f)
{
navAgent.speed = 0.1f;
turnOnSpot = (int)Mathf.Sign(horizontal);
}
else
{
navAgent.speed = originalMaxSpeed;
turnOnSpot = 0;
}
animator.SetFloat("Horizontal", horizontal, 0.1f, Time.deltaTime);
animator.SetFloat("Vertical", navAgent.desiredVelocity.magnitude, 0.1f, Time.deltaTime);
animator.SetInteger("TurnOnSpot", turnOnSpot);
/*
* if (navAgent.isOnOffMeshLink) {
* StartCoroutine(Jump(1.0f, navAgent.destination, CurrentIndex));
* return;
* }
*/
if ((navAgent.remainingDistance <= navAgent.stoppingDistance && !PathPending && !OnOffMeshLink) || PathStatus == NavMeshPathStatus.PathInvalid)
{
SetNextDestination(true);
}
else if (PathStale)
{
SetNextDestination(false);
}
}
public static void CalculateNavigationMeshPath(Vector3 startPosition, Vector3 goalPosition, int passableMask)
{
ClearNavigationMeshPath ();
switch (navigationMeshChoice)
{
default:
case NavigationMeshChoice.USE_UNITY :
NavMeshPath unityPath = new NavMeshPath();
NavMesh.CalculatePath(startPosition,goalPosition, passableMask,unityPath);
pathStatus = unityPath.status;
if (pathStatus == NavMeshPathStatus.PathInvalid)
{
numberOfNodes = 0;
}
else
{
if ( unityPath.corners.Length >= maxNumberOfNodes)
{
Debug.LogWarning("Navigation mesh path greater than maximum number of nodes");
numberOfNodes = maxNumberOfNodes;
pathStatus = NavMeshPathStatus.PathPartial;
}
else
{
numberOfNodes = unityPath.corners.Length;
}
for(int i =0; i < numberOfNodes; i++)
{
// MAKING SURE LAST WAYPOINT IS THE GOAL
if ( i == numberOfNodes - 1)
path[i] = goalPosition;
else
path[i] = unityPath.corners[i];
// computing path cost
if (i==0)
pathCost[i] = 0.0f;
else
{
// assuming that all off mesh links will override cost
if (CentralizedManager.IsOffMeshLink(path[i]))
pathCost[i] = CentralizedManager.GetOffMeshLinkInformation(path[i]).offMeshLink.costOverride;
else
pathCost[i] = Vector3.Distance(path[i],path[i-1]);
}
totalPathCost += pathCost[i];
}
}
break;
case NavigationMeshChoice.USE_RECAST:
if (recastSteeringManager == null)
recastSteeringManager = GameObject.Find("ADAPTPrefab").GetComponentInChildren<SteeringManager>();
numberOfNodes = recastSteeringManager.FindPath(startPosition,goalPosition,path,maxNumberOfNodes);
if( numberOfNodes > 0)
path[numberOfNodes-1] = goalPosition;
// computing path cost
for (int i=1; i < numberOfNodes; i++)
{
// TODO : incorporate number of obstacles from centralized manager here
pathCost[i] = Vector3.Distance(path[i],path[i-1]);
totalPathCost += pathCost[i];
}
if (numberOfNodes == 0)
pathStatus = NavMeshPathStatus.PathInvalid;
else if ( numberOfNodes == maxNumberOfNodes)
pathStatus = NavMeshPathStatus.PathPartial;
else
pathStatus = NavMeshPathStatus.PathComplete;
break;
}
}
public static void ClearNavigationMeshPath()
{
numberOfNodes = 0;
pathStatus = NavMeshPathStatus.PathInvalid;
totalPathCost = 0.0f;
}
