Class LayerGridGraph Extends GridGraph, IUpdatableGraph

int CountNodes ()

Number of nodes in the graph.

Note that this is, unless the graph type has overriden it, an O(n) operation.

This is an O(1) operation for grid graphs and point graphs. For layered grid graphs it is an O(n) operation.

GridNodeBase GetNode (

int	x
int	z
int	layer

)

Node in the specified cell.

Returns null if the coordinate is outside the grid.

If you know the coordinate is inside the grid and you are looking to maximize performance then you can look up the node in the internal array directly which is slightly faster.

void GetNodes (

System.Action<GraphNode>

action

)

Calls a delegate with all nodes in the graph.

This is the primary way of iterating through all nodes in a graph.

Do not change the graph structure inside the delegate.

var gg = AstarPath.active.data.gridGraph;

gg.GetNodes(node => {
// Here is a node
Debug.Log("I found a node at position " + (Vector3)node.position);
});
If you want to store all nodes in a list you can do this

var gg = AstarPath.active.data.gridGraph;

List<GraphNode> nodes = new List<GraphNode>();

gg.GetNodes((System.Action<GraphNode>)nodes.Add);


int GetNodesInRegion (

IntRect	rect	Region in which to return nodes. It will be clamped to the grid.
GridNodeBase[]	buffer	Buffer in which the nodes will be stored. Should be at least as large as the number of nodes that can exist in that region.

)

Get all nodes in a rectangle.

LayerGridGraph ()

int LayerCount

int MaxLayers

float characterHeight = 0.4F

Nodes with a short distance to the node above it will be set unwalkable.

void AlignToTilemap (

UnityEngine.GridLayout

grid

)

Aligns this grid to a given tilemap or grid layout.

This is very handy if your game uses a tilemap for rendering and you want to make sure the graph is laid out exactly the same. Matching grid parameters manually can be quite tricky in some cases.

The inspector will automatically show a button to align to a tilemap if one is detected in the scene. If no tilemap is detected, the button be hidden.

void CalculateConnectionsForCellAndNeighbours (

int	x
int	z

)

Calculates the grid connections for a cell as well as its neighbours.

This is a useful utility function if you want to modify the walkability of a single node in the graph.

AstarPath.active.AddWorkItem(ctx => {
var grid = AstarPath.active.data.gridGraph;
int x = 5;
int z = 7;

// Mark a single node as unwalkable
grid.GetNode(x, z).Walkable = false;

// Recalculate the connections for that node as well as its neighbours
grid.CalculateConnectionsForCellAndNeighbours(x, z);
});


GraphTransform CalculateTransform ()

Returns a new transform which transforms graph space to world space.

Does not update the transform field.

float ConvertHexagonSizeToNodeSize (

InspectorGridHexagonNodeSize	mode
float	value

)

Converts a hexagon dimension to a node size.

A hexagon can be defined using either its diameter, or width, none of which are the same as the nodeSize used internally to define the size of a single node.

float ConvertNodeSizeToHexagonSize (

InspectorGridHexagonNodeSize	mode
float	value

)

Converts an internal node size to a hexagon dimension.

A hexagon can be defined using either its diameter, or width, none of which are the same as the nodeSize used internally to define the size of a single node.

int Depth

const int FixedPrecisionScale = 1024

Scaling used for the coordinates in the Linecast methods that take normalized points using integer coordinates.

To convert from world space, each coordinate is multiplied by this factor and then rounded to the nearest integer.

Typically you do not need to use this constant yourself, instead use the Linecast overloads that do not take integer coordinates.

uint GetConnectionCost (

int

dir

)

Default cost of moving one node in a particular direction.

Z
|
|

6 2 5
\ | /
-- 3 - X - 1 ----- X
/ | \
7 0 4

|
|


NNInfo GetNearest (

Vector3	position	The position to try to find the closest node to.
NNConstraint	constraint	Used to limit which nodes are considered acceptable. You may, for example, only want to consider walkable nodes. If null, all nodes will be considered acceptable.
float	maxDistanceSqr	The maximum squared distance from the position to the node. If the node is further away than this, the function will return an empty NNInfo. You may pass infinity if you do not want to limit the distance.

)

