Class AstarPath Extends VersionedMonoBehaviour

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));


void AddWorkItem (

System.Action<IWorkItemContext>

callback

)

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

Convenience method that is equivalent to AddWorkItem(new AstarWorkItem(callback));


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

AstarPath.active.AddWorkItem(new AstarWorkItem(() => {
// Safe to update graphs here
var node = AstarPath.active.GetNearest(transform.position).node;
node.Walkable = false;
}));
AstarPath.active.AddWorkItem(() => {
// Safe to update graphs here
var node = AstarPath.active.GetNearest(transform.position).node;
node.position = (Int3)transform.position;
});


Unity.Jobs.JobHandle AllocateNodes<T> (

T[]	result	Node array to fill
int	count	How many nodes to allocate
System.Func<T>	createNode	Delegate which creates a node. () => new T(). Note that new T(AstarPath.active) should *not* be used as that will cause the node to be initialized twice.
uint	variantsPerNode	How many variants of the node to allocate. Should be the same as GraphNode.PathNodeVariants for this node type.

)

Allocate a bunch of nodes at once.

This is faster than allocating each individual node separately and it can be done in a separate thread by using jobs.

var nodes = new PointNode[128];
var job = AstarPath.active.AllocateNodes(nodes, 128, () => new PointNode(), 1);

job.Complete();


void DrawGizmos ()

Calls OnDrawGizmos on graph generators.

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.

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

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

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

NavmeshEdges.NavmeshBorderData GetNavmeshBorderData (

outRWLock.CombinedReadLockAsync

readLock

)

Obstacle data for navmesh edges.

This can be used to get information about the edge/borders of the navmesh. It can also be queried in burst jobs. Just make sure you release the read lock after you are done with it.

NNInfo GetNearest (

Vector3

position

)

Returns the nearest node to a position.

This method will search through all graphs and query them for the closest node to this position, and then it will return the closest one of those.

Equivalent to GetNearest(position, NNConstraint.None).

// Find the closest node to this GameObject's position
GraphNode node = AstarPath.active.GetNearest(transform.position).node;

if (node.Walkable) {
// Yay, the node is walkable, we can place a tower here or something
}


NNInfo GetNearest (

Vector3	position	The point to find nodes close to
NNConstraint	constraint	The constraint which determines which graphs and nodes are acceptable to search on. May be null, in which case all nodes will be considered acceptable.

)

Returns the nearest node to a point 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.

GraphNode node = AstarPath.active.GetNearest(transform.position, NNConstraint.Walkable).node;
var constraint = NNConstraint.None;

// Constrain the search to walkable nodes only
constraint.constrainWalkability = true;
constraint.walkable = true;

// Constrain the search to only nodes with tag 3 or tag 5
// The 'tags' field is a bitmask
constraint.constrainTags = true;
constraint.tags = (1 << 3) | (1 << 5);

var info = AstarPath.active.GetNearest(transform.position, constraint);
var node = info.node;
var closestPoint = info.position;


GraphNode GetNearest (

Ray

ray

)

Returns the node closest to the ray (slow).

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

RWLock.ReadLockAsync LockGraphDataForReading ()

Allows you to access read-only graph data in jobs safely.

You can for example use AstarPath.active.GetNearest(...) in a job.

Using AstarPath.StartPath is always safe to use in jobs even without calling this method.

When a graph update, work item, or graph scan would start, it will first block on the given dependency to ensure no race conditions occur.

If you do not call this method, then a graph update might start in the middle of your job, causing race conditions and all manner of other hard-to-diagnose bugs.

var readLock = AstarPath.active.LockGraphDataForReading();
var handle = new MyJob {
// ...
}.Schedule(readLock.dependency);
readLock.UnlockAfter(handle);


RWLock.WriteLockAsync LockGraphDataForWriting ()

Aquires an exclusive lock on the graph data asynchronously.

This is used when graphs want to modify graph data.

This is a low-level primitive, usually you do not need to use this method.

