Class LayerGridGraphUpdate Extends GraphUpdateObject

bool preserveExistingNodes = true

If true, nodes will be reused.

This can be used to preserve e.g penalty values when recalculating

bool recalculateNodes

Recalculate nodes in the graph.

Nodes might be created, moved or destroyed depending on how the world has changed.

void Apply (

GraphNode

node

)

Updates the specified node using this GUO's settings.

void RevertFromBackup ()

Reverts penalties and flags (which includes walkability) on every node which was updated using this GUO.

Data for reversion is only saved if trackChangedNodes is true.

This method modifies the graph. So it must be called inside while it is safe to modify the graph, for example inside a work item as shown in the example below.

// Update the graph
var guo = new GraphUpdateObject(GetComponent<Collider>().bounds);

guo.trackChangedNodes = true;
AstarPath.active.UpdateGraphs(guo);
// Apply the update immediately
AstarPath.active.FlushGraphUpdates();

// Then revert the change.
// The reversion modifies the graph, so it must be done inside a work item
AstarPath.active.AddWorkItem(() => {
guo.RevertFromBackup();
});
// Apply the reversion immediately
AstarPath.active.FlushWorkItems();



void WillUpdateNode (

GraphNode

node

The node to save fields for. If null, nothing will be done

)

Should be called on every node which is updated with this GUO before it is updated.

int addPenalty

Penalty to add to the nodes.

A penalty of 1000 is equivalent to the cost of moving 1 world unit.

Bounds bounds

The bounds to update nodes within.

Defined in world space.

List<GraphNode> changedNodes

Nodes which were updated by this GraphUpdateObject.

Will only be filled if trackChangedNodes is true.

bool modifyTag

If true, all nodes' tag will be set to setTag.

bool modifyWalkability

If true, all nodes' walkable variable will be set to setWalkability.

It is not recommended to combine this with updatePhysics since then you will just overwrite what updatePhysics calculated.

NNConstraint nnConstraint = NNConstraint.None

NNConstraint to use.

The Pathfinding.NNConstraint.SuitableGraph function will be called on the NNConstraint to enable filtering of which graphs to update.

bool resetPenaltyOnPhysics = true

Reset penalties to their initial values when updating grid graphs and updatePhysics is true.

If you want to keep old penalties even when you update the graph you may want to disable this option.

The images below shows two overlapping graph update objects, the right one happened to be applied before the left one. They both have updatePhysics = true and are set to increase the penalty of the nodes by some amount.

The first image shows the result when resetPenaltyOnPhysics is false. Both penalties are added correctly.

This second image shows when resetPenaltyOnPhysics is set to true. The first GUO is applied correctly, but then the second one (the left one) is applied and during its updating, it resets the penalties first and then adds penalty to the nodes. The result is that the penalties from both GUOs are not added together. The green patch in at the border is there because physics recalculation (recalculation of the position of the node, checking for obstacles etc.) affects a slightly larger area than the original GUO bounds because of the Grid Graph -> Collision Testing -> Diameter setting (it is enlarged by that value). So some extra nodes have their penalties reset.

int setTag

If modifyTag is true, all nodes' tag will be set to this value.

bool setWalkability

If modifyWalkability is true, the nodes' walkable variable will be set to this value.

GraphUpdateShape shape

A shape can be specified if a bounds object does not give enough precision.

Note that if you set this, you should set the bounds so that it encloses the shape because the bounds will be used as an initial fast check for which nodes that should be updated.

GraphUpdateStage stage

Info about if a graph update has been applied or not.

bool trackChangedNodes

Track which nodes are changed and save backup data.

Used internally to revert changes if needed.

bool updateErosion = true

Update Erosion for GridGraphs.

When enabled, erosion will be recalculated for grid graphs after the GUO has been applied.

In the below image you can see the different effects you can get with the different values.
The first image shows the graph when no GUO has been applied. The blue box is not identified as an obstacle by the graph, the reason there are unwalkable nodes around it is because there is a height difference (nodes are placed on top of the box) so erosion will be applied (an erosion value of 2 is used in this graph). The orange box is identified as an obstacle, so the area of unwalkable nodes around it is a bit larger since both erosion and collision has made nodes unwalkable.
The GUO used simply sets walkability to true, i.e making all nodes walkable.

When updateErosion=True, the reason the blue box still has unwalkable nodes around it is because there is still a height difference so erosion will still be applied. The orange box on the other hand has no height difference and all nodes are set to walkable.

When updateErosion=False, all nodes walkability are simply set to be walkable in this example.

bool updatePhysics = true

Use physics checks to update nodes.

When updating a grid graph and this is true, the nodes' position and walkability will be updated using physics checks with settings from "Collision Testing" and "Height Testing".

When updating a PointGraph, setting this to true will make it re-evaluate all connections in the graph which passes through the bounds.

This has no effect when updating GridGraphs if modifyWalkability is turned on. You should not combine updatePhysics and modifyWalkability.

On RecastGraphs, having this enabled will trigger a complete recalculation of all tiles intersecting the bounds. This is quite slow (but powerful). If you only want to update e.g penalty on existing nodes, leave it disabled.

const int STAGE_ABORTED = -3

const int STAGE_APPLIED = 0

const int STAGE_CREATED = -1

const int STAGE_PENDING = -2

int internalStage = STAGE_CREATED

Info about if a graph update has been applied or not.

Either an enum (see STAGE_CREATED and associated constants) or a non-negative count of the number of graphs that are waiting to apply this graph update.