Nearest node to a position using the specified NNConstraint.

The returned NNInfo will contain both the closest node, and the closest point on the surface of that node. The distance is measured to the closest point on the surface of the node.

NNInfo GetNearest (

Vector3	position	The position to try to find the closest node to.
NNConstraint	constraint=null	Used to limit which nodes are considered acceptable. You may, for example, only want to consider walkable nodes. If null, all nodes will be considered acceptable.

)

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

The returned NNInfo will contain both the closest node, and the closest point on the surface of that node. The distance is measured to the closest point on the surface of the node.

int[] GetNeighbourDirections (

NumNeighbours

neighbours

)

Neighbour direction indices to use depending on how many neighbours each node should have.

The following illustration shows the direction indices for all 8 neighbours, Z
|
|

6 2 5
\ | /
-- 3 - X - 1 ----- X
/ | \
7 0 4

|
|


For other neighbour counts, a subset of these will be returned.

These can then be used to index into the neighbourOffsets, neighbourCosts, neighbourXOffsets, and neighbourZOffsets arrays.

GridNodeBase GetNode (

int	x
int	z

)

Node in the specified cell.

Returns null if the coordinate is outside the grid.

var gg = AstarPath.active.data.gridGraph;
int x = 5;
int z = 8;
GridNodeBase node = gg.GetNode(x, z);
If you know the coordinate is inside the grid and you are looking to maximize performance then you can look up the node in the internal array directly which is slightly faster.

void GetNodes (

System.Func<GraphNode, bool>

action

)

Calls a delegate with all nodes in the graph until the delegate returns false.

List<GraphNode> GetNodesInRegion (

Bounds

bounds

)

All nodes inside the bounding box.

List<GraphNode> GetNodesInRegion (

GraphUpdateShape

shape

)

All nodes inside the shape.

List<GraphNode> GetNodesInRegion (

IntRect

rect

Region in which to return nodes. It will be clamped to the grid.

)

Get all nodes in a rectangle.

IntRect GetRectFromBounds (

Bounds

bounds

)

A rect that contains all nodes that the bounds could touch.

This correctly handles rotated graphs and other transformations. The returned rect is guaranteed to not extend outside the graph bounds.

Int3 GraphPointToWorld (

int	x
int	z
float	height

)

Transform a point in graph space to world space.

This will give you the node position for the node at the given x and z coordinate if it is at the specified height above the base of the graph.

bool IsInsideBounds (

Vector3

point

)

True if the point is inside the bounding box of this graph.

For a graph that uses 2D physics, or if height testing is disabled, then the graph is treated as infinitely tall. Otherwise, the height of the graph is determined by GraphCollision.fromHeight.

int LayerCount

Number of layers in the graph.

For grid graphs this is always 1, for layered grid graphs it can be higher. The nodes array has the size width*depth*layerCount.

bool Linecast (

Vector3	from
Vector3	to

)

Returns if there is an obstacle between from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


Edge cases are handled as follows:

• Shared edges and corners between walkable and unwalkable nodes are treated as walkable (so for example if the linecast just touches a corner of an unwalkable node, this is allowed).

• If the linecast starts outside the graph, a hit is returned at from.

• If the linecast starts inside the graph, but the end is outside of it, a hit is returned at the point where it exits the graph (unless there are any other hits before that).

bool Linecast (

Vector3	from	Point to linecast from
Vector3	to	Point to linecast to
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.
List<GraphNode>	trace=null	If a list is passed, then it will be filled with all nodes the linecast traverses
System.Func<GraphNode, bool>	filter=null	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.

)

Returns if there is an obstacle between from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

Edge cases are handled as follows:

• Shared edges and corners between walkable and unwalkable nodes are treated as walkable (so for example if the linecast just touches a corner of an unwalkable node, this is allowed).

• If the linecast starts outside the graph, a hit is returned at from.

• If the linecast starts inside the graph, but the end is outside of it, a hit is returned at the point where it exits the graph (unless there are any other hits before that).

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