var readLock = AstarPath.active.LockGraphDataForReading();
var handle = new MyJob {
// ...
}.Schedule(readLock.dependency);
readLock.UnlockAfter(handle);


RWLock.LockSync LockGraphDataForWritingSync ()

Aquires an exclusive lock on the graph data.

This is used when graphs want to modify graph data.

This is a low-level primitive, usually you do not need to use this method.

var readLock = AstarPath.active.LockGraphDataForReading();
var handle = new MyJob {
// ...
}.Schedule(readLock.dependency);
readLock.UnlockAfter(handle);


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 increasing the penalty of a node
AstarPath.active.data.gridGraph.GetNode(0, 0).Penalty += 1000;

// Allow pathfinding to resume
graphLock.Release();


PathProcessor.GraphUpdateLock PausePathfindingSoon ()

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

Pathfinding threads will stop accepting new path requests and will finish the ones they are currently calculating asynchronously. When the lock is released, the pathfinding threads will resume as normal.

void QueueGraphUpdates ()

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

Calling this multiple times will not create multiple callbacks. 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. Note that this does not block until the updates are done, it merely bypasses the batchGraphUpdates time limit.

void Scan (

NavGraph

graphToScan

)

Scans a particular graph.

Calling this method will recalculate the specified graph from scratch. 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.

// Recalculate all graphs
AstarPath.active.Scan();

// Recalculate only the first grid graph
var graphToScan = AstarPath.active.data.gridGraph;
AstarPath.active.Scan(graphToScan);

// Recalculate only the first and third graphs
var graphsToScan = new [] { AstarPath.active.data.graphs[0], AstarPath.active.data.graphs[2] };
AstarPath.active.Scan(graphsToScan);


void Scan (

NavGraph[]

graphsToScan=null

The graphs to scan. If this parameter is null then all graphs will be scanned

)

Scans all specified graphs.

Calling this method will recalculate all specified graphs (or all graphs if the graphsToScan parameter is null) from scratch. 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.

// Recalculate all graphs
AstarPath.active.Scan();

// Recalculate only the first grid graph
var graphToScan = AstarPath.active.data.gridGraph;
AstarPath.active.Scan(graphToScan);

// Recalculate only the first and third graphs
var graphsToScan = new [] { AstarPath.active.data.graphs[0], AstarPath.active.data.graphs[2] };
AstarPath.active.Scan(graphsToScan);


IEnumerable<Progress> ScanAsync (

NavGraph

graphToScan

)

Scans a particular graph asynchronously.

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

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

IEnumerator Start () {
foreach (Progress progress in AstarPath.active.ScanAsync()) {
Debug.Log("Scanning... " + progress.ToString());
yield return null;
}
}


IEnumerable<Progress> ScanAsync (

NavGraph[]

graphsToScan=null

The graphs to scan. If this parameter is null then all graphs will be scanned

)

Scans all specified graphs asynchronously.

This is a IEnumerable, you can loop through it to get the progress 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.ToString());
yield return null;
}
}


GraphSnapshot Snapshot (

Bounds	bounds
GraphMask	graphMask

)

Captures a snapshot of a part of the graphs, to allow restoring it later.

This is useful if you want to do a graph update, but you want to be able to restore the graph to the previous state.

The snapshot will capture enough information to restore the graphs, assuming the world only changed within the given bounding box. This means the captured region may be larger than the bounding box.

Limitations:

• Currently, the GridGraph and LayerGridGraph supports snapshots. Other graph types do not support it.

• The graph must not change its dimensions or other core parameters between the time the snapshot is taken and the time it is restored.

• Custom node connections may not be preserved. Unless they are added as off-mesh links using e.g. a NodeLink2 component.

• The snapshot must not be captured during a work item, graph update or when the graphs are being scanned, as the graphs may not be in a consistent state during those times.

void UpdateGraphs (

Bounds	bounds
float	delay

)

Update all graphs within bounds after delay seconds.

The graphs will be updated as soon as possible.

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 a region unwalkable, or set them to a higher penalty.

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));


