Class RichAI Extends AIBase, IAstarAI

float acceleration = 5

Max acceleration of the agent.

In world units per second per second.

bool approachingPartEndpoint

True if approaching the last waypoint in the current part of the path.

Path parts are separated by off-mesh links.

bool approachingPathEndpoint

True if approaching the last waypoint of all parts in the current path.

Path parts are separated by off-mesh links.

Vector3 endOfPath

End point of path the agent is currently following.

If the agent has no path (or it might not be calculated yet), this will return the destination instead. If the agent has no destination it will return the agent's current position.

The end of the path is usually identical or very close to the destination, but it may differ if the path for example was blocked by a wall so that the agent couldn't get any closer.

This is only updated when the path is recalculated.

bool funnelSimplification = false

Use funnel simplification.

On tiled navmesh maps, but sometimes on normal ones as well, it can be good to simplify the funnel as a post-processing step to make the paths straighter.

This has a moderate performance impact during frames when a path calculation is completed.

The RichAI script uses its own internal funnel algorithm, so you never need to attach the FunnelModifier component.

bool hasPath

True if this agent currently has a path that it follows.

System.Func<RichSpecial, IEnumerator> onTraverseOffMeshLink

Called when the agent starts to traverse an off-mesh link.

Register to this callback to handle off-mesh links in a custom way.

If this event is set to null then the agent will fall back to traversing off-mesh links using a very simple linear interpolation.

void OnEnable () {
ai = GetComponent<RichAI>();
if (ai != null) ai.onTraverseOffMeshLink += TraverseOffMeshLink;
}

void OnDisable () {
if (ai != null) ai.onTraverseOffMeshLink -= TraverseOffMeshLink;
}

IEnumerator TraverseOffMeshLink (RichSpecial link) {
// Traverse the link over 1 second
float startTime = Time.time;

while (Time.time < startTime + 1) {
transform.position = Vector3.Lerp(link.first.position, link.second.position, Time.time - startTime);
yield return null;
}
transform.position = link.second.position;
}


bool pathPending

True if a path is currently being calculated.

bool preventMovingBackwards = false

Prevent the velocity from being too far away from the forward direction of the character.

If the character is ordered to move in the opposite direction from where it is facing then enabling this will cause it to make a small loop instead of turning on the spot.

This setting only has an effect if slowWhenNotFacingTarget is enabled.

bool reachedDestination

True if the ai has reached the destination.

This is a best effort calculation to see if the destination has been reached. For the AIPath/RichAI scripts, this is when the character is within AIPath.endReachedDistance world units from the destination. For the AILerp script it is when the character is at the destination (±a very small margin).

This value will be updated immediately when the destination is changed (in contrast to reachedEndOfPath), however since path requests are asynchronous it will use an approximation until it sees the real path result. What this property does is to check the distance to the end of the current path, and add to that the distance from the end of the path to the destination (i.e. is assumes it is possible to move in a straight line between the end of the current path to the destination) and then checks if that total distance is less than AIPath.endReachedDistance. This property is therefore only a best effort, but it will work well for almost all use cases.

Furthermore it will not report that the destination is reached if the destination is above the head of the character or more than half the height of the character below its feet (so if you have a multilevel building, it is important that you configure the height of the character correctly).

The cases which could be problematic are if an agent is standing next to a very thin wall and the destination suddenly changes to the other side of that thin wall. During the time that it takes for the path to be calculated the agent may see itself as alredy having reached the destination because the destination only moved a very small distance (the wall was thin), even though it may actually be quite a long way around the wall to the other side.

In contrast to reachedEndOfPath, this property is immediately updated when the destination is changed.

IEnumerator Start () {
ai.destination = somePoint;
// Start to search for a path to the destination immediately
ai.SearchPath();
// Wait until the agent has reached the destination
while (!ai.reachedDestination) {
yield return null;
}
// The agent has reached the destination now
}


bool reachedEndOfPath

True if the agent has reached the end of the current path.

Note that setting the destination does not immediately update the path, nor is there any guarantee that the AI will actually be able to reach the destination that you set. The AI will try to get as close as possible. Often you want to use reachedDestination instead which is easier to work with.

It is very hard to provide a method for detecting if the AI has reached the destination that works across all different games because the destination may not even lie on the navmesh and how that is handled differs from game to game (see also the code snippet in the docs for destination).