bool Linecast (

GridNodeBase	fromNode	Node to start from.
GridNodeBase	toNode	Node to try to reach using a straight line.
System.Func<GraphNode, bool>	filter=null	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.

)

Returns if there is an obstacle between the two nodes on the graph.

This method is very similar to the other Linecast methods however it is a bit faster due to not having to look up which node is closest to a particular input point.

var gg = AstarPath.active.data.gridGraph;
var node1 = gg.GetNode(2, 3);
var node2 = gg.GetNode(5, 7);
bool anyObstaclesInTheWay = gg.Linecast(node1, node2);


bool Linecast (

Vector3	from	Point to linecast from
Vector3	to	Point to linecast to
outGridHitInfo	hit	Contains info on what was hit, see GridHitInfo
List<GraphNode>	trace=null	If a list is passed, then it will be filled with all nodes the linecast traverses
System.Func<GraphNode, bool>	filter=null	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.

)

Returns if there is an obstacle between from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

Edge cases are handled as follows:

• Shared edges and corners between walkable and unwalkable nodes are treated as walkable (so for example if the linecast just touches a corner of an unwalkable node, this is allowed).

• If the linecast starts outside the graph, a hit is returned at from.

• If the linecast starts inside the graph, but the end is outside of it, a hit is returned at the point where it exits the graph (unless there are any other hits before that).

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


bool Linecast (

GridNodeBase	fromNode	Node to start from.
Vector2	normalizedFromPoint	Where in the start node to start. This is a normalized value so each component must be in the range 0 to 1 (inclusive).
GridNodeBase	toNode	Node to try to reach using a straight line.
Vector2	normalizedToPoint	Where in the end node to end. This is a normalized value so each component must be in the range 0 to 1 (inclusive).
outGridHitInfo	hit	Contains info on what was hit, see GridHitInfo
List<GraphNode>	trace=null	If a list is passed, then it will be filled with all nodes the linecast traverses
System.Func<GraphNode, bool>	filter=null	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.
bool	continuePastEnd=false	If true, the linecast will continue past the end point in the same direction until it hits something.

)

Returns if there is an obstacle between the two nodes on the graph.

This method is very similar to the other Linecast methods but it gives some extra control, in particular when the start/end points are at node corners instead of inside nodes.

Shared edges and corners between walkable and unwalkable nodes are treated as walkable. So for example if the linecast just touches a corner of an unwalkable node, this is allowed.

bool Linecast (

GridNodeBase	fromNode
int2	fixedNormalizedFromPoint
GridNodeBase	toNode
int2	fixedNormalizedToPoint
outGridHitInfo	hit
List<GraphNode>	trace=null
System.Func<GraphNode, bool>	filter=null
bool	continuePastEnd=false

)

Returns if there is an obstacle between the two nodes on the graph.

Like Linecast(GridNodeBase,Vector2,GridNodeBase,Vector2,GridHitInfo,List<GraphNode>,System.Func<GraphNode,bool>,bool) but takes normalized points as fixed precision points normalized between 0 and FixedPrecisionScale instead of between 0 and 1.

int MaxLayers

float NearestNodeDistanceSqrLowerBound (

Vector3	position	The position to check from
NNConstraint	constraint	A constraint on which nodes are valid. This may or may not be used by the function. You may pass null if you consider all nodes valid.

)

Lower bound on the squared distance from the given point to the closest node in this graph.

This is used to speed up searching for the closest node when there is more than one graph in the scene, by checking the graphs in order of increasing estimated distance to the point.

Implementors may return 0 at all times if it is hard to come up with a good lower bound. It is more important that this function is fast than that it is accurate.

void OnDrawGizmos (

DrawingData	gizmos
bool	drawNodes
RedrawScope	redrawScope

)

Draw gizmos for the graph.

void RecalculateAllConnections ()

Recalculates node connections for all nodes in grid graph.

This is used if you have manually changed the walkability, or other parameters, of some grid nodes, and you need their connections to be recalculated. If you are changing the connections themselves, you should use the GraphNode.Connect and GraphNode.Disconnect functions instead.

