A* Pathfinding Project
3.8.6
The A* Pathfinding Project for Unity 3D

Generates a grid of nodes. More...
Generates a grid of nodes.
The GridGraph does exactly what the name implies, generates nodes in a grid pattern.
Grid graphs suit well to when you already have a grid based world. Features:
The The Snap Size button snaps the internal size of the graph to exactly contain the current number of nodes, i.e not contain 100.3 nodes but exactly 100 nodes.
This will make the "center" coordinate more accurate.
Updating the graph during runtime Any graph which implements the IUpdatableGraph interface can be updated during runtime.
For grid graphs this is a great feature since you can update only a small part of the grid without causing any lag like a complete rescan would.
If you for example just have instantiated a sphere obstacle in the scene and you want to update the grid where that sphere was instantiated, you can do this:
Where ob is the obstacle you just instantiated (a GameObject).
As you can see, the UpdateGraphs function takes a Bounds parameter and it will send an update call to all updateable graphs.
A grid graph will update that area and a small margin around it equal to collision testing diameter/2
Hexagon graphs The graph can be configured to work like a hexagon graph with some simple settings. Just set the neighbours (called 'connections' in the editor) field to 'Six' and then click the 'Configure as Hexagon Graph' button that will show up. That will set the isometricAngle field to 54.74 (more precisely 90atan(1/sqrt(2))) and enable uniformEdgeCosts.
Then the graph will work like a hexagon graph. You might want to rotate it to better match your game however.
Note however that the snapping to the closest node is not exactly as you would expect in a real hexagon graph, but it is close enough that you will likely not notice.
Configure using code
Tree colliders It seems that Unity will only generate tree colliders at runtime when the game is started. For this reason, the grid graph will not pick up tree colliders when outside of play mode but it will pick them up once the game starts. If it still does not pick them up make sure that the trees actually have colliders attached to them and that the tree prefabs are in the correct layer (the layer should be included in the 'Collision Testing' mask).
Classes  
class  TextureData 
Used for using a texture as a source for a grid graph. More...  
Public Member Functions  
GridGraph ()  
virtual void  CalculateConnections (GridNode[] nodes, int x, int z, GridNode node) 
Calculates the grid connections for a single node.  
virtual void  CalculateConnections (int x, int z, GridNode node) 
Calculates the grid connections for a single node.  
GraphUpdateThreading  CanUpdateAsync (GraphUpdateObject o) 
bool  CheckConnection (GridNode node, int dir) 
Returns if node is connected to it's neighbour in the specified direction.  
override int  CountNodes () 
Count nodes in the graph.  
override void  DeserializeExtraInfo (GraphSerializationContext ctx) 
Deserializes graph type specific node data.  
override void  DeserializeSettingsCompatibility (GraphSerializationContext ctx) 
An old format for serializing settings.  
virtual void  ErodeWalkableArea () 
Erodes the walkable area.  
virtual void  ErodeWalkableArea (int xmin, int zmin, int xmax, int zmax) 
Erodes the walkable area.  
void  GenerateMatrix () 
Generates the matrix used for translating nodes from grid coordinates to world coordintes.  
uint  GetConnectionCost (int dir) 
override NNInfo  GetNearest (Vector3 position, NNConstraint constraint, GraphNode hint) 
Returns the nearest node to a position using the specified NNConstraint.  
override NNInfo  GetNearestForce (Vector3 position, NNConstraint constraint) 
Returns the nearest node to a position using the specified constraint .  
GridNode  GetNodeConnection (GridNode node, int dir) 
override void  GetNodes (GraphNodeDelegateCancelable del) 
Calls a delegate with all nodes in the graph.  
List< GraphNode >  GetNodesInArea (Bounds b) 
All nodes inside the bounding box.  
List< GraphNode >  GetNodesInArea (GraphUpdateShape shape) 
All nodes inside the shape.  
Int3  GraphPointToWorld (int x, int z, float height) 
Transform a point in graph space to world space.  
bool  HasNodeConnection (GridNode node, int dir) 
bool  HasNodeConnection (int index, int x, int z, int dir) 
virtual bool  IsValidConnection (GridNode n1, GridNode n2) 
Returns true if a connection between the adjacent nodes n1 and n2 is valid.  
bool  Linecast (Vector3 _a, Vector3 _b) 
Returns if there is an obstacle between origin and end on the graph.  
bool  Linecast (Vector3 _a, Vector3 _b, GraphNode hint) 
Returns if there is an obstacle between origin and end on the graph.  
bool  Linecast (Vector3 _a, Vector3 _b, GraphNode hint, out GraphHitInfo hit) 
Returns if there is an obstacle between origin and end on the graph.  
bool  Linecast (Vector3 _a, Vector3 _b, GraphNode hint, out GraphHitInfo hit, List< GraphNode > trace) 
Returns if there is an obstacle between _a and _b on the graph.  
override void  OnDestroy () 
This function will be called when this graph is destroyed.  
override void  OnDrawGizmos (bool drawNodes) 
Draw gizmos for the graph.  
void  OnPostScan (AstarPath script) 
Auto links grid graphs together.  
override void  PostDeserialization () 
Called after all deserialization has been done for all graphs.  
void  RelocateNodes (Vector3 center, Quaternion rotation, float nodeSize, float aspectRatio=1, float isometricAngle=0) 
Relocate the grid graph using new settings.  
override void  ScanInternal (OnScanStatus statusCallback) 
Scans the graph, called from AstarPath.ScanLoop.  
override void  SerializeExtraInfo (GraphSerializationContext ctx) 
Serializes graph type specific node data.  
void  SetNodeConnection (GridNode node, int dir, bool value) 
void  SetNodeConnection (int index, int x, int z, int dir, bool value) 
Set if connection in the specified direction should be enabled.  
virtual void  SetUpOffsetsAndCosts () 
Sets up neighbourOffsets with the current settings.  
bool  SnappedLinecast (Vector3 a, Vector3 b, GraphNode hint, out GraphHitInfo hit) 
Returns if there is an obstacle between and on the graph.  
void  UpdateArea (GraphUpdateObject o) 
Internal function to update an area of the graph.  
void  UpdateAreaInit (GraphUpdateObject o) 
virtual void  UpdateNodePositionCollision (GridNode node, int x, int z, bool resetPenalty=true) 
Updates position, walkability and penalty for the node.  
void  UpdateSizeFromWidthDepth () 
Updates size from width, depth and nodeSize values.  
Public Member Functions inherited from NavGraph  
virtual void  Awake () 
This will be called on the same time as Awake on the gameObject which the AstarPath script is attached to.  
NNInfo  GetNearest (Vector3 position) 
Returns the nearest node to a position using the default NNConstraint.  
NNInfo  GetNearest (Vector3 position, NNConstraint constraint) 
Returns the nearest node to a position using the specified NNConstraint.  
virtual Color  NodeColor (GraphNode node, PathHandler data) 
virtual void  RelocateNodes (Matrix4x4 oldMatrix, Matrix4x4 newMatrix) 
Relocates the nodes in this graph.  
void  Scan () 
void  ScanGraph () 
void  ScanInternal () 
Internal method for scanning graphs.  
void  SetMatrix (Matrix4x4 m) 
Use to set both matrix and inverseMatrix at the same time.  
Public Member Functions inherited from IUpdatableGraph  
GraphUpdateThreading  CanUpdateAsync (GraphUpdateObject o) 
void  UpdateArea (GraphUpdateObject o) 
Updates an area using the specified GraphUpdateObject.  
void  UpdateAreaInit (GraphUpdateObject o) 
Public Member Functions inherited from IRaycastableGraph  
bool  Linecast (Vector3 start, Vector3 end) 
bool  Linecast (Vector3 start, Vector3 end, GraphNode hint) 
bool  Linecast (Vector3 start, Vector3 end, GraphNode hint, out GraphHitInfo hit) 
bool  Linecast (Vector3 start, Vector3 end, GraphNode hint, out GraphHitInfo hit, List< GraphNode > trace) 
Static Public Member Functions  
static void  CalculateConnections (GridNode node) 
Calculates the grid connections for a single node.  
Static Public Member Functions inherited from NavGraph  
static bool  InSearchTree (GraphNode node, Path path) 
Returns if the node is in the search tree of the path.  
Public Attributes  
const int  getNearestForceOverlap = 2 
In GetNearestForce, determines how far to search after a valid node has been found.  
readonly uint[]  neighbourCosts = new uint[8] 
Costs to neighbour nodes.  
readonly int[]  neighbourOffsets = new int[8] 
Index offset to get neighbour nodes.  
readonly int[]  neighbourXOffsets = new int[8] 
Offsets in the X direction for neighbour nodes.  
readonly int[]  neighbourZOffsets = new int[8] 
Offsets in the Z direction for neighbour nodes.  
GridNode[]  nodes 
All nodes in this graph.  
Public Attributes inherited from NavGraph  
AstarPath  active 
Reference to the AstarPath object in the scene.  
bool  drawGizmos = true 
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.  
uint  initialPenalty 
Default penalty to apply to all nodes.  
Matrix4x4  inverseMatrix = Matrix4x4.identity 
Inverse of matrix.  
Matrix4x4  matrix = Matrix4x4.identity 
A matrix for translating/rotating/scaling the graph.  
string  name 
Name of the graph.  
bool  open 
Is the graph open in the editor.  
Protected Member Functions  
bool  ClipLineSegmentToBounds (Vector3 a, Vector3 b, out Vector3 outA, out Vector3 outB) 
Clips a line segment in graph space to the graph bounds.  
virtual GridNodeBase  GetNeighbourAlongDirection (GridNodeBase node, int direction) 
Utility method used by Linecast.  
Static Protected Member Functions  
static float  CrossMagnitude (Vector2 a, Vector2 b) 
Magnitude of the cross product a x b.  
static void  GetBoundsMinMax (Bounds b, Matrix4x4 matrix, out Vector3 min, out Vector3 max) 
Calculates minimum and maximum points for bounds b when multiplied with the matrix.  
Static Package Attributes  
static readonly int[]  hexagonNeighbourIndices = { 0, 1, 2, 3, 5, 7 } 
Which neighbours are going to be used when neighbours=6.  
Properties  
Matrix4x4  boundsMatrix [get, set] 
int  Depth [get, set] 
Vector2  size [get, set] 
Size of the grid.  
virtual bool  uniformWidthDepthGrid [get] 
This is placed here so generators inheriting from this one can override it and set it to false.  
int  Width [get, set] 
Private Member Functions  
bool  ErosionAnyFalseConnections (GridNode node) 
True if the node has any blocked connections.  
GridNode  GetNodeConnection (int index, int x, int z, int dir) 
Get the connecting node from the node at (x,z) in the specified direction.  
List< GraphNode >  GetNodesInArea (Bounds b, GraphUpdateShape shape) 
All nodes inside the shape or if null, the bounding box.  
void  RemoveGridGraphFromStatic () 
Inspector  Settings  
bool  useRaycastNormal [get] 
Use heigh raycasting normal for max slope calculation.  
int  width 
Width of the grid in nodes.  
int  depth 
Depth (height) of the grid in nodes.  
float  aspectRatio = 1F 
Scaling of the graph along the X axis.  
float  isometricAngle 
Angle to use for the isometric projection.  
bool  uniformEdgeCosts 
If true, all edge costs will be set to the same value.  
Vector3  rotation 
Rotation of the grid in degrees.  
Vector3  center 
Center point of the grid.  
Vector2  unclampedSize 
Size of the grid.  
float  nodeSize = 1 
Size of one node in world units.  
GraphCollision  collision 
Settings on how to check for walkability and height.  
float  maxClimb = 0.4F 
The max position difference between two nodes to enable a connection.  
int  maxClimbAxis = 1 
The axis to use for maxClimb.  
float  maxSlope = 90 
The max slope in degrees for a node to be walkable.  
int  erodeIterations 
Erosion of the graph.  
bool  erosionUseTags 
Use tags instead of walkability for erosion.  
int  erosionFirstTag = 1 
Tag to start from when using tags for erosion.  
bool  autoLinkGrids 
Auto link the graph's edge nodes together with other GridGraphs in the scene on Scan.  
float  autoLinkDistLimit = 10F 
Distance limit for grid graphs to be auto linked.  
NumNeighbours  neighbours = NumNeighbours.Eight 
Number of neighbours for each node.  
bool  cutCorners = true 
If disabled, will not cut corners on obstacles.  
float  penaltyPositionOffset 
Offset for the position when calculating penalty.  
bool  penaltyPosition 
Use position (ycoordinate) to calculate penalty.  
float  penaltyPositionFactor = 1F 
Scale factor for penalty when calculating from position.  
bool  penaltyAngle 
float  penaltyAngleFactor = 100F 
How much penalty is applied depending on the slope of the terrain.  
float  penaltyAnglePower = 1 
How much extra to penalize very steep angles.  
bool  useJumpPointSearch 
TextureData  textureData = new TextureData() 
Holds settings for using a texture as source for a grid graph.  
Additional Inherited Members  
Package Functions inherited from NavGraph  
virtual void  UnloadGizmoMeshes () 
Called when temporary meshes used in OnDrawGizmos need to be unloaded to prevent memory leaks.  
GridGraph  (  ) 