void UpdateGraphs (

GraphUpdateObject

ob

)

Update all graphs using the GraphUpdateObject.

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

void BlockUntilCalculated (

Path

path

The path to wait for. The path must be started, otherwise an exception will be thrown.

)

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.

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

int CalculateThreadCount (

ThreadCount

count

)

Calculates number of threads to use.

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

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

void FindAstarPath ()

Used outside of play mode to initialize the AstarPath object even if it has not been selected in the inspector yet.

This will set the active property and deserialize all graphs.

This is useful if you want to do changes to the graphs in the editor outside of play mode, but cannot be sure that the graphs have been deserialized yet. In play mode this method does nothing.

string[] FindTagNames ()

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.

void StartPath (

Path	path	The path that should be enqueued.
bool	pushToFront=false	If 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.
bool	assumeInPlayMode=false	Typically path.BlockUntilCalculated will be called when not in play mode. However, the play mode check will not work if you call this from a separate thread, or a job. In that case you can set this to true to skip the check.

)

Adds the path to a queue so that it will be calculated as soon as possible.

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.

// There must be an AstarPath instance in the scene
if (AstarPath.active == null) return;

// We can calculate multiple paths asynchronously
for (int i = 0; i < 10; i++) {
var path = ABPath.Construct(transform.position, transform.position+transform.forward*i*10, OnPathComplete);

// Calculate the path by using the AstarPath component directly
AstarPath.StartPath(path);
}


bool IsAnyGraphUpdateInProgress

Returns if any graph updates are being calculated right now.

bool IsAnyGraphUpdateQueued

Returns if any graph updates are waiting to be applied.

bool IsAnyWorkItemInProgress

Returns if any work items are in progress right now.

bool IsUsingMultithreading

Returns whether or not multithreading is used.

int NumParallelThreads

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

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

If you want to apply graph updates immediately at some point, you can call FlushGraphUpdates.

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 completely red.

GraphDebugMode debugMode

The mode to use for drawing nodes in the sceneview.

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 completely green.

For the penalty debug mode, the nodes will be colored green when they have a penalty less than debugFloor and red when their penalty is greater or equal to this value and something between red and green otherwise.

EuclideanEmbedding euclideanEmbedding = new EuclideanEmbedding()

Holds settings for heuristic optimization.

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.

float graphUpdateBatchingInterval = 0.2F

Minimum number of seconds between each batch of graph updates.

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

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.

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

NavGraph[] graphs

Shortcut to Pathfinding.AstarData.graphs.

Heuristic heuristic = Heuristic.Euclidean

The distance function to use as a heuristic.

The heuristic, often referred to as just '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

float heuristicScale = 1F

The scale of the heuristic.

If a value lower than 1 is used, the pathfinder will search more nodes (slower). If 0 is used, the pathfinding algorithm will be reduced to dijkstra's algorithm. This is equivalent to setting heuristic to None. If a value larger than 1 is used the pathfinding will (usually) be faster because it expands fewer nodes, but the paths may no longer be the optimal (i.e the shortest possible paths).

Usually you should leave this to the default value of 1.

bool isScanning

Set while any graphs are being scanned.

It will be true up until the FloodFill is done.

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

float lastScanTime

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

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

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 scripts are doing. The InGame option 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.

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

float maxNearestNodeDistance = 100

Maximum distance to search for nodes.

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

This is relevant if you try to request a path to a point that cannot be reached and it thus has to search for the closest node to that point which can be reached (which might be far away). If it cannot find a node within this distance then the path will fail.

float maxNearestNodeDistanceSqr

Max Nearest Node Distance Squared.

NavmeshUpdates navmeshUpdates = new NavmeshUpdates()

Handles navmesh cuts.

OffMeshLinks offMeshLinks

Holds all active off-mesh links.

bool scanOnStartup = true

If true, all graphs will be scanned during Awake.

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.

If a startup cache has been generated (see Saving and Loading Graphs), it always takes priority to load that instead of scanning the graphs.