Typically you do not change walkability manually. Instead you can use for example a GraphUpdateObject.

void RecalculateConnectionsInRegion (

IntRect

recalculateRect

)

Recalculates node connections for all nodes in a given region of the grid.

This is used if you have manually changed the walkability, or other parameters, of some grid nodes, and you need their connections to be recalculated. If you are changing the connections themselves, you should use the GraphNode.AddConnection and GraphNode.RemoveConnection functions instead.

Typically you do not change walkability manually. Instead you can use for example a GraphUpdateObject.

RecalculationMode

void RelocateNodes (

Matrix4x4

deltaMatrix

)

Moves the nodes in this graph.

Multiplies all node positions by deltaMatrix.

For example if you want to move all your nodes in e.g a point graph 10 units along the X axis from the initial position var graph = AstarPath.data.pointGraph;
var m = Matrix4x4.TRS (new Vector3(10,0,0), Quaternion.identity, Vector3.one);
graph.RelocateNodes (m);


void RelocateNodes (

Vector3	center
Quaternion	rotation
float	nodeSize
float	aspectRatio=1
float	isometricAngle=0

)

Relocate the grid graph using new settings.

This will move all nodes in the graph to new positions which matches the new settings.

// Move the graph to the origin, with no rotation, and with a node size of 1.0
var gg = AstarPath.active.data.gridGraph;
gg.RelocateNodes(center: Vector3.zero, rotation: Quaternion.identity, nodeSize: 1.0f);


void Scan ()

Scan the graph.

Consider using AstarPath.Scan() instead since this function only scans this graph, and if you are using multiple graphs with connections between them, then it is better to scan all graphs at once.

void SetDimensions (

int	width
int	depth
float	nodeSize

)

Updates unclampedSize from width, depth and nodeSize values.

Also generates a new matrix .

You should use this method instead of setting the width and depth fields as the grid dimensions are not defined by the width and depth variables but by the unclampedSize and center variables.

var gg = AstarPath.active.data.gridGraph;
var width = 80;
var depth = 60;
var nodeSize = 1.0f;

gg.SetDimensions(width, depth, nodeSize);

// Recalculate the graph
AstarPath.active.Scan();


void SetGridShape (

InspectorGridMode

shape

)

Changes the grid shape.

This is equivalent to changing the 'shape' dropdown in the grid graph inspector.

Calling this method will set isometricAngle, aspectRatio, uniformEdgeCosts and neighbours to appropriate values for that shape.

void SetUpOffsetsAndCosts ()

Sets up neighbourOffsets with the current settings.

neighbourOffsets, neighbourCosts, neighbourXOffsets and neighbourZOffsets are set up.
The cost for a non-diagonal movement between two adjacent nodes is RoundToInt (nodeSize * Int3.Precision)
The cost for a diagonal movement between two adjacent nodes is RoundToInt (nodeSize * Sqrt (2) * Int3.Precision)

void SetWalkability (

bool[]	walkability
IntRect	rect

)

Set walkability for multiple nodes at once.

If you are calculating your graph's walkability in some custom way, you can use this method to copy that data to the graph. In most cases you'll not use this method, but instead build your world with colliders and such, and then scan the graph.

IGraphSnapshot Snapshot (

Bounds

bounds

)

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

If this graph type does not support taking snapshots, or if the bounding box does not intersect with the graph, this method returns null.

float StandardDimetricAngle = Mathf.Acos(1/2f)*Mathf.Rad2Deg

Commonly used value for isometricAngle.

float StandardIsometricAngle = 90-Mathf.Atan(1/Mathf.Sqrt(2))*Mathf.Rad2Deg

Commonly used value for isometricAngle.

IGraphUpdatePromise TranslateInDirection (

int	dx	Number of nodes along the graph's X axis to move by.
int	dz	Number of nodes along the graph's Z axis to move by.

)

Moves the grid by a number of nodes.

This is used by the ProceduralGraphMover component to efficiently move the graph.