static 
Calculates the grid connections for a single node.
Convenience function, it's faster to use CalculateConnections(int,int,GridNode) but that will only show when calculating for a large number of nodes.
Calculates the grid connections for a single node.

virtual 
Calculates the grid connections for a single node.
The x and z parameters are assumed to be the grid coordinates of the node.
GraphUpdateThreading CanUpdateAsync  (  GraphUpdateObject  o  ) 
bool CheckConnection  (  GridNode  node, 
int  dir  
) 
Returns if node is connected to it's neighbour in the specified direction.
This will also return true if neighbours = NumNeighbours.Four, the direction is diagonal and one can move through one of the adjacent nodes to the targeted node.

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

virtual 
Count nodes in the graph.
Note that this is, unless the graph type has overriden it, an O(n) operation.
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.

staticprotected 
Magnitude of the cross product a x b.

virtual 
Deserializes graph type specific node data.
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.

virtual 
An old format for serializing settings.
Reimplemented from NavGraph.

virtual 
Erodes the walkable area.

virtual 
Erodes the walkable area.
xmin, zmin (inclusive)
xmax, zmax (exclusive)
Reimplemented in LayerGridGraph.

private 
True if the node has any blocked connections.
For 4 and 8 neighbours the 4 axis aligned connections will be checked. For 6 neighbours all 6 neighbours will be checked.
void GenerateMatrix  (  ) 
Generates the matrix used for translating nodes from grid coordinates to world coordintes.