float remainingDistance

Approximate remaining distance along the current path to the end of the path.

The RichAI movement script approximates this distance since it is quite expensive to calculate the real distance. However it will be accurate when the agent is within 1 corner of the destination. You can use GetRemainingPath to calculate the actual remaining path more precisely.

The AIPath and AILerp scripts use a more accurate distance calculation at all times.

If the agent does not currently have a path, then positive infinity will be returned.

Quaternion rotation

Rotation of the agent.

If updateRotation is true then this value is identical to transform.rotation.

float rotationSpeed = 360

Max rotation speed of the agent.

In degrees per second.

bool slowWhenNotFacingTarget = true

Slow down when not facing the target direction.

Incurs at a small performance overhead.

This setting only has an effect if enableRotation is enabled.

float slowdownTime = 0.5f

How long before reaching the end of the path to start to slow down.

A lower value will make the agent stop more abruptly.

If set to zero the agent will not even attempt to slow down. This can be useful if the target point is not a point you want the agent to stop at but it might for example be the player and you want the AI to slam into the player.

Vector3 steeringTarget

Point on the path which the agent is currently moving towards.

This is usually a point a small distance ahead of the agent or the end of the path.

If the agent does not have a path at the moment, then the agent's current position will be returned.

bool traversingOffMeshLink

float wallDist = 1

Walls within this range will be used for avoidance.

Setting this to zero disables wall avoidance and may improve performance slightly

float wallForce = 3

Force to avoid walls with.

The agent will try to steer away from walls slightly.

Color ShapeGizmoColor = new Color(240/255f, 213/255f, 30/255f)

AutoRepathPolicy autoRepath = new AutoRepathPolicy()

Determines how the agent recalculates its path automatically.

This corresponds to the settings under the "Recalculate Paths Automatically" field in the inspector.

bool canMove = true

Enables or disables movement completely.

If you want the agent to stand still, but still react to local avoidance and use gravity: use isStopped instead.

This is also useful if you want to have full control over when the movement calculations run. Take a look at MovementUpdate

Vector3? desiredVelocity

Velocity that this agent wants to move with.

Includes gravity and local avoidance if applicable. In world units per second.

Vector3 desiredVelocityWithoutLocalAvoidance

Velocity that this agent wants to move with before taking local avoidance into account.

Includes gravity. In world units per second.

Setting this property will set the current velocity that the agent is trying to move with, including gravity. This can be useful if you want to make the agent come to a complete stop in a single frame or if you want to modify the velocity in some way.

// Set the velocity to zero, but keep the current gravity
var newVelocity = new Vector3(0, ai.desiredVelocityWithoutLocalAvoidance.y, 0);

ai.desiredVelocityWithoutLocalAvoidance = newVelocity;


If you are not using local avoidance then this property will in almost all cases be identical to desiredVelocity plus some noise due to floating point math.

Vector3 destination

Position in the world that this agent should move to.

If no destination has been set yet, then (+infinity, +infinity, +infinity) will be returned.

Note that setting this property does not immediately cause the agent to recalculate its path. So it may take some time before the agent starts to move towards this point. Most movement scripts have a repathRate field which indicates how often the agent looks for a new path. You can also call the SearchPath method to immediately start to search for a new path. Paths are calculated asynchronously so when an agent starts to search for path it may take a few frames (usually 1 or 2) until the result is available. During this time the pathPending property will return true.

If you are setting a destination and then want to know when the agent has reached that destination then you could either use reachedDestination (recommended) or check both pathPending and reachedEndOfPath. Check the documentation for the respective fields to learn about their differences.

IEnumerator Start () {
ai.destination = somePoint;
// Start to search for a path to the destination immediately
ai.SearchPath();
// Wait until the agent has reached the destination
while (!ai.reachedDestination) {
yield return null;
}
// The agent has reached the destination now
}
IEnumerator Start () {
ai.destination = somePoint;
// Start to search for a path to the destination immediately
// Note that the result may not become available until after a few frames
// ai.pathPending will be true while the path is being calculated
ai.SearchPath();
// Wait until we know for sure that the agent has calculated a path to the destination we set above
while (ai.pathPending || !ai.reachedEndOfPath) {
yield return null;
}
// The agent has reached the destination now
}


bool enableRotation = true

