Generates a grid of nodes. More...

Detailed Description

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:

You can update the graph during runtime (good for e.g Tower Defence or RTS games)
Throw any scene at it, with minimal configurations you can get a good graph from it.
Supports raycast and the funnel algorithm
Predictable pattern
Can apply penalty and walkability values from a supplied image
Perfect for terrain worlds since it can make areas unwalkable depending on the slope

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:

AstarPath.active.UpdateGraphs (ob.collider.bounds);

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

See Also: Graph Updates during Runtime for more info about updating Graph Types during runtime

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 90-atan(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

// This holds all graph data
AstarData data = AstarPath.active.data;
// This creates a Grid Graph
GridGraph gg = data.AddGraph(typeof(GridGraph)) as GridGraph;
// Setup a grid graph with some values
int width = 50;
int depth = 50;
float nodeSize = 1;
gg.center = new Vector3 (10,0,0);
// Updates internal size from the above values
gg.SetDimensions(width, depth, nodeSize);
// Scans all graphs, do not call gg.Scan(), that is an internal method
AstarPath.active.Scan();

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

See Also: Pathfinding.GraphCollision for documentation on the 'Height Testing' and 'Collision Testing' sections of the grid graph settings.

Classes
class	TextureData
	Used for using a texture as a source for a grid graph. More...

Public Member Functions
	GridGraph ()

virtual void	CalculateConnections (GridNodeBase node)
	Calculates the grid connections for a single node.

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.

virtual void	CalculateConnections (int x, int z)
	Calculates the grid connections for a single node.

GraphTransform	CalculateTransform ()
	Returns a new transform which transforms graph space to world space.

bool	CheckConnection (GridNode node, int dir)
	Returns if node is connected to it's neighbour in the specified direction.

override int	CountNodes ()
	Number of nodes in the graph.

virtual void	ErodeWalkableArea ()
	Erodes the walkable area.

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

uint	GetConnectionCost (int dir)

override NNInfoInternal	GetNearest (Vector3 position, NNConstraint constraint, GraphNode hint)
	Returns the nearest node to a position using the specified NNConstraint.

override NNInfoInternal	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 (System.Action< GraphNode > action)
	Calls a delegate with all nodes in the graph.

List< GraphNode >	GetNodesInArea (Bounds bounds)

List< GraphNode >	GetNodesInArea (GraphUpdateShape shape)

List< GraphNode >	GetNodesInArea (Bounds bounds, GraphUpdateShape shape)

List< GraphNode >	GetNodesInRegion (Bounds bounds)
	All nodes inside the bounding box.

List< GraphNode >	GetNodesInRegion (GraphUpdateShape shape)
	All nodes inside the shape.

virtual List< GraphNode >	GetNodesInRegion (IntRect rect)
	Get all nodes in a rectangle.

virtual int	GetNodesInRegion (IntRect rect, GridNodeBase[] buffer)
	Get all nodes in a rectangle.

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 (GridNodeBase node1, GridNodeBase node2)
	Returns true if a connection between the adjacent nodes n1 and n2 is valid.

bool	Linecast (Vector3 from, Vector3 to)
	Returns if there is an obstacle between from and to on the graph.

bool	Linecast (Vector3 from, Vector3 to, GraphNode hint)
	Returns if there is an obstacle between from and to on the graph.

bool	Linecast (Vector3 from, Vector3 to, GraphNode hint, out GraphHitInfo hit)
	Returns if there is an obstacle between from and to on the graph.

bool	Linecast (Vector3 from, Vector3 to, GraphNode hint, out GraphHitInfo hit, List< GraphNode > trace)
	Returns if there is an obstacle between from and to on the graph.

override void	OnDrawGizmos (RetainedGizmos gizmos, bool drawNodes)
	Draw gizmos for the graph.

virtual void	RecalculateCell (int x, int z, bool resetPenalties=true, bool resetTags=true)
	Recalculates single node in the graph.

override void	RelocateNodes (Matrix4x4 deltaMatrix)
	Moves the nodes in this graph.

void	RelocateNodes (Vector3 center, Quaternion rotation, float nodeSize, float aspectRatio=1, float isometricAngle=0)
	Relocate the grid graph using new settings.

void	SetDimensions (int width, int depth, float nodeSize)
	Updates unclampedSize from width, depth and nodeSize values.

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 from, Vector3 to, GraphNode hint, out GraphHitInfo hit)
	Returns if there is an obstacle between from and to on the graph.

virtual void	UpdateNodePositionCollision (GridNode node, int x, int z, bool resetPenalty=true)
	Updates position, walkability and penalty for the node.

void	UpdateSizeFromWidthDepth ()
	Updates unclampedSize from width, depth and nodeSize values.

void	UpdateTransform ()
	Updates the transform field which transforms graph space to world space.

Public Member Functions inherited from NavGraph
NNInfoInternal	GetNearest (Vector3 position)
	Returns the nearest node to a position using the default NNConstraint.

NNInfoInternal	GetNearest (Vector3 position, NNConstraint constraint)
	Returns the nearest node to a position using the specified NNConstraint.

void	GetNodes (System.Func< GraphNode, bool > action)
	Calls a delegate with all nodes in the graph until the delegate returns false.