staticprotected 
Calculates minimum and maximum points for bounds b when multiplied with the matrix.
uint GetConnectionCost  (  int  dir  ) 

virtual 
Returns the nearest node to a position using the specified NNConstraint.
position  The position to try to find a close node to 
hint  Can be passed to enable some graph generators to find the nearest node faster. 
constraint  Can for example tell the function to try to return a walkable node. If you do not get a good node back, consider calling GetNearestForce. 
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.

virtual 
Returns the nearest node to a position using the specified constraint .
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.

protectedvirtual 
Utility method used by Linecast.
Required since LevelGridNode does not inherit from GridNode. Lots of ugly casting but it was better than massive code duplication.
Returns null if the node has no connection in that direction.
Reimplemented in LayerGridGraph.

private 

virtual 
Calls a delegate with all nodes in the graph.
This is the primary way of "looping" through all nodes in a graph.
This function should not change anything in the graph structure.
Implements NavGraph.
Reimplemented in LayerGridGraph.
List<GraphNode> GetNodesInArea  (  Bounds  b  ) 
All nodes inside the bounding box.
List<GraphNode> GetNodesInArea  (  GraphUpdateShape  shape  ) 
All nodes inside the shape.

private 
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.
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 HasNodeConnection  (  GridNode  node, 
int  dir  
) 
bool HasNodeConnection  (  int  index, 
int  x,  
int  z,  
int  dir  
) 
Returns true if a connection between the adjacent nodes n1 and n2 is valid.
Also takes into account if the nodes are walkable.
This method may be overriden if you want to customize what connections are valid. It must however hold that IsValidConnection(a,b) == IsValidConnection(b,a).
This is used for calculating the connections when the graph is scanned or updated.
bool Linecast  (  Vector3  _a, 
Vector3  _b  
) 
Returns if there is an obstacle between origin and end on the graph.
This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.
bool Linecast  (  Vector3  _a, 
Vector3  _b,  
GraphNode  hint  
) 
Returns if there is an obstacle between origin and end on the graph.
[in]  _a  Point to linecast from 
[in]  _b  Point to linecast to 
[in]  hint  If you have some idea of what the start node might be (the one close to _a), pass it to hint since it can enable faster lookups This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