All nodes that can stay in the same position will stay. The ones that would have fallen off the edge of the graph will wrap around to the other side and then be recalculated.

void UpdateTransform ()

Updates the transform field which transforms graph space to world space.

In graph space all nodes are laid out in the XZ plane with the first node having a corner in the origin. One unit in graph space is one node so the first node in the graph is at (0.5,0) the second one at (1.5,0) etc.

This takes the current values of the parameters such as position and rotation into account. The transform that was used the last time the graph was scanned is stored in the transform field.

The transform field is calculated using this method when the graph is scanned. The width, depth variables are also updated based on the unclampedSize field.

int Width

AstarPath active

Reference to the AstarPath object in the scene.

float aspectRatio = 1F

Scaling of the graph along the X axis.

This should be used if you want different scales on the X and Y axis of the grid

This option is only visible in the inspector if the graph shape is set to isometric or advanced.

Bounds bounds

World bounding box for the graph.

This always contains the whole graph.

Bounds bounds

World bounding box for the graph.

This always contains the whole graph.

It is ok for a graph type to return an infinitely large bounding box, but this may make some operations less efficient. The point graph will always return an infinitely large bounding box.

Vector3 center

Center point of the grid in world space.

The graph can be positioned anywhere in the world.

GraphCollision collision = new GraphCollision()

Settings on how to check for walkability and height.

bool cutCorners = true

If disabled, will not cut corners on obstacles.

If this is true, and neighbours is set to Eight, obstacle corners are allowed to be cut by a connection.

int depth

Depth (height) of the grid in nodes.

Grid graphs are typically anywhere from 10-500 nodes wide. But it can go up to 1024 nodes wide by default. Consider using a recast graph instead, if you find yourself needing a very high resolution grid.

This value will be clamped to at most 1024 unless ASTAR_LARGER_GRIDS has been enabled in the A* Inspector -> Optimizations tab.

bool drawGizmos = true

Enable to draw gizmos in the Unity scene view.

In the inspector this value corresponds to the state of the 'eye' icon in the top left corner of every graph inspector.

int erodeIterations

Number of times to erode the graph.

The graph can be eroded to add extra margin to obstacles. It is very convenient if your graph contains ledges, and where the walkable nodes without erosion are too close to the edge.

Below is an image showing a graph with 0, 1 and 2 erosion iterations:

int erosionFirstTag = 1

Tag to start from when using tags for erosion.

int erosionTagsPrecedenceMask = -1

Bitmask for which tags can be overwritten by erosion tags.

When erosionUseTags is enabled, nodes near unwalkable nodes will be marked with tags. However, if these nodes already have tags, you may want the custom tag to take precedence. This mask controls which tags are allowed to be replaced by the new erosion tags.

In the image below, erosion has applied tags which have overwritten both the base tag (tag 0) and the custom tag set on the nodes (shown in red).

In the image below, erosion has applied tags, but it was not allowed to overwrite the custom tag set on the nodes (shown in red).

bool erosionUseTags

Use tags instead of walkability for erosion.

Tags will be used for erosion instead of marking nodes as unwalkable. The nodes will be marked with tags in an increasing order starting with the tag erosionFirstTag. Debug with the Tags mode to see the effect. With this enabled you can in effect set how close different AIs are allowed to get to walls using the Valid Tags field on the Seeker component.

uint graphIndex

Index of the graph, used for identification purposes.

Guid guid

Used as an ID of the graph, considered to be unique.

bool infoScreenOpen

Used in the editor to check if the info screen is open.

Should be inside UNITY_EDITOR only #ifs but just in case anyone tries to serialize a NavGraph instance using Unity, I have left it like this as it would otherwise cause a crash when building. Version 3.0.8.1 was released because of this bug only

uint initialPenalty

Default penalty to apply to all nodes.

InspectorGridMode inspectorGridMode = InspectorGridMode.Grid

Determines the layout of the grid graph inspector in the Unity Editor.

A grid graph can be set up as a normal grid, isometric grid or hexagonal grid. Each of these modes use a slightly different inspector layout. When changing the shape in the inspector, it will automatically set other relevant fields to appropriate values. For example, when setting the shape to hexagonal it will automatically set the neighbours field to Six.

