Interface IAgent

void ForceSetVelocity (

Vector3

velocity

)

Set the current velocity of the agent.

This will override the local avoidance input completely. It is useful if you have a player controlled character and want other agents to avoid it.

Calling this method will mark the agent as being externally controlled for 1 simulation step. Local avoidance calculations will be skipped for the next simulation step but will be resumed after that unless this method is called again.

void SetCollisionNormal (

Vector3

normal

)

Set the normal of a wall (or something else) the agent is currently colliding with.

This is used to make the RVO system aware of things like physics or an agent being clamped to the navmesh. The velocity of this agent that other agents observe will be modified so that there is no component into the wall. The agent will however not start to avoid the wall, for that you will need to add RVO obstacles.

This value will be cleared after the next simulation step, normally it should be set every frame when the collision is still happening.

void SetObstacleQuery (

GraphNode

sourceNode

The node to start the obstacle search at. This is typically the node the agent is standing on.

)

Add obstacles to avoid for this agent.

The obstacles are based on nearby borders of the navmesh. You should call this method every frame.

void SetTarget (

Vector3	targetPoint	Target point in world space.
float	desiredSpeed	Desired speed of the agent. In world units per second. The agent will try to move with this speed if possible.
float	maxSpeed	Max speed of the agent. In world units per second. If necessary (for example if another agent is on a collision trajectory towards this agent) the agent can move at this speed. Should be at least as high as desiredSpeed, but it is recommended to use a slightly higher value than desiredSpeed (for example desiredSpeed*1.2).
Vector3	endOfPath	Point in world space which is the agent's final desired destination on the navmesh. This is typically the end of the path the agent is following. May be set to (+inf,+inf,+inf) to mark the agent as not having a well defined end of path. If this is set, multiple agents with roughly the same end of path will crowd more naturally around this point. They will be able to realize that they cannot get closer if there are many agents trying to get closer to the same destination and then stop.

)

Point towards which the agent should move.

Usually you set this once per frame. The agent will try move as close to the target point as possible. Will take effect at the next simulation step.

int AgentIndex

Internal index of the agent.

float AgentTimeHorizon

Max number of estimated seconds to look into the future for collisions with agents.

As it turns out, this variable is also very good for controling agent avoidance priorities. Agents with lower values will avoid other agents less and thus you can make 'high priority agents' by giving them a lower value.

bool AvoidingAnyAgents

True if the agent's movement is affected by any other agents or obstacles.

If the agent is all alone, and can just move in a straight line to its target, this will be false. If it has to adjust its velocity, even slightly, to avoid collisions, this will be true.

ReachedEndOfPath CalculatedEffectivelyReachedDestination

float CalculatedSpeed

Optimal speed of the agent to avoid collisions.

The movement script should move towards CalculatedTargetPoint with this speed.

Vector3 CalculatedTargetPoint

Optimal point to move towards to avoid collisions.

The movement script should move towards this point with a speed of CalculatedSpeed.

RVOLayer CollidesWith

Layer mask specifying which layers this agent will avoid.

You can set it as CollidesWith = RVOLayer.DefaultAgent | RVOLayer.Layer3 | RVOLayer.Layer6 ...

AgentDebugFlags DebugFlags

Draw debug information in the scene view.

System.Action DestroyedCallback

Callback which will be called right the agent is removed from the simulation.

This agent should not be used anymore after this callback has been called.

float FlowFollowingStrength

Determines how strongly this agent just follows the flow instead of making other agents avoid it.

The default value is 0, if it is greater than zero (up to the maximum value of 1) other agents will not avoid this character as much. However it works in a different way to Priority.

A group of agents with FlowFollowingStrength set to a high value that all try to reach the same point will end up just settling to stationary positions around that point, none will push the others away to any significant extent. This is tricky to achieve with priorities as priorities are all relative, so setting all agents to a low priority is the same thing as not changing priorities at all.

Should be a value in the range [0, 1].

float Height

Height of the agent in world units.

Agents are modelled as circles/cylinders.

int HierarchicalNodeIndex

RVOLayer Layer

Specifies the avoidance layer for this agent.

The CollidesWith mask on other agents will determine if they will avoid this agent.

bool Locked

Locked agents will be assumed not to move.

int MaxNeighbours

Max number of agents to take into account.

Decreasing this value can lead to better performance, increasing it can lead to better quality of the simulation.

Util.SimpleMovementPlane MovementPlane

Plane in which the agent moves.

Local avoidance calculations are always done in 2D and this plane determines how to convert from 3D to 2D.

In a typical 3D game the agents move in the XZ plane and in a 2D game they move in the XY plane. By default this is set to the XZ plane.

int NeighbourCount

Number of neighbours that the agent took into account during the last simulation step.

float ObstacleTimeHorizon

Max number of estimated seconds to look into the future for collisions with obstacles.

Vector3 Position

Position of the agent.

The agent does not move by itself, a movement script has to be responsible for reading the CalculatedTargetPoint and CalculatedSpeed properties and move towards that point with that speed. This property should ideally be set every frame.

System.Action PreCalculationCallback

Callback which will be called right before avoidance calculations are started.

Used to update the other properties with the most up to date values

float Priority

How strongly other agents will avoid this agent.

Usually a value between 0 and 1. Agents with similar priorities will avoid each other with an equal strength. If an agent sees another agent with a higher priority than itself it will avoid that agent more strongly. In the extreme case (e.g this agent has a priority of 0 and the other agent has a priority of 1) it will treat the other agent as being a moving obstacle. Similarly if an agent sees another agent with a lower priority than itself it will avoid that agent less.

In general the avoidance strength for this agent is: if this.priority > 0 or other.priority > 0:
avoidanceStrength = other.priority / (this.priority + other.priority);
else:
avoidanceStrength = 0.5


float Radius

Radius of the agent in world units.

Agents are modelled as circles/cylinders.