bool Linecast  (  Vector3  _a, 
Vector3  _b,  
GraphNode  hint,  
out GraphHitInfo  hit  
) 
Returns if there is an obstacle between origin and end on the graph.
[in]  _a  Point to linecast from 
[in]  _b  Point to linecast to 
[out]  hit  Contains info on what was hit, see GraphHitInfo 
[in]  hint  If you have some idea of what the start node might be (the one close to _a), pass it to hint since it can enable faster lookups This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

bool Linecast  (  Vector3  _a, 
Vector3  _b,  
GraphNode  hint,  
out GraphHitInfo  hit,  
List< GraphNode >  trace  
) 
Returns if there is an obstacle between _a and _b on the graph.
[in]  _a  Point to linecast from 
[in]  _b  Point to linecast to 
[out]  hit  Contains info on what was hit, see GraphHitInfo 
[in]  hint 
trace  If a list is passed, then it will be filled with all nodes the linecast traverses 
This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.
It uses a method similar to Bresenham's line algorithm but it has been extended to allow the start and end points to lie on noninteger coordinates (which makes the math a bit trickier).

virtual 
This function will be called when this graph is destroyed.
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.

virtual 
void OnPostScan  (  AstarPath  script  ) 

virtual 
Called after all deserialization has been done for all graphs.
Can be used to set up more graph data which is not serialized
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.
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.