This field is only used in the editor, it has no effect on the rest of the game whatsoever.

If you want to change the grid shape like in the inspector you can use the SetGridShape method.

InspectorGridHexagonNodeSize inspectorHexagonSizeMode = InspectorGridHexagonNodeSize.Width

Determines how the size of each hexagon is set in the inspector.

For hexagons the normal nodeSize field doesn't really correspond to anything specific on the hexagon's geometry, so this enum is used to give the user the opportunity to adjust more concrete dimensions of the hexagons without having to pull out a calculator to calculate all the square roots and complicated conversion factors.

This field is only used in the graph inspector, the nodeSize field will always use the same internal units. If you want to set the node size through code then you can use ConvertHexagonSizeToNodeSize.

bool? is2D

Get or set if the graph should be in 2D mode.

bool isScanned

float isometricAngle

Angle in degrees to use for the isometric projection.

If you are making a 2D isometric game, you may want to use this parameter to adjust the layout of the graph to match your game. This will essentially scale the graph along one of its diagonals to produce something like this:

A perspective view of an isometric graph.

A top down view of an isometric graph. Note that the graph is entirely 2D, there is no perspective in this image.

For commonly used values see StandardIsometricAngle and StandardDimetricAngle.

Usually the angle that you want to use is either 30 degrees (alternatively 90-30 = 60 degrees) or atan(1/sqrt(2)) which is approximately 35.264 degrees (alternatively 90 - 35.264 = 54.736 degrees). You might also want to rotate the graph plus or minus 45 degrees around the Y axis to get the oritientation required for your game.

You can read more about it on the wikipedia page linked below.

This option is only visible in the inspector if the graph shape is set to isometric or advanced.

float maxSlope = 90

The max slope in degrees for a node to be walkable.

float maxStepHeight = 0.4F

The max y coordinate difference between two nodes to enable a connection.

Set to 0 to ignore the value.

This affects for example how the graph is generated around ledges and stairs.

bool maxStepUsesSlope = true

Take the slope into account for maxStepHeight.

When this is enabled the normals of the terrain will be used to make more accurate estimates of how large the steps are between adjacent nodes.

When this is disabled then calculated step between two nodes is their y coordinate difference. This may be inaccurate, especially at the start of steep slopes.

In the image below you can see an example of what happens near a ramp. In the topmost image the ramp is not connected with the rest of the graph which is obviously not what we want. In the middle image an attempt has been made to raise the max step height while keeping maxStepUsesSlope disabled. However this causes too many connections to be added. The agent should not be able to go up the ramp from the side. Finally in the bottommost image the maxStepHeight has been restored to the original value but maxStepUsesSlope has been enabled. This configuration handles the ramp in a much smarter way. Note that all the values in the image are just example values, they may be different for your scene.

string name

Name of the graph.

Can be set in the unity editor

uint[] neighbourCosts = new uint[8]

Costs to neighbour nodes.

See neighbourOffsets.

int[] neighbourOffsets = new int[8]

Index offset to get neighbour nodes.

Added to a node's index to get a neighbour node index.

Z
|
|

6 2 5
\ | /
-- 3 - X - 1 ----- X
/ | \
7 0 4

|
|


int[] neighbourXOffsets = { 0, 1, 0, -1, 1, 1, -1, -1 }

Offsets in the X direction for neighbour nodes.

Only 1, 0 or -1

int[] neighbourZOffsets = { -1, 0, 1, 0, -1, 1, 1, -1 }

Offsets in the Z direction for neighbour nodes.

Only 1, 0 or -1

NumNeighbours neighbours = NumNeighbours.Eight

Number of neighbours for each node.

Either four, six, eight connections per node.

Six connections is primarily for hexagonal graphs.

float nodeSize = 1

Size of one node in world units.

For a grid layout, this is the length of the sides of the grid squares.

For a hexagonal layout, this value does not correspond to any specific dimension of the hexagon. Instead you can convert it to a dimension on a hexagon using ConvertNodeSizeToHexagonSize.

