A* Pathfinding Project  4.0.3
The A* Pathfinding Project for Unity 3D
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Properties Events Macros Groups Pages
AstarPath Class Reference

Core component for the A* Pathfinding System. More...

Detailed Description

Core component for the A* Pathfinding System.

This class handles all of the pathfinding system, calculates all paths and stores the info.
This class is a singleton class, meaning there should only exist at most one active instance of it in the scene.
It might be a bit hard to use directly, usually interfacing with the pathfinding system is done through the Seeker class.

Examples:
MovePointNode.cs, MultiTargetFree.cs, and WaypointPath.cs.

Public Types

enum  AstarDistribution { WebsiteDownload, AssetStore }
 Information about where the package was downloaded. More...
 

Public Member Functions

void AddWorkItem (System.Action callback)
 Add a work item to be processed when pathfinding is paused.
 
void AddWorkItem (AstarWorkItem item)
 Add a work item to be processed when pathfinding is paused.
 
void BlockUntilPathQueueBlocked ()
 Blocks until all pathfinding threads are paused and blocked.
 
void EnsureValidFloodFill ()
 If a WorkItem needs to have a valid flood fill during execution, call this method to ensure there are no pending flood fills.
 
void FloodFill (GraphNode seed)
 Floodfills starting from the specified node.
 
void FloodFill (GraphNode seed, uint area)
 Floodfills starting from 'seed' using the specified area.
 
void FloodFill ()
 Floodfills all graphs and updates areas for every node.
 
void FlushGraphUpdates ()
 Forces graph updates to complete in a single frame.
 
void FlushThreadSafeCallbacks ()
 Forces thread safe callbacks to run.
 
void FlushWorkItems ()
 Forces work items to complete in a single frame.
 
void FlushWorkItems (bool unblockOnComplete, bool block)
 Make sure work items are executed.
 
NNInfo GetNearest (Vector3 position)
 Returns the nearest node to a position using the specified NNConstraint.
 
NNInfo GetNearest (Vector3 position, NNConstraint constraint)
 Returns the nearest node to a position using the specified NNConstraint.
 
NNInfo GetNearest (Vector3 position, NNConstraint constraint, GraphNode hint)
 Returns the nearest node to a position using the specified NNConstraint.
 
GraphNode GetNearest (Ray ray)
 Returns the node closest to the ray (slow).
 
string[] GetTagNames ()
 Returns tag names.
 
PathProcessor.GraphUpdateLock PausePathfinding ()
 Blocks until all pathfinding threads are paused and blocked.
 
void QueueGraphUpdates ()
 Will apply queued graph updates as soon as possible, regardless of batchGraphUpdates.
 
void QueueWorkItemFloodFill ()
 Call during work items to queue a flood fill.
 
void Scan (NavGraph graphToScan)
 Scans a particular graph.
 
void Scan (NavGraph[] graphsToScan=null)
 Scans all specified graphs.
 
IEnumerable< ProgressScanAsync (NavGraph graphToScan)
 Scans a particular graph asynchronously.
 
IEnumerable< ProgressScanAsync (NavGraph[] graphsToScan=null)
 Scans all specified graphs asynchronously.
 
void ScanLoop (OnScanStatus statusCallback)
 Scans all graphs.
 
void UpdateGraphs (Bounds bounds, float delay)
 Update all graphs within bounds after delay seconds.
 
void UpdateGraphs (GraphUpdateObject ob, float delay)
 Update all graphs using the GraphUpdateObject after delay seconds.
 
void UpdateGraphs (Bounds bounds)
 Update all graphs within bounds.
 
void UpdateGraphs (GraphUpdateObject ob)
 Update all graphs using the GraphUpdateObject.
 

Static Public Member Functions

static void BlockUntilCalculated (Path p)
 Blocks until the path has been calculated.
 
static int CalculateThreadCount (ThreadCount count)
 Calculates number of threads to use.
 
static string[] FindTagNames ()
 Tries to find an AstarPath object and return tag names.
 
static void RegisterSafeUpdate (System.Action callback, bool threadSafe)
 Will send a callback when it is safe to update nodes.
 
static void RegisterSafeUpdate (System.Action callback)
 Will send a callback when it is safe to update nodes.
 
static void StartPath (Path p, bool pushToFront=false)
 Puts the Path in queue for calculation.
 
static void WaitForPath (Path p)
 Wait for the specified path to be calculated.
 

Public Attributes

AstarData data
 Holds all graph data.
 
EuclideanEmbedding euclideanEmbedding = new EuclideanEmbedding()
 Holds settings for heuristic optimization.
 
bool showGraphs = false
 Shows or hides graph inspectors.
 

Static Public Attributes

static AstarPath active
 Returns the active AstarPath object in the scene.
 
static readonly string Branch = "master_Pro"
 Which branch of the A* Pathfinding Project is this release.
 
static readonly AstarDistribution Distribution = AstarDistribution.WebsiteDownload
 Used by the editor to guide the user to the correct place to download updates.
 

Protected Member Functions

override void Awake ()
 Sets up all needed variables and scans the graphs.
 
- Protected Member Functions inherited from VersionedMonoBehaviour
virtual int OnUpgradeSerializedData (int version)
 Handle serialization backwards compatibility.
 

Package Functions

void DestroyNode (GraphNode node)
 Internal method to destroy a given node.
 
int GetNewNodeIndex ()
 Returns a new global node index.
 
ushort GetNextPathID ()
 Returns the next free path ID.
 
void InitializeNode (GraphNode node)
 Initializes temporary path data for a node.
 
void Log (string s)
 Logs a string while taking into account logPathResults.
 
void VerifyIntegrity ()
 Does simple error checking.
 

Properties