private 

virtual 
Scans the graph, called from AstarPath.ScanLoop.
Override this function to implement custom scanning logic The statusCallback may be optionally called to show progress info in the editor
Implements NavGraph.
Reimplemented in LayerGridGraph.

virtual 
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.
Reimplemented from NavGraph.
Reimplemented in LayerGridGraph.
void SetNodeConnection  (  GridNode  node, 
int  dir,  
bool  value  
) 
void SetNodeConnection  (  int  index, 
int  x,  
int  z,  
int  dir,  
bool  value  
) 
Set if connection in the specified direction should be enabled.
Note that bounds checking will still be done when getting the connection value again, so it is not necessarily true that HasNodeConnection will return true just because you used SetNodeConnection on a node to set a connection to true.
index  Index of the node 
x  X coordinate of the node 
z  Z coordinate of the node 
value  Enable or disable the connection 

virtual 
Sets up neighbourOffsets with the current settings.
neighbourOffsets, neighbourCosts, neighbourXOffsets and neighbourZOffsets are set up.
The cost for a nondiagonal 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)
bool SnappedLinecast  (  Vector3  a, 
Vector3  b,  
GraphNode  hint,  
out GraphHitInfo  hit  
) 
Returns if there is an obstacle between and on the graph.
This function is different from the other Linecast functions since it 1) snaps the start and end positions directly to the graph.
[in]  a  Point to linecast from 
[in]  b  Point to linecast to 
[out]  hit  Contains info on what was hit, see GraphHitInfo 
[in]  hint 
This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.
void UpdateArea  (  GraphUpdateObject  o  ) 
Internal function to update an area of the graph.
void UpdateAreaInit  (  GraphUpdateObject  o  ) 

