AStarGrid2D
Hereda: RefCounted < Object
Una implementación de A* para encontrar el camino más corto entre dos puntos en una cuadrícula 2D parcial.
Descripción
AStarGrid2D es una variante de AStar2D que se especializa en cuadrículas 2D parciales. Es más sencillo de usar porque no requiere que crees manualmente los puntos y los conectes. Esta clase también admite múltiples tipos de heurísticas, modos para el movimiento diagonal y un modo de salto para acelerar los cálculos.
Para usar AStarGrid2D, solo necesitas establecer la region de la cuadrícula, opcionalmente establecer el cell_size y luego llamar al método update():
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))) # Imprime [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
print(astar_grid.get_point_path(Vector2i(0, 0), Vector2i(3, 4))) # Imprime [(0, 0), (16, 16), (32, 32), (48, 48), (48, 64)]
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))); // Imprime [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
GD.Print(astarGrid.GetPointPath(Vector2I.Zero, new Vector2I(3, 4))); // Imprime [(0, 0), (16, 16), (32, 32), (48, 48), (48, 64)]
Para eliminar un punto de la cuadrícula de búsqueda de trayectos, debes establecerlo como "sólido" con set_point_solid().
Tutoriales
Propiedades
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Métodos
_compute_cost(from_id: Vector2i, to_id: Vector2i) virtual const |
|
_estimate_cost(from_id: Vector2i, end_id: Vector2i) virtual const |
|
void |
clear() |
void |
fill_solid_region(region: Rect2i, solid: bool = true) |
void |
fill_weight_scale_region(region: Rect2i, weight_scale: float) |
get_id_path(from_id: Vector2i, to_id: Vector2i, allow_partial_path: bool = false) |
|
get_point_data_in_region(region: Rect2i) const |
|
get_point_path(from_id: Vector2i, to_id: Vector2i, allow_partial_path: bool = false) |
|
get_point_position(id: Vector2i) const |
|
get_point_weight_scale(id: Vector2i) const |
|
is_dirty() const |
|
is_in_bounds(x: int, y: int) const |
|
is_in_boundsv(id: Vector2i) const |
|
is_point_solid(id: Vector2i) const |
|
void |
set_point_solid(id: Vector2i, solid: bool = true) |
void |
set_point_weight_scale(id: Vector2i, weight_scale: float) |
void |
update() |
Enumeraciones
enum Heuristic: 🔗
Heuristic HEURISTIC_EUCLIDEAN = 0
La heurística euclidiana que se utilizará para la búsqueda de trayectos utilizando la siguiente fórmula:
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
result = sqrt(dx * dx + dy * dy)
Nota: Esta es también la heurística interna utilizada en AStar3D y AStar2D por defecto (con la inclusión de la posible coordenada del eje z).
Heuristic HEURISTIC_MANHATTAN = 1
La heurística de Manhattan que se utilizará para la búsqueda de trayectos utilizando la siguiente fórmula:
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
result = dx + dy
Nota: Esta heurística está pensada para ser utilizada con movimientos ortogonales de 4 lados, proporcionados estableciendo diagonal_mode a DIAGONAL_MODE_NEVER.
Heuristic HEURISTIC_OCTILE = 2
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;
Heuristic HEURISTIC_CHEBYSHEV = 3
La heurística de Chebyshev que se utilizará para la búsqueda de trayectos utilizando la siguiente fórmula:
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
result = max(dx, dy)
Heuristic HEURISTIC_MAX = 4
Representa el tamaño del enum Heuristic.
enum DiagonalMode: 🔗
DiagonalMode DIAGONAL_MODE_ALWAYS = 0
El algoritmo de búsqueda de caminos ignorará los vecinos sólidos alrededor de la celda objetivo y permitirá pasar usando diagonales.
DiagonalMode DIAGONAL_MODE_NEVER = 1
El algoritmo de búsqueda de caminos ignorará todas las diagonales y el camino siempre será ortogonal.
DiagonalMode DIAGONAL_MODE_AT_LEAST_ONE_WALKABLE = 2
El algoritmo de búsqueda de caminos evitará el uso de diagonales si se han colocado al menos dos obstáculos alrededor de las celdas vecinas del segmento de ruta específico.
DiagonalMode DIAGONAL_MODE_ONLY_IF_NO_OBSTACLES = 3
El algoritmo de búsqueda de caminos evitará el uso de diagonales si se ha colocado algún obstáculo alrededor de las celdas vecinas del segmento de ruta específico.
DiagonalMode DIAGONAL_MODE_MAX = 4
Representa el tamaño del enum DiagonalMode.
enum CellShape: 🔗
CellShape CELL_SHAPE_SQUARE = 0
Forma de celda rectangular.
CellShape CELL_SHAPE_ISOMETRIC_RIGHT = 1
Forma de celda de diamante (para apariencia isométrica). Diseño de coordenadas de celda donde el eje horizontal va hacia arriba a la derecha, y el vertical hacia abajo a la derecha.
CellShape CELL_SHAPE_ISOMETRIC_DOWN = 2
Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes down-right, and the vertical one goes down-left.
CellShape CELL_SHAPE_MAX = 3
Representa el tamaño del enum CellShape.
Descripciones de Propiedades
La forma de la celda. Afecta a cómo se colocan las posiciones en la cuadrícula. Si se cambia, es necesario llamar a update() antes de encontrar el siguiente trayecto.
Vector2 cell_size = Vector2(1, 1) 🔗
El tamaño de la celda de punto que se aplicará para calcular la posición del punto resultante devuelta por get_point_path(). Si se cambia, es necesario llamar a update() antes de encontrar el siguiente trayecto.
Heuristic default_compute_heuristic = 0 🔗
La Heuristic predeterminada que se utilizará para calcular el coste entre dos puntos si _compute_cost() no se ha sobreescrito.
Heuristic default_estimate_heuristic = 0 🔗
La Heuristic predeterminada que se utilizará para calcular el coste entre el punto y el punto final si _estimate_cost() no se ha sobreescrito.
DiagonalMode diagonal_mode = 0 🔗
void set_diagonal_mode(value: DiagonalMode)
DiagonalMode get_diagonal_mode()
Un modo DiagonalMode específico que forzará a la ruta a evitar o aceptar las diagonales especificadas.
bool jumping_enabled = false 🔗
Activa o desactiva el salto para omitir los puntos intermedios y acelera el algoritmo de búsqueda.
Nota: Actualmente, activarlo desactiva la consideración del escalado de peso en la búsqueda de trayectos.
Vector2 offset = Vector2(0, 0) 🔗
El desplazamiento de la cuadrícula que se aplicará para calcular la posición del punto resultante devuelta por get_point_path(). Si se cambia, es necesario llamar a update() antes de encontrar el siguiente trayecto.
Rect2i region = Rect2i(0, 0, 0, 0) 🔗
La región de celdas de la cuadrícula disponibles para la búsqueda de trayectos. Si se cambia, es necesario llamar a update() antes de encontrar el siguiente trayecto.
Vector2i size = Vector2i(0, 0) 🔗
Obsoleto: Use region instead.
El tamaño de la cuadrícula (número de celdas de tamaño cell_size en cada eje). Si se cambia, es necesario llamar a update() antes de encontrar el siguiente trayecto.
Descripciones de Métodos
float _compute_cost(from_id: Vector2i, to_id: Vector2i) virtual const 🔗
Llamado al calcular el coste entre dos puntos conectados.
Ten en cuenta que esta función está oculta en la clase AStarGrid2D por defecto.
float _estimate_cost(from_id: Vector2i, end_id: Vector2i) virtual const 🔗
Llamado al estimar el coste entre un punto y el punto final del camino.
Ten en cuenta que esta función está oculta en la clase AStarGrid2D por defecto.
void clear() 🔗
Limpia la cuadrícula y establece region a Rect2i(0, 0, 0, 0).
void fill_solid_region(region: Rect2i, solid: bool = true) 🔗
Rellena la region dada en la cuadrícula con el valor especificado para la bandera de sólido.
Nota: No es necesario llamar a update() después de la llamada a esta función.
void fill_weight_scale_region(region: Rect2i, weight_scale: float) 🔗
Rellena la region dada en la cuadrícula con el valor especificado para la escala de peso.
Nota: No es necesario llamar a update() después de la llamada a esta función.
Array[Vector2i] get_id_path(from_id: Vector2i, to_id: Vector2i, allow_partial_path: bool = false) 🔗
Devuelve un array con los ID de los puntos que forman el camino encontrado por AStar2D entre los puntos dados. El array se ordena desde el punto de inicio hasta el punto final del trayecto.
Si no hay un trayecto válido hacia el objetivo, y allow_partial_path es true, devuelve un camino al punto más cercano al objetivo que se puede alcanzar.
Nota: Cuando allow_partial_path es true y to_id es sólido, la búsqueda puede tardar un tiempo inusualmente largo en finalizar.
Array[Dictionary] get_point_data_in_region(region: Rect2i) const 🔗
Devuelve un array de diccionarios con información de los puntos (id: Vector2i, position: Vector2, solid: bool, weight_scale: float) dentro de una region.
PackedVector2Array get_point_path(from_id: Vector2i, to_id: Vector2i, allow_partial_path: bool = false) 🔗
Devuelve un array con los puntos que están en la ruta encontrada por AStarGrid2D entre los puntos dados. El array se ordena desde el punto de inicio hasta el punto final del camino.
Si no hay un camino válido hacia el objetivo, y allow_partial_path es true, devuelve un camino al punto más cercano al objetivo que se puede alcanzar.
Nota: Este método no es seguro para hilos; solo se puede usar desde un único Thread a la vez. Considera usar Mutex para asegurar el acceso exclusivo a un hilo para evitar condiciones de carrera.
Adicionalmente, cuando allow_partial_path es true y to_id es sólido, la búsqueda puede tardar un tiempo inusualmente largo en finalizar.
Vector2 get_point_position(id: Vector2i) const 🔗
Devuelve la posición del punto asociado con el id dado.
float get_point_weight_scale(id: Vector2i) const 🔗
Devuelve la escala de peso del punto asociado con el id dado.
Indica que los parámetros de la cuadrícula se han cambiado y que es necesario llamar a update().
bool is_in_bounds(x: int, y: int) const 🔗
Devuelve true si x e y son coordenadas de cuadrícula válidas (id), es decir, si están dentro de region. Equivalente a region.has_point(Vector2i(x, y)).
bool is_in_boundsv(id: Vector2i) const 🔗
Devuelve true si el vector id es una coordenada de cuadrícula válida, es decir, si está dentro de region. Equivalente a region.has_point(id).
bool is_point_solid(id: Vector2i) const 🔗
Devuelve true si un punto está deshabilitado para la búsqueda de trayectos. Por defecto, todos los puntos están habilitados.
void set_point_solid(id: Vector2i, solid: bool = true) 🔗
Deshabilita o habilita el punto especificado para la búsqueda de trayectos. Útil para crear un obstáculo. Por defecto, todos los puntos están habilitados.
Nota: No es necesario llamar a update() después de llamar a esta función.
void set_point_weight_scale(id: Vector2i, 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 general de viajar a través de un segmento desde un punto vecino a este punto.
Nota: No es necesario llamar a update() después de llamar a esta función.
void update() 🔗
Actualiza el estado interno de la cuadrícula de acuerdo con los parámetros para prepararla para buscar la ruta. Necesita ser llamado si los parámetros como region, cell_size o offset cambian. is_dirty() devolverá true si este es el caso y esto necesita ser llamado.
Nota: Todos los datos de los puntos (solidez y escala de peso) se borrarán.