AstarData astarData [get]
 Holds all graph data.
 
NavGraph[] graphs [get]
 Shortcut to Pathfinding.AstarData.graphs.
 
System.Type[] graphTypes [get]
 See Pathfinding.AstarData.
 
bool IsAnyGraphUpdateInProgress [get]
 Returns if any graph updates are being calculated right now.
 
bool IsAnyGraphUpdateQueued [get]
 Returns if any graph updates are waiting to be applied.
 
bool IsAnyGraphUpdatesQueued [get]
 Returns if any graph updates are waiting to be applied.
 
bool IsAnyWorkItemInProgress [get]
 Returns if any work items are in progress right now.
 
bool isScanning [get, set]
 Set while any graphs are being scanned.
 
bool IsUsingMultithreading [get]
 Returns whether or not multithreading is used.
 
int NumParallelThreads [get]
 Number of parallel pathfinders.
 
static System.Version Version [get]
 The version number for the A* Pathfinding Project.
 

Private Member Functions

 AstarPath ()
 
IEnumerator DelayedGraphUpdate ()
 Waits a moment with updating graphs.
 
void InitializeAstarData ()
 Initializes the AstarData class.
 
void InitializePathProcessor ()
 Initializes the pathProcessor field.
 
void InitializeProfiler ()
 Calls AstarProfiler.InitializeFastProfile.
 
void LogPathResults (Path p)
 Prints path results to the log.
 
void OnApplicationQuit ()
 Terminates pathfinding threads when the application quits.
 
void OnDestroy ()
 Clears up variables and other stuff, destroys graphs.
 
void OnDisable ()
 Cleans up meshes to avoid memory leaks.
 
void OnDrawGizmos ()
 Calls OnDrawGizmos on graph generators.
 
void OnGUI ()
 Draws the InGame debugging (if enabled), also shows the fps if 'L' is pressed down.
 
PathProcessor.GraphUpdateLock PausePathfindingSoon ()
 Blocks the path queue so that e.g work items can be performed.
 
void PerformBlockingActions (bool force=false)
 
void RecalculateDebugLimits ()
 
IEnumerable< ProgressScanGraph (NavGraph graph)
 
void Update ()
 Checks if any work items need to be executed then runs pathfinding for a while (if not using multithreading because then the calculation happens in other threads) and then returns any calculated paths to the scripts that requested them.
 
IEnumerator UpdateGraphsInteral (GraphUpdateObject ob, float delay)
 Update all graphs using the GraphUpdateObject after delay seconds.
 

Private Attributes

Pathfinding.Util.RetainedGizmos gizmos = new Pathfinding.Util.RetainedGizmos()
 
bool graphUpdateRoutineRunning = false
 
readonly GraphUpdateProcessor graphUpdates
 Processes graph updates.
 
bool graphUpdatesWorkItemAdded = false
 Makes sure QueueGraphUpdates will not queue multiple graph update orders.
 
bool isScanningBacking
 Backing field for isScanning.
 
float lastGraphUpdate = -9999F
 Time the last graph update was done.
 
ushort nextFreePathID = 1
 The next unused Path ID.
 
PathProcessor pathProcessor
 Holds all paths waiting to be calculated and calculates them.
 
readonly PathReturnQueue pathReturnQueue
 Holds all completed paths waiting to be returned to where they were requested.
 
PathProcessor.GraphUpdateLock workItemLock
 Held if any work items are currently queued.
 
readonly WorkItemProcessor workItems
 Processes work items.
 

Static Private Attributes

static int waitForPathDepth = 0
 

Inspector - Debug

bool showNavGraphs = true
 Toggle for showing the gizmo debugging for the graphs in the scene view (editor only).
 
bool showUnwalkableNodes = true
 Toggle to show unwalkable nodes.
 
GraphDebugMode debugMode
 The mode to use for drawing nodes in the sceneview.
 
float debugFloor = 0
 Low value to use for certain debugMode modes.
 
float debugRoof = 20000
 High value to use for certain debugMode modes.
 
bool manualDebugFloorRoof = false
 If set, the debugFloor and debugRoof values will not be automatically recalculated.
 
bool showSearchTree = false
 If enabled, nodes will draw a line to their 'parent'.
 
float unwalkableNodeDebugSize = 0.3F
 Size of the red cubes shown in place of unwalkable nodes.
 
PathLog logPathResults = PathLog.Normal
 The amount of debugging messages.
 

Inspector - Settings

float maxNearestNodeDistanceSqr [get]
 Max Nearest Node Distance Squared.
 
bool limitGraphUpdates [get, set]
 Batch graph updates.
 
float maxGraphUpdateFreq [get, set]
 Limit for how often should graphs be updated.
 
float maxNearestNodeDistance = 100
 Max Nearest Node Distance.
 
bool scanOnStartup = true
 If true, all graphs will be scanned in Awake.
 
bool fullGetNearestSearch = false
 Do a full GetNearest search for all graphs.
 
bool prioritizeGraphs = false
 Prioritize graphs.
 
float prioritizeGraphsLimit = 1F
 Distance limit for prioritizeGraphs.
 
AstarColor colorSettings
 Reference to the color settings for this AstarPath object.
 
Heuristic heuristic = Heuristic.Euclidean
 The heuristic to use.
 
float heuristicScale = 1F
 The scale of the heuristic.
 
ThreadCount threadCount = ThreadCount.None
 Number of pathfinding threads to use.
 
float maxFrameTime = 1F
 Max number of milliseconds to spend each frame for pathfinding.
 
int minAreaSize = 0
 Defines the minimum amount of nodes in an area.
 
bool batchGraphUpdates = false
 Throttle graph updates and batch them to improve performance.
 
