Interface IAgent

void ForceSetVelocity (

Vector2

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 (

Vector2

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 SetTarget (

Vector2	targetPoint	Target point in world space (XZ plane or XY plane depending on if the simulation is configured for 2D or 3D). Note that this is a Vector2, not a Vector3 since the system simulates everything internally in 2D. So if your agents move in the XZ plane you will have to supply it as a Vector2 with (x,z) coordinates.
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).

)

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.

Note

The system assumes that the agent will stop when it reaches the target point so if you just want to move the agent in a particular direction, make sure that you set the target point a good distance in front of the character as otherwise the system may not avoid colisions that well. What would happen is that the system (in simplified terms) would think that the agents would stop before the collision and thus it wouldn't slow down or change course. See the image below. In the image the desiredSpeed is the length of the blue arrow and the target point is the point where the black arrows point to. In the upper case the agent does not avoid the red agent (you can assume that the red agent has a very small velocity for simplicity) while in the lower case it does.
If you are following a path a good way to pick the target point is to set it to targetPoint = directionToNextWaypoint.normalized * remainingPathDistance
Where remainingPathDistance is the distance until the character would reach the end of the path. This works well because at the end of the path the direction to the next waypoint will just be the direction to the last point on the path and remainingPathDistance will be the distance to the last point in the path, so targetPoint will be set to simply the last point in the path. However when remainingPathDistance is large the target point will be so far away that the agent will essentially be told to move in a particular direction, which is precisely what we want.

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.

float CalculatedSpeed

Optimal speed of the agent to avoid collisions.

The movement script should move towards CalculatedTargetPoint with this speed.

Vector2 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 ...

bool DebugDraw

Draw debug information.

float ElevationCoordinate

Coordinate which separates characters in the height direction.

Since RVO can be used either in 2D or 3D, it is not as simple as just using the y coordinate of the 3D position. In 3D this will most likely be set to the y coordinate, but in 2D (top down) it should in most cases be set to 0 since all characters are always in the same plane, however it may be set to some other value, for example if the game is 2D isometric.

The position is assumed to be at the base of the character (near the feet).

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.

float Height

Height of the agent in world units.

Agents are modelled as circles/cylinders.

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.

int NeighbourCount

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

List<ObstacleVertex> NeighbourObstacles

List of obstacle segments which were close to the agent during the last simulation step.

Can be used to apply additional wall avoidance forces for example. Segments are formed by the obstacle vertex and its .next property.

float ObstacleTimeHorizon

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

Vector2 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.

Note that this is a Vector2, not a Vector3 since the RVO simulates everything internally in 2D. So if your agents move in the XZ plane you may have to convert it to a Vector3 like this.

Vector3 position3D = new Vector3(agent.Position.x, agent.ElevationCoordinate, agent.Position.y);


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.