Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.


Inherits: RefCounted < Object

An implementation of A* for finding the shortest path between two vertices on a connected graph in 3D space.


A* (A star) is a computer algorithm used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A* implementation uses points in 3D space and Euclidean distances by default.

You must add points manually with add_point and create segments manually with connect_points. Once done, you can test if there is a path between two points with the are_points_connected function, get a path containing indices by get_id_path, or one containing actual coordinates with get_point_path.

It is also possible to use non-Euclidean distances. To do so, create a class that extends AStar3D and override methods _compute_cost and _estimate_cost. Both take two indices and return a length, as is shown in the following example.

class MyAStar:
    extends AStar3D

    func _compute_cost(u, v):
        return abs(u - v)

    func _estimate_cost(u, v):
        return min(0, abs(u - v) - 1)

_estimate_cost should return a lower bound of the distance, i.e. _estimate_cost(u, v) <= _compute_cost(u, v). This serves as a hint to the algorithm because the custom _compute_cost might be computation-heavy. If this is not the case, make _estimate_cost return the same value as _compute_cost to provide the algorithm with the most accurate information.

If the default _estimate_cost and _compute_cost methods are used, or if the supplied _estimate_cost method returns a lower bound of the cost, then the paths returned by A* will be the lowest-cost paths. Here, the cost of a path equals the sum of the _compute_cost results of all segments in the path multiplied by the weight_scales of the endpoints of the respective segments. If the default methods are used and the weight_scales of all points are set to 1.0, then this equals the sum of Euclidean distances of all segments in the path.



_compute_cost(from_id: int, to_id: int) virtual const


_estimate_cost(from_id: int, to_id: int) virtual const


add_point(id: int, position: Vector3, weight_scale: float = 1.0)


are_points_connected(id: int, to_id: int, bidirectional: bool = true) const




connect_points(id: int, to_id: int, bidirectional: bool = true)


disconnect_points(id: int, to_id: int, bidirectional: bool = true)


get_available_point_id() const


get_closest_point(to_position: Vector3, include_disabled: bool = false) const