float graphUpdateBatchingInterval = 0.2F
 Limit for how often should graphs be updated.
 
string[] tagNames = null
 Stored tag names.
 

Debug Members

float lastScanTime [get, set]
 The time it took for the last call to Scan() to complete.
 
PathHandler debugPathData
 The path to debug using gizmos.
 
ushort debugPathID
 The path ID to debug using gizmos.
 
string inGameDebugPath
 Debug string from the last completed path.
 

Callbacks

static System.Action OnAwakeSettings
 Called on Awake before anything else is done.
 
static OnGraphDelegate OnGraphPreScan
 Called for each graph before they are scanned.
 
static OnGraphDelegate OnGraphPostScan
 Called for each graph after they have been scanned.
 
static OnPathDelegate OnPathPreSearch
 Called for each path before searching.
 
static OnPathDelegate OnPathPostSearch
 Called for each path after searching.
 
static OnScanDelegate OnPreScan
 Called before starting the scanning.
 
static OnScanDelegate OnPostScan
 Called after scanning.
 
static OnScanDelegate OnLatePostScan
 Called after scanning has completed fully.
 
static OnScanDelegate OnGraphsUpdated
 Called when any graphs are updated.
 
static System.Action On65KOverflow
 Called when pathID overflows 65536 and resets back to zero.
 
System.Action OnGraphsWillBeUpdated
 
System.Action OnGraphsWillBeUpdated2
 

Member Enumeration Documentation

Information about where the package was downloaded.

Enumerator:
WebsiteDownload 
AssetStore 

Constructor & Destructor Documentation

AstarPath ( )
private

Member Function Documentation

void AddWorkItem ( System.Action  callback)

Add a work item to be processed when pathfinding is paused.

Convenience method that is equivalent to

AddWorkItem(new AstarWorkItem(callback));
Examples:
MovePointNode.cs.
void AddWorkItem ( AstarWorkItem  item)

Add a work item to be processed when pathfinding is paused.

The work item will be executed when it is safe to update nodes. This is defined as between the path searches. When using more threads than one, calling this often might decrease pathfinding performance due to a lot of idling in the threads. Not performance as in it will use much CPU power, but performance as in the number of paths per second will probably go down (though your framerate might actually increase a tiny bit).

You should only call this function from the main unity thread (i.e normal game code).

var node = AstarPath.active.GetNearest (transform.position).node;
AstarPath.AddWorkItem (new AstarWorkItem((ctx) => {
node.walkable = false;
ctx.QueueFloodFill();
}));
var node = AstarPath.active.GetNearest (transform.position).node;
node.position = (Int3)transform.position;
});
See Also
ProcessWorkItems
FlushWorkItems
override void Awake ( )
protectedvirtual

Sets up all needed variables and scans the graphs.

Calls Initialize, starts the ReturnPaths coroutine and scans all graphs. Also starts threads if using multithreading

See Also
OnAwakeSettings

Reimplemented from VersionedMonoBehaviour.

static void BlockUntilCalculated ( Path  p)
static

Blocks until the path has been calculated.

Normally it takes a few frames for a path to be calculated and returned. This function will ensure that the path will be calculated when this function returns and that the callback for that path has been called.

If requesting a lot of paths in one go and waiting for the last one to complete, it will calculate most of the paths in the queue (only most if using multithreading, all if not using multithreading).

Use this function only if you really need to. There is a point to spreading path calculations out over several frames. It smoothes out the framerate and makes sure requesting a large number of paths at the same time does not cause lag.

Note
Graph updates and other callbacks might get called during the execution of this function.

When the pathfinder is shutting down. I.e in OnDestroy, this function will not do anything.

Parameters
pThe path to wait for. The path must be started, otherwise an exception will be thrown.
Exceptions
Exceptionif pathfinding is not initialized properly for this scene (most likely no AstarPath object exists) or if the path has not been started yet. Also throws an exception if critical errors occur such as when the pathfinding threads have crashed (which should not happen in normal cases). This prevents an infinite loop while waiting for the path.
See Also
Pathfinding.Path.WaitForPath
Pathfinding.Path.BlockUntilCalculated
void BlockUntilPathQueueBlocked ( )

Blocks until all pathfinding threads are paused and blocked.

Deprecated:
Use PausePathfinding instead. Make sure to call Release on the returned lock.
static int CalculateThreadCount ( ThreadCount  count)
static

Calculates number of threads to use.

If count is not Automatic, simply returns count casted to an int.

Returns
An int specifying how many threads to use, 0 means a coroutine should be used for pathfinding instead of a separate thread.

If count is set to Automatic it will return a value based on the number of processors and memory for the current system. If memory is <= 512MB or logical cores are <= 1, it will return 0. If memory is <= 1024 it will clamp threads to max 2. Otherwise it will return the number of logical cores clamped to 6.

When running on WebGL this method always returns 0

IEnumerator DelayedGraphUpdate ( )
private

Waits a moment with updating graphs.

If batchGraphUpdates is set, we want to keep some space between them to let pathfinding threads running and then calculate all queued calls at once

void DestroyNode ( GraphNode  node)
package

Internal method to destroy a given node.

This is to be called after the node has been disconnected from the graph so that it cannot be reached from any other nodes. It should only be called during graph updates, that is when the pathfinding threads are either not running or paused.

Warning
This method should not be called by user code. It is used internally by the system.
void EnsureValidFloodFill ( )

If a WorkItem needs to have a valid flood fill during execution, call this method to ensure there are no pending flood fills.

Deprecated:
This method has been moved. Use the method on the context object that can be sent with work item delegates instead
See Also
IWorkItemContext
static string [] FindTagNames ( )
static

Tries to find an AstarPath object and return tag names.

If an AstarPath object cannot be found, it returns an array of length 1 with an error message.

