SimulatorBurst.Agent Class Reference

Public Member Functions
void	ForceSetVelocity (Vector2 velocity)
	Set the current velocity of the agent. More...
void	SetCollisionNormal (Vector2 normal)
	Set the normal of a wall (or something else) the agent is currently colliding with. More...
void	SetTarget (Vector2 targetPoint, float desiredSpeed, float maxSpeed)
	Point towards which the agent should move. More...

Public Attributes
int	agentIndex
float	CalculatedSpeed => simulator.outputData.speed[agentIndex]
Vector2	CalculatedTargetPoint => simulator.outputData.targetPoint[agentIndex]
int	NeighbourCount => throw new NotImplementedException()
List< ObstacleVertex >	NeighbourObstacles => throw new NotImplementedException()
SimulatorBurst	simulator

Properties
float	AgentTimeHorizon [get, set]
RVOLayer	CollidesWith [get, set]
bool	DebugDraw [get, set]
float	ElevationCoordinate [get, set]
float	FlowFollowingStrength [get, set]
float	Height [get, set]
RVOLayer	Layer [get, set]
bool	Locked [get, set]
int	MaxNeighbours [get, set]
float	ObstacleTimeHorizon [get, set]
Vector2	Position [get, set]
Action	PreCalculationCallback [set]
float	Priority [get, set]
float	Radius [get, set]
Properties inherited from IAgent
float	AgentTimeHorizon [get, set]
	Max number of estimated seconds to look into the future for collisions with agents. More...
float	CalculatedSpeed [get]
	Optimal speed of the agent to avoid collisions. More...
Vector2	CalculatedTargetPoint [get]
	Optimal point to move towards to avoid collisions. More...
RVOLayer	CollidesWith [get, set]
	Layer mask specifying which layers this agent will avoid. More...
bool	DebugDraw [get, set]
	Draw debug information. More...
float	ElevationCoordinate [get, set]
	Coordinate which separates characters in the height direction. More...
float	FlowFollowingStrength [get, set]
	Determines how strongly this agent just follows the flow instead of making other agents avoid it. More...
float	Height [get, set]
	Height of the agent in world units. More...
RVOLayer	Layer [get, set]
	Specifies the avoidance layer for this agent. More...
bool	Locked [get, set]
	Locked agents will be assumed not to move. More...
int	MaxNeighbours [get, set]
	Max number of agents to take into account. More...
int	NeighbourCount [get]
	Number of neighbours that the agent took into account during the last simulation step. More...
List< ObstacleVertex >	NeighbourObstacles [get]
	List of obstacle segments which were close to the agent during the last simulation step. More...
float	ObstacleTimeHorizon [get, set]
	Max number of estimated seconds to look into the future for collisions with obstacles. More...
Vector2	Position [get, set]
	Position of the agent. More...
System.Action	PreCalculationCallback [set]
	Callback which will be called right before avoidance calculations are started. More...
float	Priority [get, set]
	How strongly other agents will avoid this agent. More...
float	Radius [get, set]
	Radius of the agent in world units. More...

Member Function Documentation

ForceSetVelocity()

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.

Implements IAgent.

SetCollisionNormal()

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.

Implements IAgent.

SetTarget()

void SetTarget	(	Vector2	targetPoint,
		float	desiredSpeed,
		float	maxSpeed
	)

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.

Parameters

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.
desiredSpeed	Desired speed of the agent. In world units per second. The agent will try to move with this speed if possible.
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).

Implements IAgent.

Member Data Documentation

agentIndex

int agentIndex

CalculatedSpeed

float CalculatedSpeed => simulator.outputData.speed[agentIndex]

CalculatedTargetPoint

Vector2 CalculatedTargetPoint => simulator.outputData.targetPoint[agentIndex]

NeighbourCount

int NeighbourCount => throw new NotImplementedException()

NeighbourObstacles

List<ObstacleVertex> NeighbourObstacles => throw new NotImplementedException()

simulator

SimulatorBurst simulator

Property Documentation

AgentTimeHorizon

float AgentTimeHorizon

getset

CollidesWith

RVOLayer CollidesWith

getset

DebugDraw

bool DebugDraw

getset

ElevationCoordinate

float ElevationCoordinate

getset

FlowFollowingStrength

float FlowFollowingStrength

getset

Height

float Height

getset

Layer

RVOLayer Layer

getset

Locked

bool Locked

getset

MaxNeighbours

int MaxNeighbours

getset

ObstacleTimeHorizon

float ObstacleTimeHorizon

getset

Position

Vector2 Position

getset

PreCalculationCallback

Action PreCalculationCallback

set

Priority

float Priority

getset

Radius

float Radius

getset

---

The documentation for this class was generated from the following file:

• /Users/arong/Unity/a-pathfinding-project/Assets/AstarPathfindingProject/Core/RVO/RVOCoreSimulatorBurst.cs