If true, the AI will rotate to face the movement direction.

float endReachedDistance = 0.2f

Distance to the end point to consider the end of path to be reached.

When the end of the path is within this distance then IAstarAI.reachedEndOfPath will return true. When the destination is within this distance then IAstarAI.reachedDestination will return true.

Note that the destination may not be reached just because the end of the path was reached. The destination may not be reachable at all.

Vector3 gravity = new Vector3(float.NaN, float.NaN, float.NaN)

Gravity to use.

If set to (NaN,NaN,NaN) then Physics.Gravity (configured in the Unity project settings) will be used. If set to (0,0,0) then no gravity will be used and no raycast to check for ground penetration will be performed.

LayerMask groundMask = -1

Layer mask to use for ground placement.

Make sure this does not include the layer of any colliders attached to this gameobject.

float height = 2

Height of the agent in world units.

This is visualized in the scene view as a yellow cylinder around the character.

This value is currently only used if an RVOController is attached to the same GameObject, otherwise it is only used for drawing nice gizmos in the scene view. However since the height value is used for some things, the radius field is always visible for consistency and easier visualization of the character. That said, it may be used for something in a future release.

bool isStopped

Gets or sets if the agent should stop moving.

If this is set to true the agent will immediately start to slow down as quickly as it can to come to a full stop. The agent will still react to local avoidance and gravity (if applicable), but it will not try to move in any particular direction.

The current path of the agent will not be cleared, so when this is set to false again the agent will continue moving along the previous path.

This is a purely user-controlled parameter, so for example it is not set automatically when the agent stops moving because it has reached the target. Use reachedEndOfPath for that.

If this property is set to true while the agent is traversing an off-mesh link (RichAI script only), then the agent will continue traversing the link and stop once it has completed it.

The steeringTarget property will continue to indicate the point which the agent would move towards if it would not be stopped.

float maxSpeed = 1

Max speed in world units per second.

SimpleMovementPlane movementPlane = new SimpleMovementPlane(Quaternion.identity)

Plane which this agent is moving in.

This is used to convert between world space and a movement plane to make it possible to use this script in both 2D games and 3D games.

System.Action onSearchPath

Called when the agent recalculates its path.

This is called both for automatic path recalculations (see canSearch) and manual ones (see SearchPath).

OrientationMode orientation = OrientationMode.ZAxisForward

Determines which direction the agent moves in.

For 3D games you most likely want the ZAxisIsForward option as that is the convention for 3D games. For 2D games you most likely want the YAxisIsForward option as that is the convention for 2D games.

Using the YAxisForward option will also allow the agent to assume that the movement will happen in the 2D (XY) plane instead of the XZ plane if it does not know. This is important only for the point graph which does not have a well defined up direction. The other built-in graphs (e.g the grid graph) will all tell the agent which movement plane it is supposed to use.

Vector3? position

Position of the agent.

In world space. If updatePosition is true then this value is idential to transform.position.

float radius = 0.5f

Radius of the agent in world units.

This is visualized in the scene view as a yellow cylinder around the character.

Note that this does not affect pathfinding in any way. The graph used completely determines where the agent can move.

Quaternion? rotation

Rotation of the agent.

If updateRotation is true then this value is identical to transform.rotation.

RVODestinationCrowdedBehavior rvoDensityBehavior = new RVODestinationCrowdedBehavior(true, 0.5f, false)

Controls if the agent slows down to a stop if the area around the destination is crowded.

Using this module requires that local avoidance is used: i.e. that an RVOController is attached to the GameObject.

bool updatePosition = true

Determines if the character's position should be coupled to the Transform's position.

If false then all movement calculations will happen as usual, but the object that this component is attached to will not move instead only the position property will change.

This is useful if you want to control the movement of the character using some other means such as for example root motion but still want the AI to move freely.

bool updateRotation = true

Determines if the character's rotation should be coupled to the Transform's rotation.

If false then all movement calculations will happen as usual, but the object that this component is attached to will not rotate instead only the rotation property will change.

Vector3? velocity

Actual velocity that the agent is moving with.

In world units per second.

CloseToDestinationMode whenCloseToDestination = CloseToDestinationMode.Stop

What to do when within endReachedDistance units from the destination.

