Class Seeker Extends VersionedMonoBehaviour

void CancelCurrentPathRequest (

bool

pool=true

If true then the path will be pooled when the pathfinding system is done with it.

)

Stop calculating the current path request.

If this Seeker is currently calculating a path it will be canceled. The callback (usually to a method named OnPathComplete) will soon be called with a path that has the 'error' field set to true.

This does not stop the character from moving, it just aborts the path calculation.

void DeregisterModifier (

IPathModifier

modifier

)

Called by modifiers when they are disabled or destroyed.

void DrawGizmos ()

Draws gizmos for the Seeker.

Path GetCurrentPath ()

Path that is currently being calculated or was last calculated.

You should rarely have to use this. Instead get the path when the path callback is called.

bool IsDone ()

Is the current path done calculating.

Returns true if the current path has been returned or if the path is null.

Inside the OnPathComplete callback this method will return true.

void PostProcess (

Path

path

)

Post Processes the path.

This will run any modifiers attached to this GameObject on the path. This is identical to calling RunModifiers(ModifierPass.PostProcess, path)

void RegisterModifier (

IPathModifier

modifier

)

Called by modifiers to register themselves.

void RunModifiers (

ModifierPass	pass
Path	path

)

Runs modifiers on a path.

Seeker ()

MultiTargetPath StartMultiTargetPath (

Vector3	start	The start point of the path
Vector3[]	endPoints	The end points of the path
bool	pathsForAll	Indicates whether or not a path to all end points should be searched for or only to the closest one
OnPathDelegate	callback	The function to call when the path has been calculated. If you don't want a callback (e.g. if you instead poll path.IsDone or use a similar method) you can set this to null.
int	graphMask=-1	Mask used to specify which graphs should be searched for close nodes. See Pathfinding.NNConstraint.graphMask.

)

Starts a Multi Target Path from one start point to multiple end points.

A Multi Target Path will search for all the end points in one search and will return all paths if pathsForAll is true, or only the shortest one if pathsForAll is false.
callback and pathCallback will be called when the path has completed. Callback will not be called if the path is canceled (e.g when a new path is requested before the previous one has completed)

var endPoints = new Vector3[] {
transform.position + Vector3.forward * 5,
transform.position + Vector3.right * 10,
transform.position + Vector3.back * 15
};
// Start a multi target path, where endPoints is a Vector3[] array.
// The pathsForAll parameter specifies if a path to every end point should be searched for
// or if it should only try to find the shortest path to any end point.
var path = seeker.StartMultiTargetPath(transform.position, endPoints, pathsForAll: true, callback: null);
path.BlockUntilCalculated();

if (path.error) {
Debug.LogError("Error calculating path: " + path.errorLog);
return;
}

Debug.Log("The closest target was index " + path.chosenTarget);

// Draw the path to all targets
foreach (var subPath in path.vectorPaths) {
for (int i = 0; i < subPath.Count - 1; i++) {
Debug.DrawLine(subPath[i], subPath[i+1], Color.green, 10);
}
}

// Draw the path to the closest target
for (int i = 0; i < path.vectorPath.Count - 1; i++) {
Debug.DrawLine(path.vectorPath[i], path.vectorPath[i+1], Color.red, 10);
}


MultiTargetPath StartMultiTargetPath (

Vector3[]	startPoints	The start points of the path
Vector3	end	The end point of the path
bool	pathsForAll	Indicates whether or not a path from all start points should be searched for or only to the closest one
OnPathDelegate	callback	The function to call when the path has been calculated. If you don't want a callback (e.g. if you instead poll path.IsDone or use a similar method) you can set this to null.
int	graphMask=-1	Mask used to specify which graphs should be searched for close nodes. See Pathfinding.NNConstraint.graphMask.

)

Starts a Multi Target Path from multiple start points to a single target point.

A Multi Target Path will search from all start points to the target point in one search and will return all paths if pathsForAll is true, or only the shortest one if pathsForAll is false.
callback and pathCallback will be called when the path has completed. Callback will not be called if the path is canceled (e.g when a new path is requested before the previous one has completed)

Path StartPath (

Vector3	start	The start point of the path
Vector3	end	The end point of the path
OnPathDelegate	callback	The function to call when the path has been calculated. If you don't want a callback (e.g. if you instead poll path.IsDone or use a similar method) you can set this to null.

)

Queue a path to be calculated.

The callback will be called when the path has been calculated (which may be several frames into the future). Callback will not be called if the path is canceled (e.g when a new path is requested before the previous one has completed)