See Also
AstarPath.GetTagNames
void FloodFill ( GraphNode  seed)

Floodfills starting from the specified node.

void FloodFill ( GraphNode  seed,
uint  area 
)

Floodfills starting from 'seed' using the specified area.

void FloodFill ( )

Floodfills all graphs and updates areas for every node.

The different colored areas that you see in the scene view when looking at graphs are called just 'areas', this method calculates which nodes are in what areas.

See Also
Pathfinding.Node.area
void FlushGraphUpdates ( )

Forces graph updates to complete in a single frame.

This will force the pathfinding threads to finish calculating the path they are currently calculating (if any) and then pause. When all threads have paused, graph updates will be performed.

Warning
Using this very often (many times per second) can reduce your fps due to a lot of threads waiting for one another. But you probably wont have to worry about that.
Note
This is almost identical to FlushWorkItems, but added for more descriptive name. This function will also override any time limit delays for graph updates. This is because graph updates are implemented using work items. So calling this function will also execute any other work items (if any are queued).

Will not do anything if there are no graph updates queued (not even execute other work items).

void FlushThreadSafeCallbacks ( )

Forces thread safe callbacks to run.

Deprecated:
Use FlushWorkItems instead
void FlushWorkItems ( )

Forces work items to complete in a single frame.

This will force all work items to run immidiately. This will force the pathfinding threads to finish calculating the path they are currently calculating (if any) and then pause. When all threads have paused, work items will be executed (which can be e.g graph updates).

Warning
Using this very often (many times per second) can reduce your fps due to a lot of threads waiting for one another. But you probably wont have to worry about that
Note
This is almost (note almost) identical to FlushGraphUpdates, but added for more descriptive name.

Will not do anything if there are no queued work items waiting to run.

void FlushWorkItems ( bool  unblockOnComplete,
bool  block 
)

Make sure work items are executed.

Parameters
unblockOnCompleteIf true, pathfinding will be allowed to start running immediately after completing all work items.
blockIf true, work items that usually take more than one frame to complete will be forced to complete during this call. If false, then after this call there might still be work left to do.
See Also
AddWorkItem
Deprecated:
Use FlushWorkItems() instead.
NNInfo GetNearest ( Vector3  position)

Returns the nearest node to a position using the specified NNConstraint.

Searches through all graphs for their nearest nodes to the specified position and picks the closest one.
Using the NNConstraint.None constraint.

See Also
Pathfinding.NNConstraint
NNInfo GetNearest ( Vector3  position,
NNConstraint  constraint 
)

Returns the nearest node to a position using the specified NNConstraint.

Searches through all graphs for their nearest nodes to the specified position and picks the closest one. The NNConstraint can be used to specify constraints on which nodes can be chosen such as only picking walkable nodes.

See Also
Pathfinding.NNConstraint
NNInfo GetNearest ( Vector3  position,
NNConstraint  constraint,
GraphNode  hint 
)

Returns the nearest node to a position using the specified NNConstraint.

Searches through all graphs for their nearest nodes to the specified position and picks the closest one. The NNConstraint can be used to specify constraints on which nodes can be chosen such as only picking walkable nodes.

See Also
Pathfinding.NNConstraint
GraphNode GetNearest ( Ray  ray)

Returns the node closest to the ray (slow).

Warning
This function is brute-force and very slow, use with caution
int GetNewNodeIndex ( )
package

Returns a new global node index.

Warning
This method should not be called directly. It is used by the GraphNode constructor.
ushort GetNextPathID ( )
package

Returns the next free path ID.

string [] GetTagNames ( )

Returns tag names.

Makes sure that the tag names array is not null and of length 32. If it is null or not of length 32, it creates a new array and fills it with 0,1,2,3,4 etc...

See Also
AstarPath.FindTagNames
void InitializeAstarData ( )
private

Initializes the AstarData class.

Searches for graph types, calls Awake on data and on all graphs

See Also
AstarData.FindGraphTypes
void InitializeNode ( GraphNode  node)
package

Initializes temporary path data for a node.

Warning
This method should not be called directly. It is used by the GraphNode constructor.
void InitializePathProcessor ( )
private

Initializes the pathProcessor field.

void InitializeProfiler ( )
private

Calls AstarProfiler.InitializeFastProfile.

void Log ( string  s)
package

Logs a string while taking into account logPathResults.

void LogPathResults ( Path  p)
private

Prints path results to the log.

What it prints can be controled using logPathResults.

See Also
logPathResults
PathLog
Pathfinding.Path.DebugString
void OnApplicationQuit ( )
private

Terminates pathfinding threads when the application quits.

void OnDestroy ( )
private

Clears up variables and other stuff, destroys graphs.

Note that when destroying an AstarPath object, all static variables such as callbacks will be cleared.

void OnDisable ( )
private

Cleans up meshes to avoid memory leaks.

void OnDrawGizmos ( )
private

Calls OnDrawGizmos on graph generators.

void OnGUI ( )
private

Draws the InGame debugging (if enabled), also shows the fps if 'L' is pressed down.

See Also
logPathResults PathLog
PathProcessor.GraphUpdateLock PausePathfinding ( )

Blocks until all pathfinding threads are paused and blocked.

var graphLock = AstarPath.active.PausePathfinding();
// Here we can modify the graphs safely. For example by adding a new node to a point graph
var node = AstarPath.active.data.pointGraph.AddNode(new Vector3(3,1,4));
// Allow pathfinding to resume
graphLock.Release();
Returns
A lock object. You need to call Unlock on that object to allow pathfinding to resume.
Note
In most cases this should not be called from user code.
See Also
AddWorkItem
RegisterSafeUpdate
PathProcessor.GraphUpdateLock PausePathfindingSoon ( )
private