GridNodeBase[] nodes

All nodes in this graph.

Nodes are laid out row by row.

The first node has grid coordinates X=0, Z=0, the second one X=1, Z=0
the last one has grid coordinates X=width-1, Z=depth-1.

var gg = AstarPath.active.data.gridGraph;
int x = 5;
int z = 8;
GridNodeBase node = gg.nodes[z*gg.width + x];


bool open

Is the graph open in the editor.

bool persistent

True if the graph will be included when serializing graph data.

If false, the graph will be ignored when saving graph data.

Most graphs are persistent, but the LinkGraph is not persistent because links are always re-created from components at runtime.

Vector3 rotation

Rotation of the grid in degrees.

The nodes are laid out along the X and Z axes of the rotation.

For a 2D game, the rotation will typically be set to (-90, 270, 90). If the graph is aligned with the XY plane, the inspector will automatically switch to 2D mode.

GridGraphRules rules = new GridGraphRules()

Additional rules to use when scanning the grid graph.

// Get the first grid graph in the scene
var gridGraph = AstarPath.active.data.gridGraph;

gridGraph.rules.AddRule(new Pathfinding.Graphs.Grid.Rules.RuleAnglePenalty {
penaltyScale = 10000,
curve = AnimationCurve.Linear(0, 0, 90, 1),
});


bool showInInspector

True if the graph should be visible in the editor.

False is used for some internal graph types that users don't have to worry about.

bool showMeshOutline = true

Show an outline of the grid nodes in the Unity Editor.

bool showMeshSurface = true

Show the surface of the graph.

Each node will be drawn as a square (unless e.g hexagon graph mode has been enabled).

bool showNodeConnections

Show the connections between the grid nodes in the Unity Editor.

Vector2 size

Size of the grid.

Will always be positive and larger than nodeSize.

GraphTransform transform = new GraphTransform(Matrix4x4.identity)

Determines how the graph transforms graph space to world space.

Vector2 unclampedSize = new Vector2(10, 10)

Size of the grid.

Can be negative or smaller than nodeSize

bool uniformEdgeCosts

If true, all edge costs will be set to the same value.

If false, diagonals will cost more. This is useful for a hexagon graph where the diagonals are actually the same length as the normal edges (since the graph has been skewed)

int width

Width of the grid in nodes.

Grid graphs are typically anywhere from 10-500 nodes wide. But it can go up to 1024 nodes wide by default. Consider using a recast graph instead, if you find yourself needing a very high resolution grid.

This value will be clamped to at most 1024 unless ASTAR_LARGER_GRIDS has been enabled in the A* Inspector -> Optimizations tab.

GridNodeBase[] AllocateNodesJob (

int	size
out JobHandle	dependency

)

GridNodeBase[] AllocateNodesJob (

int	size
out Unity.Jobs.JobHandle	dependency

)

void AssertSafeToUpdateGraph ()

Throws an exception if it is not safe to update internal graph data right now.

It is safe to update graphs when graphs are being scanned, or inside a work item. In other cases pathfinding could be running at the same time, which would not appreciate graph data changing under its feet.

bool ClipLineSegmentToBounds (

Vector3	a
Vector3	b
out Vector3	outA
out Vector3	outB

)

Clips a line segment in graph space to the graph bounds.

That is (0,0,0) is the bottom left corner of the graph and (width,0,depth) is the top right corner. The first node is placed at (0.5,y,0.5). One unit distance is the same as nodeSize.

Returns false if the line segment does not intersect the graph at all.

long CrossMagnitude (

int2	a
int2	b

)

Magnitude of the cross product a x b.

void DeserializeExtraInfo (

GraphSerializationContext

ctx

)

Deserializes graph type specific node data.

void DeserializeNativeData (

GraphSerializationContext	ctx
bool	normalsSerialized

)

void DeserializeNodeSurfaceNormals (

GraphSerializationContext	ctx
GridNodeBase[]	nodes
bool	ignoreForCompatibility

)

void DestroyAllNodes ()

