Inheritance #

AStarGrid2D #

is_refcounted, is_instantiable, core, not_builtin_classes

An implementation of A* for finding the shortest path between two points on a partial 2D grid.

AStarGrid2D is a variant of AStar2D that is specialized for partial 2D grids. It is simpler to use because it doesn't require you to manually create points and connect them together. This class also supports multiple types of heuristics, modes for diagonal movement, and a jumping mode to speed up calculations.

To use AStarGrid2D, you only need to set the region of the grid, optionally set the cell_size, and then call the update method:

GDScript

var astar_grid = AStarGrid2D.new()
astar_grid.region = Rect2i(0, 0, 32, 32)
astar_grid.cell_size = Vector2(16, 16)
astar_grid.update()
print(astar_grid.get_id_path(Vector2i(0, 0), Vector2i(3, 4))) # Prints [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
print(astar_grid.get_point_path(Vector2i(0, 0), Vector2i(3, 4))) # Prints [(0, 0), (16, 16), (32, 32), (48, 48), (48, 64)]

C#

AStarGrid2D astarGrid = new AStarGrid2D();
astarGrid.Region = new Rect2I(0, 0, 32, 32);
astarGrid.CellSize = new Vector2I(16, 16);
astarGrid.Update();
GD.Print(astarGrid.GetIdPath(Vector2I.Zero, new Vector2I(3, 4))); // Prints [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
GD.Print(astarGrid.GetPointPath(Vector2I.Zero, new Vector2I(3, 4))); // Prints [(0, 0), (16, 16), (32, 32), (48, 48), (48, 64)]

To remove a point from the pathfinding grid, it must be set as "solid" with set_point_solid.

Members #

var cell_shape = CELL_SHAPE_SQUARE#

The cell shape. Affects how the positions are placed in the grid. If changed, update needs to be called before finding the next path.

var cell_size: Vector2 = Vector2(1, 1)#

The size of the point cell which will be applied to calculate the resulting point position returned by get_point_path. If changed, update needs to be called before finding the next path.

var default_compute_heuristic = HEURISTIC_EUCLIDEAN#

The default Heuristic which will be used to calculate the cost between two points if _compute_cost was not overridden.

var default_estimate_heuristic = HEURISTIC_EUCLIDEAN#

The default Heuristic which will be used to calculate the cost between the point and the end point if _estimate_cost was not overridden.

var diagonal_mode = DIAGONAL_MODE_ALWAYS#

A specific DiagonalMode mode which will force the path to avoid or accept the specified diagonals.

var jumping_enabled: bool = false#

Enables or disables jumping to skip up the intermediate points and speeds up the searching algorithm.

Note: Currently, toggling it on disables the consideration of weight scaling in pathfinding.

var offset: Vector2 = Vector2(0, 0)#

The offset of the grid which will be applied to calculate the resulting point position returned by get_point_path. If changed, update needs to be called before finding the next path.

var region: Rect2i = Rect2i(0, 0, 0, 0)#

The region of grid cells available for pathfinding. If changed, update needs to be called before finding the next path.

var size: Vector2i = Vector2i(0, 0)#

The size of the grid (number of cells of size cell_size on each axis). If changed, update needs to be called before finding the next path.

Methods #

Annotations #

Constants #

const HEURISTIC_EUCLIDEAN = 0 enum Heuristic#

The Euclidean heuristic to be used for the pathfinding using the following formula:

dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
result = sqrt(dx * dx + dy * dy)

Note: This is also the internal heuristic used in AStar3D and AStar2D by default (with the inclusion of possible z-axis coordinate).

const HEURISTIC_MANHATTAN = 1 enum Heuristic#

The Manhattan heuristic to be used for the pathfinding using the following formula:

dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
result = dx + dy

Note: This heuristic is intended to be used with 4-side orthogonal movements, provided by setting the diagonal_mode to DIAGONAL_MODE_NEVER.

const HEURISTIC_OCTILE = 2 enum Heuristic#

The Octile heuristic to be used for the pathfinding using the following formula:

dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
f = sqrt(2) - 1
result = (dx < dy) ? f * dx + dy : f * dy + dx;

const HEURISTIC_CHEBYSHEV = 3 enum Heuristic#

The Chebyshev heuristic to be used for the pathfinding using the following formula:

dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
result = max(dx, dy)

const HEURISTIC_MAX = 4 enum Heuristic#

Represents the size of the Heuristic enum.

const DIAGONAL_MODE_ALWAYS = 0 enum DiagonalMode#

The pathfinding algorithm will ignore solid neighbors around the target cell and allow passing using diagonals.

const DIAGONAL_MODE_NEVER = 1 enum DiagonalMode#

The pathfinding algorithm will ignore all diagonals and the way will be always orthogonal.

const DIAGONAL_MODE_AT_LEAST_ONE_WALKABLE = 2 enum DiagonalMode#

The pathfinding algorithm will avoid using diagonals if at least two obstacles have been placed around the neighboring cells of the specific path segment.

const DIAGONAL_MODE_ONLY_IF_NO_OBSTACLES = 3 enum DiagonalMode#

The pathfinding algorithm will avoid using diagonals if any obstacle has been placed around the neighboring cells of the specific path segment.

const DIAGONAL_MODE_MAX = 4 enum DiagonalMode#

Represents the size of the DiagonalMode enum.

const CELL_SHAPE_SQUARE = 0 enum CellShape#

Rectangular cell shape.

const CELL_SHAPE_ISOMETRIC_RIGHT = 1 enum CellShape#

Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes up-right, and the vertical one goes down-right.

const CELL_SHAPE_ISOMETRIC_DOWN = 2 enum CellShape#

Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes down-right, and the vertical one goes down-left.

const CELL_SHAPE_MAX = 3 enum CellShape#

Represents the size of the CellShape enum.

Constructors #

Enums #

Heuristic#

DiagonalMode#

CellShape#

Operators #

Signals #

Theme Items #

Tutorials #