void Start () {
// Get the seeker component attached to this GameObject
var seeker = GetComponent<Seeker>();

// Schedule a new path request from the current position to a position 10 units forward.
// When the path has been calculated, the OnPathComplete method will be called, unless it was canceled by another path request
seeker.StartPath(transform.position, transform.position + Vector3.forward * 10, OnPathComplete);

// Note that the path is NOT calculated at this point
// It has just been queued for calculation
}

void OnPathComplete (Path path) {
// The path is now calculated!

if (path.error) {
Debug.LogError("Path failed: " + path.errorLog);
return;
}

// Cast the path to the path type we were using
var abPath = path as ABPath;

// Draw the path in the scene view for 10 seconds
for (int i = 0; i < abPath.vectorPath.Count - 1; i++) {
Debug.DrawLine(abPath.vectorPath[i], abPath.vectorPath[i+1], Color.red, 10);
}
}


Path StartPath (

Vector3	start	The start point of the path
Vector3	end	The end point of the path
OnPathDelegate	callback	The function to call when the path has been calculated. If you don't want a callback (e.g. if you instead poll path.IsDone or use a similar method) you can set this to null.
GraphMask	graphMask	Mask used to specify which graphs should be searched for close nodes. See Pathfinding.NNConstraint.graphMask. This will override graphMask for this path request.

)

Queue a path to be calculated.

The callback will be called when the path has been calculated (which may be several frames into the future). Callback will not be called if the path is canceled (e.g when a new path is requested before the previous one has completed)

// Schedule a path search that will only start searching the graphs with index 0 and 3
seeker.StartPath(startPoint, endPoint, null, 1 << 0 | 1 << 3);


Path StartPath (

Path

p

The path to start calculating

)

Queue a path to be calculated.

This overload takes no callback parameter. Instead, it is expected that you poll the path for completion, or block until it is completed.

However, Path.IsDone should not be used with the Seeker component. This is because while the path itself may be calculated, the Seeker may not have had time to run post processing modifiers on the path yet.

Path StartPath (

Path	p	The path to start calculating
OnPathDelegate	callback	The function to call when the path has been calculated. If you don't want a callback (e.g. if you instead poll path.IsDone or use a similar method) you can set this to null.

)

Queue a path to be calculated.

The callback will be called when the path has been calculated (which may be several frames into the future). The callback will not be called if a new path request is started before this path request has been calculated.

Path StartPath (

Path	p	The path to start calculating
OnPathDelegate	callback	The function to call when the path has been calculated. If you don't want a callback (e.g. if you instead poll path.IsDone or use a similar method) you can set this to null.
GraphMask	graphMask	Mask used to specify which graphs should be searched for close nodes. See Pathfinding.GraphMask. This will override graphMask for this path request.

)

Call this function to start calculating a path.

The callback will be called when the path has been calculated (which may be several frames into the future). The callback will not be called if a new path request is started before this path request has been calculated.

bool detailedGizmos

Enables drawing of the non-postprocessed path using Gizmos.

The path will show up in orange.

Requires that drawGizmos is true.

This will show the path before any post processing such as smoothing is applied.

bool drawGizmos = true

Enables drawing of the last calculated path using Gizmos.

The path will show up in green.

GraphMask graphMask = GraphMask.everything

Graphs that this Seeker can use.

This field determines which graphs will be considered when searching for the start and end nodes of a path. It is useful in numerous situations, for example if you want to make one graph for small units and one graph for large units.

This is a bitmask so if you for example want to make the agent only use graph index 3 then you can set this to: seeker.graphMask = 1 << 3;


Note that this field only stores which graph indices that are allowed. This means that if the graphs change their ordering then this mask may no longer be correct.

If you know the name of the graph you can use the Pathfinding.GraphMask.FromGraphName method: GraphMask mask1 = GraphMask.FromGraphName("My Grid Graph");
GraphMask mask2 = GraphMask.FromGraphName("My Other Grid Graph");

NNConstraint nn = NNConstraint.Walkable;

nn.graphMask = mask1 | mask2;

// Find the node closest to somePoint which is either in 'My Grid Graph' OR in 'My Other Grid Graph'
var info = AstarPath.active.GetNearest(somePoint, nn);
Some overloads of the StartPath methods take a graphMask parameter. If those overloads are used then they will override the graph mask for that path request.

OnPathDelegate postProcessPath

Called after a path has been calculated, right before modifiers are executed.

OnPathDelegate preProcessPath

Called before pathfinding is started.

StartEndModifier startEndModifier = new StartEndModifier()