Destroys all nodes in the graph.

void DirtyBounds (

Bounds

bounds

)

Notifies the system that changes have been made inside these bounds.

This should be called by graphs whenever they are changed. It will cause off-mesh links to be updated, and it will also ensure GraphModifier events are callled.

The bounding box should cover the surface of all nodes that have been updated. It is fine to use a larger bounding box than necessary (even an infinite one), though this may be slower, since more off-mesh links need to be recalculated. You can even use an infinitely large bounding box if you don't want to bother calculating a more accurate one. You can also call this multiple times to dirty multiple bounding boxes.

When scanning the graph, this is called automatically - with the value from the bounds property - for all graphs after the scanning has finished.

void DisposeUnmanagedData ()

Cleans up any unmanaged data that the graph has.

void DrawUnwalkableNodes (

DrawingData	gizmos
float	size
RedrawScope	redrawScope

)

GridNodeBase GetNearestFromGraphSpace (

Vector3

positionGraphSpace

)

GridNodeBase GetNearestNode (

Vector3	position
int	x
int	z
NNConstraint	constraint

)

List<GraphNode> GetNodesInRegion (

Bounds	bounds
GraphUpdateShape	shape

)

All nodes inside the shape or if null, the bounding box.

If a shape is supplied, it is assumed to be contained inside the bounding box.

const int HexagonConnectionMask = 0b010101111

Mask based on hexagonNeighbourIndices.

This indicates which connections (out of the 8 standard ones) should be enabled for hexagonal graphs.

int hexagonConnectionMask = 0;
for (int i = 0; i < GridGraph.hexagonNeighbourIndices.Length; i++) hexagonConnectionMask |= 1 << GridGraph.hexagonNeighbourIndices[i];


void OnDestroy ()

Function for cleaning up references.

This will be called on the same time as OnDisable on the gameObject which the AstarPath script is attached to (remember, not in the editor). Use for any cleanup code such as cleaning up static variables which otherwise might prevent resources from being collected. Use by creating a function overriding this one in a graph class, but always call base.OnDestroy () in that function. All nodes should be destroyed in this function otherwise a memory leak will arise.

void PostDeserialization (

GraphSerializationContext

ctx

)

Called after all deserialization has been done for all graphs.

Can be used to set up more graph data which is not serialized

IGraphUpdatePromise ScanInternal (

bool

async

)

Internal method to scan the graph.

Override this function to implement custom scanning logic.

void SerializeExtraInfo (

GraphSerializationContext

ctx

)

Serializes graph type specific node data.

This function can be overriden to serialize extra node information (or graph information for that matter) which cannot be serialized using the standard serialization. Serialize the data in any way you want and return a byte array. When loading, the exact same byte array will be passed to the DeserializeExtraInfo function.
These functions will only be called if node serialization is enabled.

void SerializeNodeSurfaceNormals (

GraphSerializationContext

ctx

)

int[] allNeighbourIndices = { 0, 1, 2, 3, 4, 5, 6, 7 }

Which neighbours are going to be used when neighbours=8.

int[] axisAlignedNeighbourIndices = { 0, 1, 2, 3 }

Which neighbours are going to be used when neighbours=4.

bool exists

True if the graph exists, false if it has been destroyed.

int[] hexagonNeighbourIndices = { 0, 1, 5, 2, 3, 7 }

Which neighbours are going to be used when neighbours=6.

int lastScannedDepth

int lastScannedWidth

int layerCount

Number of layers.

System.Func<GridNodeBase> newGridNodeDelegate = () => new GridNode()

Delegate which creates and returns a single instance of the node type for this graph.

This may be set in the constructor for graphs inheriting from the GridGraph to change the node type of the graph.

GridGraphNodeData nodeData

Internal data for each node.

It also contains some data not stored in the node objects, such as normals for the surface of the graph. These normals need to be saved when the maxStepUsesSlope option is enabled for graph updates to work.

refGridGraphNodeData nodeDataRef

bool useRaycastNormal

Use heigh raycasting normal for max slope calculation.

True if maxSlope is less than 90 degrees.