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.

Checking the stable version of the documentation...

AStar2D

Hereda: RefCounted < Object

Una implementación de A* para encontrar el camino más corto entre dos vértices en un grafo conectado en un espacio 2D.

Descripción

Una implementación del algoritmo A*, utilizado para encontrar el camino más corto entre dos vértices en un grafo conectado en un espacio 2D.

Véase AStar3D para obtener una explicación más detallada sobre cómo usar esta clase. AStar2D es un envoltorio para AStar3D que aplica coordenadas 2D.

Tutoriales

Demo de Navegación basada en cuadrícula con AStarGrid2D

Propiedades

bool

neighbor_filter_enabled

false

Métodos

float	_compute_cost(from_id: int, to_id: int) virtual const
float	_estimate_cost(from_id: int, end_id: int) virtual const
bool	_filter_neighbor(from_id: int, neighbor_id: int) virtual const
void	add_point(id: int, position: Vector2, weight_scale: float = 1.0)
bool	are_points_connected(id: int, to_id: int, bidirectional: bool = true) const
void	clear()
void	connect_points(id: int, to_id: int, bidirectional: bool = true)
void	disconnect_points(id: int, to_id: int, bidirectional: bool = true)
int	get_available_point_id() const
int	get_closest_point(to_position: Vector2, include_disabled: bool = false) const
Vector2	get_closest_position_in_segment(to_position: Vector2) const
PackedInt64Array	get_id_path(from_id: int, to_id: int, allow_partial_path: bool = false)
int	get_point_capacity() const
PackedInt64Array	get_point_connections(id: int)
int	get_point_count() const
PackedInt64Array	get_point_ids()
PackedVector2Array	get_point_path(from_id: int, to_id: int, allow_partial_path: bool = false)
Vector2	get_point_position(id: int) const
float	get_point_weight_scale(id: int) const
bool	has_point(id: int) const
bool	is_point_disabled(id: int) const
void	remove_point(id: int)
void	reserve_space(num_nodes: int)
void	set_point_disabled(id: int, disabled: bool = true)
void	set_point_position(id: int, position: Vector2)
void	set_point_weight_scale(id: int, weight_scale: float)

Descripciones de Propiedades

bool neighbor_filter_enabled = false 🔗

void set_neighbor_filter_enabled(value: bool)
bool is_neighbor_filter_enabled()

Si es true, habilita el filtrado de vecinos a través de _filter_neighbor().

Descripciones de Métodos

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

Llamado al calcular el coste entre dos puntos conectados.

Ten en cuenta que esta función está oculta en la clase AStar2D por defecto.

float _estimate_cost(from_id: int, end_id: int) virtual const 🔗

Se llama cuando se calcula el coste entre un punto y punto final de un trayecto.

Nota que esta función está oculta en la clase AStar2D por defecto.

bool _filter_neighbor(from_id: int, neighbor_id: int) virtual const 🔗

Llamado cuando un vecino entra en el procesamiento y si neighbor_filter_enabled es true. Si se devuelve true, el punto no se procesará.

Ten en cuenta que esta función está oculta en la clase AStar2D por defecto.

void add_point(id: int, position: Vector2, weight_scale: float = 1.0) 🔗

Añade un nuevo punto en la posición dada con el identificador dado. El id debe ser 0 o mayor, y el weight_scale debe ser 0.0 o mayor.

El weight_scale se multiplica por el resultado de _compute_cost() al determinar el costo total de viajar a través de un segmento desde un punto vecino hasta este punto. Por lo tanto, si todo lo demás es igual, el algoritmo prefiere puntos con weight_scale más bajos para formar una ruta.

var astar = AStar2D.new()
astar.add_point(1, Vector2(1, 0), 4) # Adds the point (1, 0) with weight_scale 4 and id 1

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(1, 0), 4); // Adds the point (1, 0) with weight_scale 4 and id 1

Si ya existe un punto para el id dado, su posición y escala de peso se actualizan a los valores dados.

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

Devuelve si existe una conexión/segmento entre los puntos dados. Si bidirectional es false, devuelve si el movimiento desde id a to_id es posible a través de este segmento.

void clear() 🔗

Limpia todos los puntos y segmentos.

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

Crea un segmento entre los puntos dados. Si bidirectional es false, solo se permite el movimiento desde id hacia to_id, no en la dirección inversa.

var astar = AStar2D.new()
astar.add_point(1, Vector2(1, 1))
astar.add_point(2, Vector2(0, 5))
astar.connect_points(1, 2, false)

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(1, 1));
astar.AddPoint(2, new Vector2(0, 5));
astar.ConnectPoints(1, 2, false);

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

Elimina el segmento entre los puntos dados. Si bidirectional es false, solo el movimiento desde id a to_id se impide, y un segmento unidireccional posiblemente permanece.

int get_available_point_id() const 🔗

Devuelve el punto de Ide proximo disponible con ningun punto asociado a el.

int get_closest_point(to_position: Vector2, include_disabled: bool = false) const 🔗

Devuelve el ID del punto más cercano a to_position, opcionalmente teniendo en cuenta los puntos desactivados. Devuelve -1 si no hay puntos en el grupo de puntos.

Nota: Si varios puntos son los más cercanos a to_position, se devolverá el que tenga el ID más pequeño, lo que garantiza un resultado determinista.

Vector2 get_closest_position_in_segment(to_position: Vector2) const 🔗

Devuelve la posición más cercana a to_position que reside dentro de un segmento entre dos puntos conectados.