Path modifier which tweaks the start and end points of a path.

int[] tagPenalties = new int[32]

Penalties for each tag.

Tag 0 which is the default tag, will have added a penalty of tagPenalties[0]. These should only be positive values since the A* algorithm cannot handle negative penalties.

The length of this array should be exactly 32, one for each tag.

int traversableTags = -1

The tags which the Seeker can traverse.

ITraversalProvider traversalProvider

Custom traversal provider to calculate which nodes are traversable and their penalties.

This can be used to override the built-in pathfinding logic.

seeker.traversalProvider = new MyCustomTraversalProvider();


ModifierPass

void Awake ()

Initializes a few variables.

void OnDestroy ()

Cleans up some variables.

Releases any eventually claimed paths. Calls OnDestroy on the startEndModifier.

void OnMultiPathComplete (

Path

p

)

Called once for a MultiTargetPath.

Only returns the path, does not post process.

void OnPartialPathComplete (

Path

p

)

Called for each path in a MultiTargetPath.

Only post processes the path, does not return it.

void OnPathComplete (

Path

path

)

Called when a path has completed.

void OnPathComplete (

Path	p
bool	runModifiers
bool	sendCallbacks

)

Called when a path has completed.

Will post process it and return it by calling tmpPathCallback and pathCallback

void OnUpgradeSerializedData (

refSerialization.Migrations	migrations
bool	unityThread

)

void OnUpgradeSerializedData (

refMigrations	migrations
bool	unityThread

)

Handle serialization backwards compatibility.

void ReleaseClaimedPath ()

Releases the path used for gizmos (if any).

The seeker keeps the latest path claimed so it can draw gizmos. In some cases this might not be desireable and you want it released. In that case, you can call this method to release it (not that path gizmos will then not be drawn).

If you didn't understand anything from the description above, you probably don't need to use this method.

void Reset ()

Handle serialization backwards compatibility.

void StartPathInternal (

Path	p
OnPathDelegate	callback

)

Internal method to start a path and mark it as the currently active path.

void UpgradeSerializedData (

bool

isUnityThread

)

int graphMaskCompatibility = -1

Used for serialization backwards compatibility.

List<GraphNode> lastCompletedNodePath

Used for drawing gizmos.

List<Vector3> lastCompletedVectorPath

Used for drawing gizmos.

uint lastPathID

The path ID of the last path queried.

List<IPathModifier> modifiers = new List<IPathModifier>()

Internal list of all modifiers.

OnPathDelegate onPartialPathDelegate

Cached delegate to avoid allocating one every time a path is started.

OnPathDelegate onPathDelegate

Cached delegate to avoid allocating one every time a path is started.

Path path

The current path.

Path prevPath

Previous path.

Used to draw gizmos

OnPathDelegate tmpPathCallback

Temporary callback only called for the current path.

This value is set by the StartPath functions

Path StartPath (

Vector3	start	The start point of the path
Vector3	end	The end point of the path

)

Queue a path to be calculated.

Since this method does not take a callback parameter, you should set the pathCallback field before calling this method.

void Start () {
// Get the seeker component attached to this GameObject
var seeker = GetComponent<Seeker>();

// Schedule a new path request from the current position to a position 10 units forward.
// When the path has been calculated, the OnPathComplete method will be called, unless it was canceled by another path request
seeker.StartPath(transform.position, transform.position + Vector3.forward * 10, OnPathComplete);

// Note that the path is NOT calculated at this point
// It has just been queued for calculation
}

void OnPathComplete (Path path) {
// The path is now calculated!

if (path.error) {
Debug.LogError("Path failed: " + path.errorLog);
return;
}

// Cast the path to the path type we were using
var abPath = path as ABPath;

// Draw the path in the scene view for 10 seconds
for (int i = 0; i < abPath.vectorPath.Count - 1; i++) {
Debug.DrawLine(abPath.vectorPath[i], abPath.vectorPath[i+1], Color.red, 10);
}
}


OnPathDelegate pathCallback

Callback for when a path is completed.

Movement scripts should register to this delegate.
A temporary callback can also be set when calling StartPath, but that delegate will only be called for that path

public void Start () {
// Assumes a Seeker component is attached to the GameObject
Seeker seeker = GetComponent<Seeker>();

// seeker.pathCallback is a OnPathDelegate, we add the function OnPathComplete to it so it will be called whenever a path has finished calculating on that seeker
seeker.pathCallback += OnPathComplete;
}

public void OnPathComplete (Path p) {
Debug.Log("This is called when a path is completed on the seeker attached to this GameObject");
}