Blocks the path queue so that e.g work items can be performed.

void PerformBlockingActions ( bool  force = false)
private
void QueueGraphUpdates ( )

Will apply queued graph updates as soon as possible, regardless of batchGraphUpdates.

Calling this multiple times will not create multiple callbacks. Makes sure DoUpdateGraphs is called as soon as possible.
This function is useful if you are limiting graph updates, but you want a specific graph update to be applied as soon as possible regardless of the time limit.

See Also
FlushGraphUpdates
void QueueWorkItemFloodFill ( )

Call during work items to queue a flood fill.

Deprecated:
This method has been moved. Use the method on the context object that can be sent with work item delegates instead
See Also
IWorkItemContext
void RecalculateDebugLimits ( )
private
static void RegisterSafeUpdate ( System.Action  callback,
bool  threadSafe 
)
static

Will send a callback when it is safe to update nodes.

This is defined as between the path searches. This callback will only be sent once and is nulled directly after the callback has been sent. When using more threads than one, calling this often might decrease pathfinding performance due to a lot of idling in the threads. Not performance as in it will use much CPU power, but performance as in the number of paths per second will probably go down (though your framerate might actually increase a tiny bit)

You should only call this function from the main unity thread (i.e normal game code).

Note
The threadSafe parameter has been deprecated
Deprecated:
static void RegisterSafeUpdate ( System.Action  callback)
static

Will send a callback when it is safe to update nodes.

This is defined as between the path searches. This callback will only be sent once and is nulled directly after the callback has been sent. When using more threads than one, calling this often might decrease pathfinding performance due to a lot of idling in the threads. Not performance as in it will use much CPU power, but performance as in the number of paths per second will probably go down (though your framerate might actually increase a tiny bit)

You should only call this function from the main unity thread (i.e normal game code).

var node = AstarPath.active.GetNearest (transform.position).node;
node.walkable = false;
});
var node = AstarPath.active.GetNearest (transform.position).node;
node.position = (Int3)transform.position;
});
Version
Since version 4.0 this is equivalent to AddWorkItem(new AstarWorkItem(callback)). Previously the callbacks added using this method would not be ordered with respect to other work items, so they could be executed before other work items or after them.
Deprecated:
Use AddWorkItem(System.Action) instead. Note the slight change in behavior (mentioned above).
void Scan ( NavGraph  graphToScan)

Scans a particular graph.

Calling this method will recalculate the specified graph. This method is pretty slow (depending on graph type and graph complexity of course), so it is advisable to use smaller graph updates whenever possible.

See Also
Graph Updates during Runtime
ScanAsync
void Scan ( NavGraph[]  graphsToScan = null)

Scans all specified graphs.

Calling this method will recalculate all specified graphs or all graphs if the graphsToScan parameter is null. This method is pretty slow (depending on graph type and graph complexity of course), so it is advisable to use smaller graph updates whenever possible.

See Also
Graph Updates during Runtime
ScanAsync
Parameters
graphsToScanThe graphs to scan. If this parameter is null then all graphs will be scanned
IEnumerable<Progress> ScanAsync ( NavGraph  graphToScan)

Scans a particular graph asynchronously.

This is a IEnumerable, you can loop through it to get the progress

foreach (Progress progress in AstarPath.active.ScanAsync ()) {
Debug.Log ("Scanning... " + progress.description + " - " + (progress.progress*100).ToString ("0") + "%");
}

You can scan graphs asyncronously by yielding when you loop through the progress. Note that this does not guarantee a good framerate, but it will allow you to at least show a progress bar during scanning.

IEnumerator Start () {
foreach (Progress progress in AstarPath.active.ScanAsync ()) {
Debug.Log ("Scanning... " + progress.description + " - " + (progress.progress*100).ToString ("0") + "%");
yield return null;
}
}
See Also
Scan
A* Pro Feature:
This is an A* Pathfinding Project Pro feature only. This function/class/variable might not exist in the Free version of the A* Pathfinding Project or the functionality might be limited
The Pro version can be bought here
IEnumerable<Progress> ScanAsync ( NavGraph[]  graphsToScan = null)

Scans all specified graphs asynchronously.

This is a IEnumerable, you can loop through it to get the progress

foreach (Progress progress in AstarPath.active.ScanAsync ()) {
Debug.Log ("Scanning... " + progress.description + " - " + (progress.progress*100).ToString ("0") + "%");
}

You can scan graphs asyncronously by yielding when you loop through the progress. Note that this does not guarantee a good framerate, but it will allow you to at least show a progress bar during scanning.

IEnumerator Start () {
foreach (Progress progress in AstarPath.active.ScanAsync ()) {
Debug.Log ("Scanning... " + progress.description + " - " + (progress.progress*100).ToString ("0") + "%");
yield return null;
}
}
See Also
Scan
A* Pro Feature:
This is an A* Pathfinding Project Pro feature only. This function/class/variable might not exist in the Free version of the A* Pathfinding Project or the functionality might be limited
The Pro version can be bought here
Parameters
graphsToScanThe graphs to scan. If this parameter is null then all graphs will be scanned
IEnumerable<Progress> ScanGraph ( NavGraph  graph)
private
void ScanLoop ( OnScanStatus  statusCallback)

Scans all graphs.

Deprecated:
Use Scan or ScanAsync instead
See Also
Scan
static void StartPath ( Path  p,
bool  pushToFront = false 
)
static

Puts the Path in queue for calculation.

The callback specified when constructing the path will be called when the path has been calculated. Usually you should use the Seeker component instead of calling this function directly.