void	RelocateNodes (Matrix4x4 oldMatrix, Matrix4x4 newMatrix)
	Moves nodes in this graph.

void	Scan ()
	Scan the graph.

void	ScanGraph ()
	Scan the graph.

void	SetMatrix (Matrix4x4 m)
	Use to set both matrix and inverseMatrix at the same time.

Public Member Functions inherited from IGraphInternals
void	DeserializeExtraInfo (GraphSerializationContext ctx)

void	DeserializeSettingsCompatibility (GraphSerializationContext ctx)

void	DestroyAllNodes ()

void	OnDestroy ()

void	PostDeserialization (GraphSerializationContext ctx)

IEnumerable< Progress >	ScanInternal ()

void	SerializeExtraInfo (GraphSerializationContext ctx)

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)
	May be called on the Unity thread before starting the update.

void	UpdateAreaPost (GraphUpdateObject o)
	May be called on the Unity thread after executing the update.

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.

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
	Enable to draw gizmos in the Unity scene view.

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
void	CalculateAffectedRegions (GraphUpdateObject o, out IntRect originalRect, out IntRect affectRect, out IntRect physicsRect, out bool willChangeWalkability, out int erosion)

bool	ClipLineSegmentToBounds (Vector3 a, Vector3 b, out Vector3 outA, out Vector3 outB)
	Clips a line segment in graph space to the graph bounds.

override void	DeserializeExtraInfo (GraphSerializationContext ctx)
	Deserializes graph type specific node data.

override void	DeserializeSettingsCompatibility (GraphSerializationContext ctx)
	An old format for serializing settings.

override void	DestroyAllNodes ()
	Destroys all nodes in the graph.

virtual bool	ErosionAnyFalseConnections (GraphNode baseNode)
	True if the node has any blocked connections.

virtual List< GraphNode >	GetNodesInRegion (Bounds bounds, GraphUpdateShape shape)
	All nodes inside the shape or if null, the bounding box.

IntRect	GetRectFromBounds (Bounds bounds)
	A rect with all nodes that the bounds could touch.

override void	OnDestroy ()
	This function will be called when this graph is destroyed.

override void	PostDeserialization (GraphSerializationContext ctx)
	Called after all deserialization has been done for all graphs.

override IEnumerable< Progress >	ScanInternal ()
	Internal method to scan the graph.

override void	SerializeExtraInfo (GraphSerializationContext ctx)
	Serializes graph type specific node data.

Protected Member Functions inherited from NavGraph
void	DrawUnwalkableNodes (float size)

Static Protected Member Functions
static float	CrossMagnitude (Vector2 a, Vector2 b)
	Magnitude of the cross product a x b.

Static Package Attributes
static readonly int[]	hexagonNeighbourIndices = { 0, 1, 5, 2, 3, 7 }
	Which neighbours are going to be used when neighbours=6.

Properties
int	Depth `[get, set]`

virtual int	LayerCount `[get]`
	Number of layers in the graph.

Vector2	size `[get, set]`
	Size of the grid.

GraphTransform	transform `[get, set]`
	Determines how the graph transforms graph space to world space.

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]`

Properties inherited from NavGraph
bool	exists `[get]`
	True if the graph exists, false if it has been destroyed.

Properties inherited from ITransformedGraph
GraphTransform	transform `[get]`

Private Member Functions
void	CalculateDimensions (out int width, out int depth, out float nodeSize)
	Calculates the width/depth of the graph from unclampedSize and nodeSize.

GraphUpdateThreading IUpdatableGraph.	CanUpdateAsync (GraphUpdateObject o)

void	CreateNavmeshSurfaceVisualization (GridNodeBase[] nodes, int nodeCount, GraphGizmoHelper helper)
	Draw the surface as well as an outline of the grid graph.

void	ErodeNode (GraphNode node)
	Internal method used for erosion.

void	ErodeNodeWithTags (GraphNode node, int iteration)
	Internal method used for erosion.

void	ErodeNodeWithTagsInit (GraphNode node)
	Internal method used for erosion.

GridNode	GetNodeConnection (int index, int x, int z, int dir)
	Get the connecting node from the node at (x,z) in the specified direction.

void	RemoveGridGraphFromStatic ()

void IUpdatableGraph.	UpdateArea (GraphUpdateObject o)
	Internal function to update an area of the graph.

void IUpdatableGraph.	UpdateAreaInit (GraphUpdateObject o)

void IUpdatableGraph.	UpdateAreaPost (GraphUpdateObject o)

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.

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.

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

bool	showMeshOutline = true
	Show an outline of the grid nodes in the Unity Editor.

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

bool	showMeshSurface = true
	Show the surface of the graph.

TextureData	textureData = new TextureData()
	Holds settings for using a texture as source for a grid graph.

Constructor & Destructor Documentation

GridGraph ( )

Member Function Documentation

void CalculateAffectedRegions	(	GraphUpdateObject	o,
		out IntRect	originalRect,
		out IntRect	affectRect,
		out IntRect	physicsRect,
		out bool	willChangeWalkability,
		out int	erosion
	)

protected

static void CalculateConnections ( GridNode node )

static