Movement scripts

Brief overview of the different movement scripts in the package.

There are several movement scripts included in the package. These are the scripts that actually move some object in your scene along a path, usually a character of some sort. The movement scripts' primary role is to take care of searching for paths and following them.

These scripts are completely optional in this package; you can use pathfinding without using a movement script, or you can write your own movement script. However, for many games they provide a nice base to build your characters on, even if you perhaps later in development replace them with something specifically tailored for your game.

There are four included movement scripts in the package: FollowerEntity, AIPath, RichAI and AILerp. The names of the scripts could, in hindsight, definitely have been chosen better, but I'm hesitant to change them at this point as a large quantity of support material and forum posts refer to these names.

The primary differences between the movement scripts are:

FollowerEntity

Good all-around movement script which works on grid, navmesh and recast graphs.
Follows paths smoothly and is very responsive.
Uses the Entity Component System behind the scenes.
Works well with local avoidance.
Supports movement in 3D games as well as 2D games.
Works well with off-mesh links.
Knows which node it is traversing at all times.
Not compatible with path modifiers (simplifies the path internally instead).
Stronger guarantees compared to the other movement scripts; it handles edge cases better.
High code complexity.
Cannot be used with Unity's character controller.
A standalone component which does not need a separate Seeker or RVOController component.

AIPath

Good all-around movement script which works on all graph types.
Follows paths smoothly and responds to physics.
Works well with local avoidance.
Supports movement in 3D games as well as 2D games.
Can traverse off-mesh links, but cannot use special movement logic for them.
Compatible with path modifiers.
Requires the Seeker component, and optionally an RVOController component for local avoidance.

RichAI

Designed specifically for navmesh/recast graphs and does not work with any other graph types.
Better than the AIPath script at following paths on navmesh-based graphs; it can handle getting pushed off its path better and usually follows the path more smoothly.
Has better support for off-mesh links compared to AIPath.
Works well with local avoidance.
Supports movement in 3D games (movement in the XZ plane), but not 2D.
Works well with off-mesh links.
Not compatible with most path modifiers (simplifies the path internally instead).
Requires the Seeker component, and optionally an RVOController component for local avoidance.
Kept for compatibility only. If you are starting a new project, the FollowerEntity script is better in almost every way.

AILerp

Uses linear interpolation to move along the path (which is why 'lerp', which stands for linear interpolation, is in the name). Does not use physics in any way.
Follows the path exactly, without any deviations whatsoever.
Due to the above points, it does not make sense to use it with local avoidance, and thus it does not support it.
By far the fastest of the movement scripts, because the movement in itself is much simpler, but keep in mind that if you need any kind of physical realism in the game, you should usually use one of the other movement scripts.
Supports movement in 3D games as well as 2D games.
Compatible with path modifiers.
Low code complexity.
Requires the Seeker component.

In short, if you are using a navmesh or grid-based graph: try the FollowerEntity component first, otherwise use either AIPath or AILerp depending on what kind of movement style your game needs. Check out the example scenes included in the package to see how the different movement scripts behave.

All movement scripts included in the package implement the Pathfinding.IAstarAI interface. So if you need something that can interact with several different movement scripts, this is a nice interface to use.

For example, these are some properties which you may find useful (these properties exist on all movement scripts):

destination

Position in the world that this agent should move to.

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 }

See

AIPath.endReachedDistance

remainingDistance

reachedEndOfPath

See This setting corresponds to the member Pathfinding.IAstarAI.reachedDestination

velocity

Actual velocity that the agent is moving with.

desiredVelocity

Velocity that this agent wants to move with.

See

IAstarAI

Migrating from Unity Navigation

If you want your character to follow a specific object, you can use the included script AIDestinationSetter. This will, behind the scenes, simply set the destination property every frame to the position of your chosen target.

Writing a movement script