Parameters
pThe path that should be put in queue for calculation
pushToFrontIf true, the path will be pushed to the front of the queue, bypassing all waiting paths and making it the next path to be calculated. This can be useful if you have a path which you want to prioritize over all others. Be careful to not overuse it though. If too many paths are put in the front of the queue often, this can lead to normal paths having to wait a very long time before being calculated.
Examples:
MultiTargetFree.cs, and WaypointPath.cs.
void Update ( )
private

Checks if any work items need to be executed then runs pathfinding for a while (if not using multithreading because then the calculation happens in other threads) and then returns any calculated paths to the scripts that requested them.

See Also
PerformBlockingActions
PathProcessor.TickNonMultithreaded
PathReturnQueue.ReturnPaths
void UpdateGraphs ( Bounds  bounds,
float  delay 
)

Update all graphs within bounds after delay seconds.

The graphs will be updated as soon as possible.

See Also
FlushGraphUpdates
batchGraphUpdates
Graph Updates during Runtime
void UpdateGraphs ( GraphUpdateObject  ob,
float  delay 
)

Update all graphs using the GraphUpdateObject after delay seconds.

This can be used to, e.g make all nodes in an area unwalkable, or set them to a higher penalty.

See Also
FlushGraphUpdates
batchGraphUpdates
Graph Updates during Runtime
void UpdateGraphs ( Bounds  bounds)

Update all graphs within bounds.

The graphs will be updated as soon as possible.

This is equivalent to

UpdateGraphs (new GraphUpdateObject (bounds))
See Also
FlushGraphUpdates
batchGraphUpdates
Graph Updates during Runtime
void UpdateGraphs ( GraphUpdateObject  ob)

Update all graphs using the GraphUpdateObject.

This can be used to, e.g make all nodes in an area unwalkable, or set them to a higher penalty. The graphs will be updated as soon as possible (with respect to batchGraphUpdates)

See Also
FlushGraphUpdates
batchGraphUpdates
Graph Updates during Runtime
IEnumerator UpdateGraphsInteral ( GraphUpdateObject  ob,
float  delay 
)
private

Update all graphs using the GraphUpdateObject after delay seconds.

void VerifyIntegrity ( )
package

Does simple error checking.

static void WaitForPath ( Path  p)
static

Wait for the specified path to be calculated.

Normally it takes a few frames for a path to get calculated and returned.

Deprecated:
This method has been renamed to BlockUntilCalculated.

Member Data Documentation

AstarPath active
static

Returns the active AstarPath object in the scene.

Note
This is only set if the AstarPath object has been initialized (which happens in Awake).
Examples:
MovePointNode.cs.
bool batchGraphUpdates = false

Throttle graph updates and batch them to improve performance.

If toggled, graph updates will batched and executed less often (specified by graphUpdateBatchingInterval).

This can have a positive impact on pathfinding throughput since the pathfinding threads do not need to be stopped as often, and it reduces the overhead per graph update. All graph updates are still applied however, they are just batched together so that more of them are applied at the same time.

However do not use this if you want minimal latency between a graph update being requested and it being applied.

This only applies to graph updates requested using the UpdateGraphs method. Not those requested using RegisterSafeUpdate or AddWorkItem.

See Also
Graph Updates during Runtime
readonly string Branch = "master_Pro"
static

Which branch of the A* Pathfinding Project is this release.

Used when checking for updates so that users of the development versions can get notifications of development updates.

AstarColor colorSettings

Reference to the color settings for this AstarPath object.

Color settings include for example which color the nodes should be in, in the sceneview.

AstarData data

Holds all graph data.

float debugFloor = 0

Low value to use for certain debugMode modes.

For example if debugMode is set to G, this value will determine when the node will be totally red.

Note
Only relevant in the editor
See Also
debugRoof
GraphDebugMode debugMode

The mode to use for drawing nodes in the sceneview.

Note
Only relevant in the editor
See Also
Pathfinding.GraphDebugMode
PathHandler debugPathData

The path to debug using gizmos.

This is the path handler used to calculate the last path. It is used in the editor to draw debug information using gizmos.

ushort debugPathID

The path ID to debug using gizmos.

float debugRoof = 20000

High value to use for certain debugMode modes.

For example if debugMode is set to G, this value will determine when the node will be totally green.

For the penalty debug mode, the nodes will be colored green when they have a penalty of zero and red when their penalty is greater or equal to this value and something between red and green for values in between.

Note
Only relevant in the editor
See Also
debugFloor
readonly AstarDistribution Distribution = AstarDistribution.WebsiteDownload
static

Used by the editor to guide the user to the correct place to download updates.

EuclideanEmbedding euclideanEmbedding = new EuclideanEmbedding()

Holds settings for heuristic optimization.

See Also
heuristic-opt
A* Pro Feature:
This is an A* Pathfinding Project Pro feature only. This function/class/variable might not exist in the Free version of the A* Pathfinding Project or the functionality might be limited
The Pro version can be bought here
bool fullGetNearestSearch = false

Do a full GetNearest search for all graphs.

Additional searches will normally only be done on the graph which in the first fast search seemed to have the closest node. With this setting on, additional searches will be done on all graphs since the first check is not always completely accurate.
More technically: GetNearestForce on all graphs will be called if true, otherwise only on the one graph which's GetNearest search returned the best node.
Usually faster when disabled, but higher quality searches when enabled. When using a a navmesh or recast graph, for best quality, this setting should be combined with the Pathfinding.NavMeshGraph.accurateNearestNode setting set to true.

Note
For the PointGraph this setting doesn't matter much as it has only one search mode.
float graphUpdateBatchingInterval = 0.2F

Limit for how often should graphs be updated.

If batchGraphUpdates is true, this defines the minimum number of seconds between each graph update.