virtual 
Updates position, walkability and penalty for the node.
Assumes that collision.Initialize (...) has been called before this function
void UpdateSizeFromWidthDepth  (  ) 
Updates size from width, depth and nodeSize values.
Also generates a new matrix .
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
float autoLinkDistLimit = 10F 
Distance limit for grid graphs to be auto linked.
bool autoLinkGrids 
Auto link the graph's edge nodes together with other GridGraphs in the scene on Scan.
Vector3 center 
Center point of the grid.
GraphCollision collision 
Settings on how to check for walkability and height.
bool cutCorners = true 
If disabled, will not cut corners on obstacles.
If connections is Eight, obstacle corners might be cut by a connection, setting this to false disables that.
int depth 
Depth (height) of the grid in nodes.
int erodeIterations 
Erosion of the graph.
The graph can be eroded after calculation. This means a margin is put around unwalkable nodes or other unwalkable connections. It is really good if your graph contains ledges where the nodes without erosion are walkable too close to the edge.
Below is an image showing a graph with erode iterations 0, 1 and 2
int erosionFirstTag = 1 
Tag to start from when using tags for erosion.
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.
const int getNearestForceOverlap = 2 
In GetNearestForce, determines how far to search after a valid node has been found.

staticpackage 
Which neighbours are going to be used when neighbours=6.
float isometricAngle 
Angle 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.
Usually the angle that you want to use is either 30 degrees (alternatively 9030 = 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.
float maxClimb = 0.4F 
The max position difference between two nodes to enable a connection.
Set to 0 to ignore the value.
int maxClimbAxis = 1 
The axis to use for maxClimb.
X = 0, Y = 1, Z = 2.
float maxSlope = 90 
The max slope in degrees for a node to be walkable.
readonly uint [] neighbourCosts = new uint[8] 
Costs to neighbour nodes.
readonly int [] neighbourOffsets = new int[8] 
Index offset to get neighbour nodes.
Added to a node's index to get a neighbour node index.
NumNeighbours neighbours = NumNeighbours.Eight 
Number of neighbours for each node.
Either four, six, eight connections per node.
Six connections is primarily for emulating hexagon graphs.
readonly int [] neighbourXOffsets = new int[8] 
Offsets in the X direction for neighbour nodes.
Only 1, 0 or 1
readonly int [] neighbourZOffsets = new int[8] 
Offsets in the Z direction for neighbour nodes.
Only 1, 0 or 1
GridNode [] 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=width1, Z=depth1.
float nodeSize = 1 
Size of one node in world units.
bool penaltyAngle 
float penaltyAngleFactor = 100F 
How much penalty is applied depending on the slope of the terrain.
At a 90 degree slope (not that exactly 90 degree slopes can occur, but almost 90 degree), this penalty is applied. At a 45 degree slope, half of this is applied and so on. Note that you may require very large values, a value of 1000 is equivalent to the cost of moving 1 world unit.
float penaltyAnglePower = 1 
How much extra to penalize very steep angles.
bool penaltyPosition 
Use position (ycoordinate) to calculate penalty.
float penaltyPositionFactor = 1F 
Scale factor for penalty when calculating from position.
float penaltyPositionOffset 
Offset for the position when calculating penalty.
Vector3 rotation 
Rotation of the grid in degrees.
TextureData textureData = new TextureData() 
Holds settings for using a texture as source for a grid graph.
Texure data can be used for fine grained control over how the graph will look. It can be used for positioning, penalty and walkability control.
Below is a screenshot of a grid graph with a penalty map applied. It has the effect of the AI taking the longer path along the green (low penalty) areas.
Vector2 unclampedSize 
Size of the grid.
Might 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)
bool useJumpPointSearch 
int width 
Width of the grid in nodes.

getset 

getset 

getset 

get 
This is placed here so generators inheriting from this one can override it and set it to false.
If it is true, it means that the nodes array's length will always be equal to width*depth It is used mainly in the editor to do autoscanning calls, setting it to false for a nonuniform grid will reduce the number of scans

get 
Use heigh raycasting normal for max slope calculation.
True if maxSlope is less than 90 degrees.

getset 