This can be useful to enable if you want to scan your graphs asynchronously, or if you have a procedural world which has not been created yet at the start of the game.

bool showGraphs = false

Shows or hides graph inspectors.

Used internally by the editor

bool showNavGraphs = true

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

bool showUnwalkableNodes = true

Toggle to show unwalkable nodes.

ThreadCount threadCount = ThreadCount.One

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 AddWorkItem) 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.

float unwalkableNodeDebugSize = 0.3F

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

string Branch = "master"

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.

AstarDistribution Distribution = AstarDistribution.WebsiteDownload

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

System.Action On65KOverflow

Called when pathID overflows 65536 and resets back to zero.

System.Action OnAwakeSettings

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 = gameObject.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
AstarPath.active.threadCount = ThreadCount.One;
}


OnGraphDelegate OnGraphPostScan

Called for each graph after they have been scanned.

All other graphs might not have been scanned yet. In most cases it is recommended to create a custom class which inherits from Pathfinding.GraphModifier instead.

OnGraphDelegate OnGraphPreScan

Called for each graph before they are scanned.

In most cases it is recommended to create a custom class which inherits from Pathfinding.GraphModifier instead.

OnScanDelegate OnGraphsUpdated

Called when any graphs are updated.

Register to for example recalculate the path whenever a graph changes. In most cases it is recommended to create a custom class which inherits from Pathfinding.GraphModifier instead.

OnScanDelegate OnLatePostScan

Called after scanning has completed fully.

This is called as the last thing in the Scan function. In most cases it is recommended to create a custom class which inherits from Pathfinding.GraphModifier instead.

OnPathDelegate OnPathPostSearch

Called for each path after searching.

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

OnPathDelegate OnPathPreSearch

Called for each path before searching.

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

System.Action OnPathsCalculated

Called right after callbacks on paths have been called.

A path's callback function runs on the main thread when the path has been calculated. This is done in batches for all paths that have finished their calculation since the last frame. This event will trigger right after a batch of callbacks have been called.

If you do not want to use individual path callbacks, you can use this instead to poll all pending paths and see which ones have completed. This is better than doing it in e.g. the Update loop, because here you will have a guarantee that all calculated paths are still valid. Immediately after this callback has finished, other things may invalidate calculated paths, like for example graph updates.

This is used by the ECS integration to update all entities' pending paths, without having to store a callback for each agent, and also to avoid the ECS synchronization overhead that having individual callbacks would entail.

OnScanDelegate OnPostScan

Called after scanning.

This is called before applying links, flood-filling the graphs and other post processing. In most cases it is recommended to create a custom class which inherits from Pathfinding.GraphModifier instead.

OnScanDelegate OnPreScan

Called before starting the scanning.

In most cases it is recommended to create a custom class which inherits from Pathfinding.GraphModifier instead.

System.Version Version = new System.Version(5, 0, 9)

The version number for the A* Pathfinding Project.

AstarPath active

Returns the active AstarPath object in the scene.

AstarDistribution

Information about where the package was downloaded.

AstarPath ()

void Awake ()

IEnumerator DelayedGraphUpdate ()

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

)

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.

void DirtyBounds (

Bounds

bounds

)

ushort GetNextPathID ()

Returns the next free path ID.

void InitializeGraphs ()

Initializes the AstarData class.

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

void InitializeNode (

GraphNode

node

)

Initializes temporary path data for a node.

Use like: InitializeNode(new PointNode())

void InitializeNodes (

GraphNode[]

nodes

)

void InitializePathProcessor ()

Initializes the pathProcessor field.

bool IsInsideWorkItem

Returns if this code is currently being exectuted inside a work item.

In contrast to IsAnyWorkItemInProgress this is only true when work item code is being executed, it is not true in-between the updates to a work item that takes several frames to complete.

void LogPathResults (

Path

path

)

Prints path results to the log.

What it prints can be controled using logPathResults.

NNConstraint NNConstraintNone = NNConstraint.None