This can have a positive impact on pathfinding throughput since the pathfinding threads do not need to be stopped as often, and it reduces the overhead per graph update. All graph updates are still applied however, they are just batched together so that more of them are applied at the same time.

However do not use this if you want minimal latency between a graph update being requested and it being applied.

This only applies to graph updates requested using the UpdateGraphs method. Not those requested using RegisterSafeUpdate or AddWorkItem.

See Also
Graph Updates during Runtime
bool graphUpdateRoutineRunning = false
private
readonly GraphUpdateProcessor graphUpdates
private

Processes graph updates.

bool graphUpdatesWorkItemAdded = false
private

Makes sure QueueGraphUpdates will not queue multiple graph update orders.

Heuristic heuristic = Heuristic.Euclidean

The heuristic to use.

The heuristic, often referred to as 'H' is the estimated cost from a node to the target. Different heuristics affect how the path picks which one to follow from multiple possible with the same length

See Also
Pathfinding.Heuristic
float heuristicScale = 1F

The scale of the heuristic.

If a smaller value than 1 is used, the pathfinder will search more nodes (slower). If 0 is used, the pathfinding will be equal to dijkstra's algorithm. If a value larger than 1 is used the pathfinding will (usually) be faster because it expands fewer nodes, but the paths might not longer be optimal

string inGameDebugPath
private

Debug string from the last completed path.

Will be updated if logPathResults == PathLog.InGame

bool isScanningBacking
private

Backing field for isScanning.

Cannot use an auto-property because they cannot be marked with System.NonSerialized.

float lastGraphUpdate = -9999F
private

Time the last graph update was done.

Used to group together frequent graph updates to batches

PathLog logPathResults = PathLog.Normal

The amount of debugging messages.

Use less debugging to improve performance (a bit) or just to get rid of the Console spamming.
Use more debugging (heavy) if you want more information about what the pathfinding is doing.
InGame will display the latest path log using in game GUI.

bool manualDebugFloorRoof = false

If set, the debugFloor and debugRoof values will not be automatically recalculated.

Note
Only relevant in the editor
float maxFrameTime = 1F

Max number of milliseconds to spend each frame for pathfinding.

At least 500 nodes will be searched each frame (if there are that many to search). When using multithreading this value is quite irrelevant, but do not set it too low since that could add upp to some overhead, 10ms will work good for multithreading

float maxNearestNodeDistance = 100

Max Nearest Node Distance.

When searching for a nearest node, this is the limit (world units) for how far away it is allowed to be.

See Also
Pathfinding.NNConstraint.constrainDistance
int minAreaSize = 0

Defines the minimum amount of nodes in an area.

If an area has less than this amount of nodes, the area will be flood filled again with the area ID GraphNode.MaxAreaIndex-1, it shouldn't affect pathfinding in any significant way.
If you want to be able to separate areas from one another for some reason (for example to do a fast check to see if a path is at all possible) you should set this variable to 0.

Version
Since version 3.6, this variable should in most cases be set to 0 since the max number of area indices available has been greatly increased.
Deprecated:
This is handled automatically now
ushort nextFreePathID = 1
private

The next unused Path ID.

Incremented for every call to GetNextPathID

System.Action On65KOverflow
static

Called when pathID overflows 65536 and resets back to zero.

Note
This callback will be cleared every time it is called, so if you want to register to it repeatedly, register to it directly on receiving the callback as well.
System.Action OnAwakeSettings
static

Called on Awake before anything else is done.

This is called at the start of the Awake call, right after active has been set, but this is the only thing that has been done.
Use this when you want to set up default settings for an AstarPath component created during runtime since some settings can only be changed in Awake (such as multithreading related stuff)

//Create a new AstarPath object on Start and apply some default settings
public void Start () {
AstarPath.OnAwakeSettings += ApplySettings;
AstarPath astar = AddComponent<AstarPath>();
}
public void ApplySettings () {
//Unregister from the delegate
AstarPath.OnAwakeSettings -= ApplySettings;
//For example threadCount should not be changed after the Awake call
//so here's the only place to set it if you create the component during runtime
}
OnGraphDelegate OnGraphPostScan
static

Called for each graph after they have been scanned.

All other graphs might not have been scanned yet.

OnGraphDelegate OnGraphPreScan
static

Called for each graph before they are scanned.

OnScanDelegate OnGraphsUpdated
static

Called when any graphs are updated.

Register to for example recalculate the path whenever a graph changes.

System.Action OnGraphsWillBeUpdated
System.Action OnGraphsWillBeUpdated2
OnScanDelegate OnLatePostScan
static

Called after scanning has completed fully.

This is called as the last thing in the Scan function.

OnPathDelegate OnPathPostSearch
static

Called for each path after searching.

Be careful when using multithreading since this will be called from a different thread.

OnPathDelegate OnPathPreSearch
static

Called for each path before searching.

Be careful when using multithreading since this will be called from a different thread.

OnScanDelegate OnPostScan
static

Called after scanning.

This is called before applying links, flood-filling the graphs and other post processing.

OnScanDelegate OnPreScan
static

Called before starting the scanning.

PathProcessor pathProcessor
private

Holds all paths waiting to be calculated and calculates them.

readonly PathReturnQueue pathReturnQueue
private

Holds all completed paths waiting to be returned to where they were requested.

bool prioritizeGraphs = false

Prioritize graphs.

Graphs will be prioritized based on their order in the inspector. The first graph which has a node closer than prioritizeGraphsLimit will be chosen instead of searching all graphs.

float prioritizeGraphsLimit = 1F

Distance limit for prioritizeGraphs.

See Also
prioritizeGraphs
bool scanOnStartup = true

If true, all graphs will be scanned in Awake.