var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 5))
astar.connect_points(1, 2)
var res = astar.get_closest_position_in_segment(Vector2(3, 3)) # Returns (0, 3)

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(0, 0));
astar.AddPoint(2, new Vector2(0, 5));
astar.ConnectPoints(1, 2);
Vector2 res = astar.GetClosestPositionInSegment(new Vector2(3, 3)); // Returns (0, 3)

El resultado está en el segmento que va desde y = 0 hasta y = 5. Es la posición más cercana en el segmento al punto dado.

PackedInt64Array get_id_path(from_id: int, to_id: int, allow_partial_path: bool = false) 🔗

Devuelve un array con los IDs de los puntos que forman la ruta encontrada por AStar2D entre los puntos dados. El array está ordenado desde el punto de inicio hasta el punto final de la ruta.

Si el punto from_id está desactivado, devuelve un array vacío (incluso si from_id == to_id).

Si el punto from_id no está desactivado, no hay una ruta válida al objetivo y allow_partial_path es true, devuelve una ruta al punto más cercano al objetivo que se puede alcanzar.

Nota: Cuando allow_partial_path es true y to_id está desactivado, la búsqueda puede tardar un tiempo inusualmente largo en finalizar.

var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 1), 1) # Default weight is 1
astar.add_point(3, Vector2(1, 1))
astar.add_point(4, Vector2(2, 0))

astar.connect_points(1, 2, false)
astar.connect_points(2, 3, false)
astar.connect_points(4, 3, false)
astar.connect_points(1, 4, false)

var res = astar.get_id_path(1, 3) # Returns [1, 2, 3]

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(0, 0));
astar.AddPoint(2, new Vector2(0, 1), 1); // Default weight is 1
astar.AddPoint(3, new Vector2(1, 1));
astar.AddPoint(4, new Vector2(2, 0));

astar.ConnectPoints(1, 2, false);
astar.ConnectPoints(2, 3, false);
astar.ConnectPoints(4, 3, false);
astar.ConnectPoints(1, 4, false);
long[] res = astar.GetIdPath(1, 3); // Returns [1, 2, 3]

Si cambias el peso del segundo punto a 3, entonces el resultado será [1, 4, 3] en su lugar, porque ahora, aunque la distancia es mayor, es "más fácil" pasar por el punto 4 que por el punto 2.

int get_point_capacity() const 🔗

Devuelve la capacidad de la estructura que respalda los puntos, útil en conjunto con reserve_space().

PackedInt64Array get_point_connections(id: int) 🔗

Devuelve un array con los IDs de los puntos que forman la conexión con el punto dado.

var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 1))
astar.add_point(3, Vector2(1, 1))
astar.add_point(4, Vector2(2, 0))

astar.connect_points(1, 2, true)
astar.connect_points(1, 3, true)

var neighbors = astar.get_point_connections(1) # Returns [2, 3]

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(0, 0));
astar.AddPoint(2, new Vector2(0, 1));
astar.AddPoint(3, new Vector2(1, 1));
astar.AddPoint(4, new Vector2(2, 0));

astar.ConnectPoints(1, 2, true);
astar.ConnectPoints(1, 3, true);

long[] neighbors = astar.GetPointConnections(1); // Returns [2, 3]

int get_point_count() const 🔗

Devuelve el número de puntos actualmente en el grupo(pool) de puntos.

PackedInt64Array get_point_ids() 🔗

Devuelve un array de todos los ID de los puntos.

PackedVector2Array get_point_path(from_id: int, to_id: int, allow_partial_path: bool = false) 🔗

Devuelve un array con los puntos que están en la ruta encontrada por AStar2D entre los puntos dados. El array está ordenado desde el punto de inicio hasta el punto final de la ruta.

Si el punto from_id está desactivado, devuelve un array vacío (incluso si from_id == to_id).

Si el punto from_id no está desactivado, no hay una ruta válida al objetivo y allow_partial_path es true, devuelve una ruta al punto más cercano al objetivo que se puede alcanzar.

Nota: Este método no es seguro para hilos; solo puede usarse desde un único Thread a la vez. Considera usar Mutex para asegurar el acceso exclusivo de un hilo y evitar condiciones de carrera.

Adicionalmente, cuando allow_partial_path es true y to_id está desactivado, la búsqueda puede tardar un tiempo inusualmente largo en finalizar.

Vector2 get_point_position(id: int) const 🔗

Devuelve la posición del punto asociado con el id dado.

float get_point_weight_scale(id: int) const 🔗

Devuelve la escala de peso del punto asociado con el id dado.

bool has_point(id: int) const 🔗

Devuelve si existe un punto asociado con el id dado.

bool is_point_disabled(id: int) const 🔗

Devuelve si un punto esta deshabilitado or no para el buscador de rutas. Por defecto, todos los puntos estan habilitados.

void remove_point(id: int) 🔗

Elimina el punto asociado con el id dado del grupo de puntos.

void reserve_space(num_nodes: int) 🔗

Reserva espacio internamente para num_nodes puntos. Útil si vas a añadir un número grande conocido de puntos a la vez, como puntos en una cuadrícula.

void set_point_disabled(id: int, disabled: bool = true) 🔗

Deshabilita o habilita el punto especificado para el buscador de rutas. Util para crear obstaculos temporales.

void set_point_position(id: int, position: Vector2) 🔗

Establece la position para el punto con el id dado.

void set_point_weight_scale(id: int, weight_scale: float) 🔗

Establece el weight_scale para el punto con el id dado. El weight_scale se multiplica por el resultado de _compute_cost() al determinar el coste total de viajar a través de un segmento desde un punto vecino a este punto.