Cached NNConstraint.None to avoid unnecessary allocations.

This should ideally be fixed by making NNConstraint an immutable class/struct.

void OnDestroy ()

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

Cleans up graphs to avoid memory leaks.

This is called by Unity when:

• The component is explicitly disabled in play mode or editor mode.

• When the component is about to be destroyed

  • Including when the game stops

• When an undo/redo event takes place (Unity will first disable the component and then enable it again).

During edit and play mode this method should:

• Destroy all node data (but not the graphs themselves)

• Dispose all unmanaged data

• Shutdown pathfinding threads if they are running (any pending path requests are left in the queue)

void OnEnable ()

Called after this component is enabled.

Unless the component has already been activated in Awake, this method should:

• Ensure the singleton holds (setting active to this).

• Make sure all subsystems that were disabled in OnDisable are again enabled.

  • This includes starting pathfinding threads.

void OnGUI ()

Draws the InGame debugging (if enabled)

void OnUpgradeSerializedData (

refMigrations	migrations
bool	unityThread

)

Handle serialization backwards compatibility.

void PerformBlockingActions (

bool

force=false

)

IEnumerator<Progress> ProgressScanningIteratorsConcurrently (

IEnumerator<JobHandle >[]	iterators
IGraphUpdatePromise[]	promises
bool	async

)

void RecalculateDebugLimits ()

void Reset ()

Handle serialization backwards compatibility.

IEnumerable<Progress> ScanInternal (

NavGraph[]	graphsToScan
bool	async

)

void ShutdownPathfindingThreads ()

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

GraphUpdateObject	ob
float	delay

)

Update all graphs using the GraphUpdateObject after delay seconds.

void UpgradeSerializedData (

bool

isUnityThread

)

void VerifyIntegrity ()

Does simple error checking.

RWLock graphDataLock = new RWLock()

Global read-write lock for graph data.

Graph data is always consistent from the main-thread's perspective, but if you are using jobs to read from graph data, you may need this.

A write lock is held automatically...

• During graph updates. During async graph updates, the lock is only held once per frame while the graph update is actually running, not for the whole duration.

• During work items. Async work items work similarly to graph updates, the lock is only held once per frame while the work item is actually running.

• When GraphModifier events run.

• When graph related callbacks, such as OnGraphsUpdated, run.

• During the last step of a graph's scanning process. See ScanningStage.

To use e.g. AstarPath.active.GetNearest from an ECS job, you'll need to acquire a read lock first, and make sure the lock is only released when the job is finished.

var readLock = AstarPath.active.LockGraphDataForReading();
var handle = new MyJob {
// ...
}.Schedule(readLock.dependency);
readLock.UnlockAfter(handle);


bool graphUpdateRoutineRunning = false

GraphUpdateProcessor graphUpdates

Processes graph updates.

bool graphUpdatesWorkItemAdded = false

Makes sure QueueGraphUpdates will not queue multiple graph update orders.

bool hasScannedGraphAtStartup = false

HierarchicalGraph hierarchicalGraph

Holds a hierarchical graph to speed up some queries like if there is a path between two nodes.

string inGameDebugPath

Debug string from the last completed path.

Will be updated if logPathResults == PathLog.InGame

bool isScanningBacking

Backing field for isScanning.

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

float lastGraphUpdate = -9999F

Time the last graph update was done.

Used to group together frequent graph updates to batches

ushort nextFreePathID = 1

The next unused Path ID.

Incremented for every call to GetNextPathID

GlobalNodeStorage nodeStorage

Holds global node data that cannot be stored in individual graphs.

PathProcessor pathProcessor

Holds all paths waiting to be calculated and calculates them.

PathReturnQueue pathReturnQueue

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

RedrawScope redrawScope

string[] tagNames = null

Stored tag names.

int waitForPathDepth = 0

PathProcessor.GraphUpdateLock workItemLock

Held if any work items are currently queued.

WorkItemProcessor workItems

Processes work items.

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.