The character can either stop immediately when it comes within that distance, which is useful for e.g archers or other ranged units that want to fire on a target. Or the character can continue to try to reach the exact destination point and come to a full stop there. This is useful if you want the character to reach the exact point that you specified.

Color GizmoColorPath = new Color(8.0f/255, 78.0f/255, 194.0f/255)

Vector3 accumulatedMovementDelta = Vector3.zero

Accumulated movement deltas from the Move method.

bool canMove

Enables or disables movement completely.

If you want the agent to stand still, but still react to local avoidance and use gravity: use isStopped instead.

This is also useful if you want to have full control over when the movement calculations run. Take a look at MovementUpdate

bool canSearch

Enables or disables recalculating the path at regular intervals.

Setting this to false does not stop any active path requests from being calculated or stop it from continuing to follow the current path.

Note that this only disables automatic path recalculations. If you call the SearchPath() method a path will still be calculated.

CharacterController controller

Cached CharacterController component.

bool delayUpdatePath

float distanceToSteeringTarget = float.PositiveInfinity

Distance to steeringTarget in the movement plane.

float height

Height of the agent in world units.

This is visualized in the scene view as a yellow cylinder around the character.

This value is currently only used if an RVOController is attached to the same GameObject, otherwise it is only used for drawing nice gizmos in the scene view. However since the height value is used for some things, the radius field is always visible for consistency and easier visualization of the character. That said, it may be used for something in a future release.

bool lastCorner

Vector2 lastDeltaPosition

Amount which the character wants or tried to move with during the last frame.

float lastDeltaTime

Delta time used for movement during the last frame.

RaycastHit lastRaycastHit

Hit info from the last raycast done for ground placement.

Will not update unless gravity is used (if no gravity is used, then raycasts are disabled).

float lastRepath = float.NegativeInfinity

Time when the last path request was started.

float maxSpeed

Max speed in world units per second.

NativeMovementPlane movementPlane

The plane the agent is moving in.

This is typically the ground plane, which will be the XZ plane in a 3D game, and the XY plane in a 2D game. Ultimately it depends on the graph orientation.

If you are doing pathfinding on a spherical world (see Spherical Worlds), the the movement plane will be the tangent plane of the sphere at the agent's position.

List<Vector3> nextCorners = new List<Vector3>()

OnPathDelegate onPathComplete

Cached delegate for the OnPathComplete method.

Caching this avoids allocating a new one every time a path is calculated, which reduces GC pressure.

Vector3 prevPosition1

Position of the character at the end of the last frame.

Vector3 prevPosition2

Position of the character at the end of the frame before the last frame.

float radius

Radius of the agent in world units.

This is visualized in the scene view as a yellow cylinder around the character.

Note that this does not affect pathfinding in any way. The graph used completely determines where the agent can move.

RichPath richPath = new RichPath()

Holds the current path that this agent is following.

Rigidbody rigid

Cached Rigidbody component.

Rigidbody2D rigid2D

Cached Rigidbody component.

Vector2 rotationFilterState

Internal state used for filtering out noise in the agent's rotation.

Vector2 rotationFilterState2

RVOController rvoController

Cached RVOController component.

Seeker seeker

Cached Seeker component.

bool shouldRecalculatePath

True if the path should be automatically recalculated as soon as possible.

bool shouldRecalculatePath

True if the path should be automatically recalculated as soon as possible.

Vector3 simulatedPosition

Position of the agent.

If updatePosition is true then this value will be synchronized every frame with Transform.position.

Quaternion simulatedRotation

Rotation of the agent.

If updateRotation is true then this value will be synchronized every frame with Transform.rotation.

bool startHasRun = false

True if the Start method has been executed.

Used to test if coroutines should be started in OnEnable to prevent calculating paths in the awake stage (or rather before start on frame 0).

Transform tr

Cached Transform component.

bool usingGravity

Indicates if gravity is used during this frame.

Vector2 velocity2D

Current desired velocity of the agent (does not include local avoidance and physics).

Lies in the movement plane.

float verticalVelocity

Velocity due to gravity.

Perpendicular to the movement plane.

When the agent is grounded this may not accurately reflect the velocity of the agent. It may be non-zero even though the agent is not moving.

bool waitingForPathCalculation = false

Only when the previous path has been calculated should the script consider searching for a new path.

List<Vector3> wallBuffer = new List<Vector3>()