Class RVOController Extends VersionedMonoBehaviour

Vector3 CalculateMovementDelta (

float

deltaTime

How far to move [seconds]. Usually set to Time.deltaTime.

)

Direction and distance to move in a single frame to avoid obstacles.

The position of the agent is taken from the attached movement script's position (see Pathfinding.IAstarAI.position) or if none is attached then transform.position.

Vector3 CalculateMovementDelta (

Vector3	position	Position of the agent.
float	deltaTime	How far to move [seconds]. Usually set to Time.deltaTime.

)

Direction and distance to move in a single frame to avoid obstacles.

public void Update () {
// Just some point far away
var targetPoint = transform.position + transform.forward * 100;

// Set the desired point to move towards using a desired speed of 10 and a max speed of 12
controller.SetTarget(targetPoint, 10, 12, targetPoint);

// Calculate how much to move during this frame
// This information is based on movement commands from earlier frames
// as local avoidance is calculated globally at regular intervals by the RVOSimulator component
var delta = controller.CalculateMovementDelta(transform.position, Time.deltaTime);
transform.position = transform.position + delta;
}


void DrawGizmos ()

void Move (

Vector3

velocity

Velocity in units/second that you want the agent to move with.

)

Set the desired velocity for the agent.

This is assumed to stay the same until something else is requested (as opposed to being reset every frame).

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	pos	Point in world space to move towards.
float	speed	Desired speed in world units per second.
float	maxSpeed	Maximum speed in world units per second. The agent will use this speed if it is necessary to avoid collisions with other agents. Should be at least as high as speed, but it is recommended to use a slightly higher value than speed (for example speed*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.

)

Set the target point for the agent to move towards.

Similar to the Move method but this is more flexible. It is also better to use near the end of the path as when using the Move method the agent does not know where to stop, so it may overshoot the target. When using this method the agent will not overshoot the target. The agent will assume that it will stop when it reaches the target so make sure that you don't place the point too close to the agent if you actually just want to move in a particular direction.

The target point is assumed to stay the same until something else is requested (as opposed to being reset every frame).

Vector2 To2D (

Vector3

p

)

Converts a 3D vector to a 2D vector in the movement plane.

If movementPlane is XZ it will be projected onto the XZ plane otherwise it will be projected onto the XY plane.

Vector2 To2D (

Vector3	p
out float	elevation

)

Converts a 3D vector to a 2D vector in the movement plane.

If movementPlane is XZ it will be projected onto the XZ plane and the elevation coordinate will be the Y coordinate otherwise it will be projected onto the XY plane and elevation will be the Z coordinate.

Vector3 To3D (

Vector2	p
float	elevationCoordinate

)

Converts a 2D vector in the movement plane as well as an elevation to a 3D coordinate.

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.

float agentTimeHorizon = 2

How far into the future to look for collisions with other agents (in seconds)

float center

Center of the agent relative to the pivot point of this game object.

RVOLayer collidesWith = (RVOLayer)(-1)

Layer mask specifying which layers this agent will avoid.

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

This can be very useful in games which have multiple teams of some sort. For example you usually want the agents in one team to avoid each other, but you do not want them to avoid the enemies.

This field only affects which other agents that this agent will avoid, it does not affect how other agents react to this agent.

AgentDebugFlags debug

Enables drawing debug information in the scene view.

float flowFollowingStrength = 0.0f

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.

RVOLayer layer = RVOLayer.DefaultAgent

Specifies the avoidance layer for this agent.

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

bool lockWhenNotMoving = false

Automatically set locked to true when desired velocity is approximately zero.

This prevents other units from pushing them away when they are supposed to e.g block a choke point.

When this is true every call to SetTarget or Move will set the locked field to true if the desired velocity was non-zero or false if it was zero.

bool locked

A locked unit cannot move.

Other units will still avoid it but avoidance quality is not the best.

int maxNeighbours = 10

Max number of other agents to take into account.

A smaller value can reduce CPU load, a higher value can lead to better local avoidance quality.

SimpleMovementPlane???????? movementPlane

Determines if the XY (2D) or XZ (3D) plane is used for movement.

MovementPlane movementPlaneMode

float obstacleTimeHorizon = 0.5f

How far into the future to look for collisions with obstacles (in seconds)

Vector3 position

Current position of the agent.

Note that this is only updated every local avoidance simulation step, not every frame.

float priority = 0.5f

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 priorityMultiplier = 1.0f

Priority multiplier.

This functions identically to the priority, however it is not exposed in the Unity inspector. It is primarily used by the Pathfinding.RVO.RVODestinationCrowdedBehavior.

float radius

Radius of the agent in world units.

IAgent rvoAgent

Reference to the internal agent.

Vector3? velocity

Current calculated velocity of the agent.

This is not necessarily the velocity the agent is actually moving with (that is up to the movement script to decide) but it is the velocity that the RVO system has calculated is best for avoiding obstacles and reaching the target.

You can also set the 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.

Setting the velocity using this property 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 property is set again.

Note that if you set the velocity the value that can be read from this property will not change until the next simulation step.

void Awake ()

void OnAgentDestroyed ()

void OnDisable ()

void OnEnable ()

void OnUpgradeSerializedData (

refMigrations	migrations
bool	unityThread

)

Handle serialization backwards compatibility.

void OnUpgradeSerializedData (

refSerialization.Migrations	migrations
bool	unityThread

)

RVOControllerMigrations

void Reset ()

Handle serialization backwards compatibility.

void UpdateAgentProperties ()

void UpgradeSerializedData (

bool

isUnityThread

)

IAstarAI ai

Cached reference to a movement script (if one is used)

IAstarAI aiBackingField

float centerBackingField = 1

float heightBackingField = 2

SimpleMovementPlane movementPlaneBackingField = GraphTransform.xzPlane.ToSimpleMovementPlane()

GraphNode obstacleQuery

float radiusBackingField = 0.5f

SimulatorBurst simulator

Reference to the rvo simulator.

Transform tr

Cached tranform component.

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

Vector3

pos

)

Teleport the agent to a new position.

bool enableRotation

LayerMask mask

float maxSpeed

float rotationSpeed

float wallAvoidFalloff = 1

How much the wallAvoidForce decreases with distance.

The strenght of avoidance is: str = 1/dist*wallAvoidFalloff


float wallAvoidForce = 1

An extra force to avoid walls.

This can be good way to reduce "wall hugging" behaviour.