This does not include loading from the cache. If you disable this, you will have to call AstarPath.active.Scan () yourself to enable pathfinding. Alternatively you could load a saved graph from a file.

bool showGraphs = false

Shows or hides graph inspectors.

Used internally by the editor

bool showNavGraphs = true

Toggle for showing the gizmo debugging for the graphs in the scene view (editor only).

bool showSearchTree = false

If enabled, nodes will draw a line to their 'parent'.

This will show the search tree for the latest path.

Note
Only relevant in the editor
Todo:
Add a showOnlyLastPath flag to indicate whether to draw every node or only the ones visited by the latest path.
bool showUnwalkableNodes = true

Toggle to show unwalkable nodes.

Note
Only relevant in the editor
See Also
unwalkableNodeDebugSize
string [] tagNames = null
protected

Stored tag names.

See Also
AstarPath.FindTagNames
AstarPath.GetTagNames
ThreadCount threadCount = ThreadCount.None

Number of pathfinding threads to use.

Multithreading puts pathfinding in another thread, this is great for performance on 2+ core computers since the framerate will barely be affected by the pathfinding at all.

  • None indicates that the pathfinding is run in the Unity thread as a coroutine
  • Automatic will try to adjust the number of threads to the number of cores and memory on the computer. Less than 512mb of memory or a single core computer will make it revert to using no multithreading.

It is recommended that you use one of the "Auto" settings that are available. The reason is that even if your computer might be beefy and have 8 cores. Other computers might only be quad core or dual core in which case they will not benefit from more than 1 or 3 threads respectively (you usually want to leave one core for the unity thread). If you use more threads than the number of cores on the computer it is mostly just wasting memory, it will not run any faster. The extra memory usage is not trivially small. Each thread needs to keep a small amount of data for each node in all the graphs. It is not the full graph data but it is proportional to the number of nodes. The automatic settings will inspect the machine it is running on and use that to determine the number of threads so that no memory is wasted.

The exception is if you only have one (or maybe two characters) active at time. Then you should probably just go with one thread always since it is very unlikely that you will need the extra throughput given by more threads. Keep in mind that more threads primarily increases throughput by calculating different paths on different threads, it will not calculate individual paths any faster.

Note that if you are modifying the pathfinding core scripts or if you are directly modifying graph data without using any of the safe wrappers (like RegisterSafeUpdate) multithreading can cause strange errors and pathfinding stopping to work if you are not careful. For basic usage (not modding the pathfinding core) it should be safe.

Note
WebGL does not support threads at all (since javascript is single-threaded)
See Also
CalculateThreadCount
A* Pro Feature:
This is an A* Pathfinding Project Pro feature only. This function/class/variable might not exist in the Free version of the A* Pathfinding Project or the functionality might be limited
The Pro version can be bought here
float unwalkableNodeDebugSize = 0.3F

Size of the red cubes shown in place of unwalkable nodes.

Note
Only relevant in the editor. Does not apply to grid graphs.
See Also
showUnwalkableNodes
int waitForPathDepth = 0
staticprivate
PathProcessor.GraphUpdateLock workItemLock
private

Held if any work items are currently queued.

readonly WorkItemProcessor workItems
private

Processes work items.

Property Documentation

AstarData astarData
get

Holds all graph data.

Deprecated:
The 'astarData' field has been renamed to 'data'
NavGraph [] graphs
get
System.Type [] graphTypes
get
bool IsAnyGraphUpdateInProgress
get

Returns if any graph updates are being calculated right now.

Note
This does *not* includes other types of work items such as navmesh cutting or anything added by RegisterSafeUpdate or AddWorkItem.
See Also
IsAnyWorkItemInProgress
bool IsAnyGraphUpdateQueued
get

Returns if any graph updates are waiting to be applied.

Note
This is false while the updates are being performed.
This does *not* includes other types of work items such as navmesh cutting or anything added by RegisterSafeUpdate or AddWorkItem.
bool IsAnyGraphUpdatesQueued
get

Returns if any graph updates are waiting to be applied.

Deprecated:
Use IsAnyGraphUpdateQueued instead
bool IsAnyWorkItemInProgress
get

Returns if any work items are in progress right now.

Note
This includes pretty much all types of graph updates. Such as normal graph updates, navmesh cutting and anything added by RegisterSafeUpdate or AddWorkItem.
bool isScanning
getset

Set while any graphs are being scanned.

It will be true up until the FloodFill is done.

Note
Not to be confused with graph updates.

Used to better support Graph Update Objects called for example in OnPostScan

See Also
IsAnyGraphUpdateQueued
IsAnyGraphUpdateInProgress
bool IsUsingMultithreading
get

Returns whether or not multithreading is used.

Exceptions
System.ExceptionIs thrown when it could not be decided if multithreading was used or not. This should not happen if pathfinding is set up correctly.
Note
This uses info about if threads are running right now, it does not use info from the settings on the A* object.
float lastScanTime
getset

The time it took for the last call to Scan() to complete.

Used to prevent automatically rescanning the graphs too often (editor only)

bool limitGraphUpdates
getset

Batch graph updates.

Deprecated:
This field has been renamed to batchGraphUpdates.
float maxGraphUpdateFreq
getset

Limit for how often should graphs be updated.

Deprecated:
This field has been renamed to graphUpdateBatchingInterval.
float maxNearestNodeDistanceSqr
get

Max Nearest Node Distance Squared.

See Also
maxNearestNodeDistance
int NumParallelThreads
get

Number of parallel pathfinders.

Returns the number of concurrent processes which can calculate paths at once. When using multithreading, this will be the number of threads, if not using multithreading it is always 1 (since only 1 coroutine is used).

See Also
threadInfos
IsUsingMultithreading
System.Version Version
staticget

The version number for the A* Pathfinding Project.


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