godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/es/class_astargrid2d.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

705 lines
38 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_AStarGrid2D:
AStarGrid2D
===========
**Hereda:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Una implementación de A\* para encontrar el camino más corto entre dos puntos en una cuadrícula 2D parcial.
.. rst-class:: classref-introduction-group
Descripción
----------------------
**AStarGrid2D** es una variante de :ref:`AStar2D<class_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 :ref:`region<class_AStarGrid2D_property_region>` de la cuadrícula, opcionalmente establecer el :ref:`cell_size<class_AStarGrid2D_property_cell_size>` y luego llamar al método :ref:`update()<class_AStarGrid2D_method_update>`:
.. tabs::
.. code-tab:: 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))) # 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)]
.. code-tab:: csharp
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 :ref:`set_point_solid()<class_AStarGrid2D_method_set_point_solid>`.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- `Demo de Navegación basada en cuadrícula con AStarGrid2D <https://godotengine.org/asset-library/asset/2723>`__
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`CellShape<enum_AStarGrid2D_CellShape>` | :ref:`cell_shape<class_AStarGrid2D_property_cell_shape>` | ``0`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cell_size<class_AStarGrid2D_property_cell_size>` | ``Vector2(1, 1)`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`Heuristic<enum_AStarGrid2D_Heuristic>` | :ref:`default_compute_heuristic<class_AStarGrid2D_property_default_compute_heuristic>` | ``0`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`Heuristic<enum_AStarGrid2D_Heuristic>` | :ref:`default_estimate_heuristic<class_AStarGrid2D_property_default_estimate_heuristic>` | ``0`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` | :ref:`diagonal_mode<class_AStarGrid2D_property_diagonal_mode>` | ``0`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`bool<class_bool>` | :ref:`jumping_enabled<class_AStarGrid2D_property_jumping_enabled>` | ``false`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`offset<class_AStarGrid2D_property_offset>` | ``Vector2(0, 0)`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`Rect2i<class_Rect2i>` | :ref:`region<class_AStarGrid2D_property_region>` | ``Rect2i(0, 0, 0, 0)`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
| :ref:`Vector2i<class_Vector2i>` | :ref:`size<class_AStarGrid2D_property_size>` | ``Vector2i(0, 0)`` |
+----------------------------------------------------+------------------------------------------------------------------------------------------+------------------------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`_compute_cost<class_AStarGrid2D_private_method__compute_cost>`\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, to_id\: :ref:`Vector2i<class_Vector2i>`\ ) |virtual| |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`_estimate_cost<class_AStarGrid2D_private_method__estimate_cost>`\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, end_id\: :ref:`Vector2i<class_Vector2i>`\ ) |virtual| |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear<class_AStarGrid2D_method_clear>`\ (\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fill_solid_region<class_AStarGrid2D_method_fill_solid_region>`\ (\ region\: :ref:`Rect2i<class_Rect2i>`, solid\: :ref:`bool<class_bool>` = true\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fill_weight_scale_region<class_AStarGrid2D_method_fill_weight_scale_region>`\ (\ region\: :ref:`Rect2i<class_Rect2i>`, weight_scale\: :ref:`float<class_float>`\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] | :ref:`get_id_path<class_AStarGrid2D_method_get_id_path>`\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, to_id\: :ref:`Vector2i<class_Vector2i>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Dictionary<class_Dictionary>`\] | :ref:`get_point_data_in_region<class_AStarGrid2D_method_get_point_data_in_region>`\ (\ region\: :ref:`Rect2i<class_Rect2i>`\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`get_point_path<class_AStarGrid2D_method_get_point_path>`\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, to_id\: :ref:`Vector2i<class_Vector2i>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_point_position<class_AStarGrid2D_method_get_point_position>`\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_point_weight_scale<class_AStarGrid2D_method_get_point_weight_scale>`\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_dirty<class_AStarGrid2D_method_is_dirty>`\ (\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_in_bounds<class_AStarGrid2D_method_is_in_bounds>`\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_in_boundsv<class_AStarGrid2D_method_is_in_boundsv>`\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_point_solid<class_AStarGrid2D_method_is_point_solid>`\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_solid<class_AStarGrid2D_method_set_point_solid>`\ (\ id\: :ref:`Vector2i<class_Vector2i>`, solid\: :ref:`bool<class_bool>` = true\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_weight_scale<class_AStarGrid2D_method_set_point_weight_scale>`\ (\ id\: :ref:`Vector2i<class_Vector2i>`, weight_scale\: :ref:`float<class_float>`\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`update<class_AStarGrid2D_method_update>`\ (\ ) |
+------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_AStarGrid2D_Heuristic:
.. rst-class:: classref-enumeration
enum **Heuristic**: :ref:`🔗<enum_AStarGrid2D_Heuristic>`
.. _class_AStarGrid2D_constant_HEURISTIC_EUCLIDEAN:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **HEURISTIC_EUCLIDEAN** = ``0``
La `heurística euclidiana <https://en.wikipedia.org/wiki/Euclidean_distance>`__ 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 :ref:`AStar3D<class_AStar3D>` y :ref:`AStar2D<class_AStar2D>` por defecto (con la inclusión de la posible coordenada del eje z).
.. _class_AStarGrid2D_constant_HEURISTIC_MANHATTAN:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **HEURISTIC_MANHATTAN** = ``1``
La `heurística de Manhattan <https://en.wikipedia.org/wiki/Taxicab_geometry>`__ 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 :ref:`diagonal_mode<class_AStarGrid2D_property_diagonal_mode>` a :ref:`DIAGONAL_MODE_NEVER<class_AStarGrid2D_constant_DIAGONAL_MODE_NEVER>`.
.. _class_AStarGrid2D_constant_HEURISTIC_OCTILE:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_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;
.. _class_AStarGrid2D_constant_HEURISTIC_CHEBYSHEV:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **HEURISTIC_CHEBYSHEV** = ``3``
La `heurística de Chebyshev <https://en.wikipedia.org/wiki/Chebyshev_distance>`__ 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)
.. _class_AStarGrid2D_constant_HEURISTIC_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **HEURISTIC_MAX** = ``4``
Representa el tamaño del enum :ref:`Heuristic<enum_AStarGrid2D_Heuristic>`.
.. rst-class:: classref-item-separator
----
.. _enum_AStarGrid2D_DiagonalMode:
.. rst-class:: classref-enumeration
enum **DiagonalMode**: :ref:`🔗<enum_AStarGrid2D_DiagonalMode>`
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_ALWAYS:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_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.
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_NEVER:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` **DIAGONAL_MODE_NEVER** = ``1``
El algoritmo de búsqueda de caminos ignorará todas las diagonales y el camino siempre será ortogonal.
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_AT_LEAST_ONE_WALKABLE:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_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.
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_ONLY_IF_NO_OBSTACLES:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_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.
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` **DIAGONAL_MODE_MAX** = ``4``
Representa el tamaño del enum :ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_AStarGrid2D_CellShape:
.. rst-class:: classref-enumeration
enum **CellShape**: :ref:`🔗<enum_AStarGrid2D_CellShape>`
.. _class_AStarGrid2D_constant_CELL_SHAPE_SQUARE:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_CellShape>` **CELL_SHAPE_SQUARE** = ``0``
Forma de celda rectangular.
.. _class_AStarGrid2D_constant_CELL_SHAPE_ISOMETRIC_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_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.
.. _class_AStarGrid2D_constant_CELL_SHAPE_ISOMETRIC_DOWN:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_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.
.. _class_AStarGrid2D_constant_CELL_SHAPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_CellShape>` **CELL_SHAPE_MAX** = ``3``
Representa el tamaño del enum :ref:`CellShape<enum_AStarGrid2D_CellShape>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_AStarGrid2D_property_cell_shape:
.. rst-class:: classref-property
:ref:`CellShape<enum_AStarGrid2D_CellShape>` **cell_shape** = ``0`` :ref:`🔗<class_AStarGrid2D_property_cell_shape>`
.. rst-class:: classref-property-setget
- |void| **set_cell_shape**\ (\ value\: :ref:`CellShape<enum_AStarGrid2D_CellShape>`\ )
- :ref:`CellShape<enum_AStarGrid2D_CellShape>` **get_cell_shape**\ (\ )
La forma de la celda. Afecta a cómo se colocan las posiciones en la cuadrícula. Si se cambia, es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` antes de encontrar el siguiente trayecto.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_cell_size:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **cell_size** = ``Vector2(1, 1)`` :ref:`🔗<class_AStarGrid2D_property_cell_size>`
.. rst-class:: classref-property-setget
- |void| **set_cell_size**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_cell_size**\ (\ )
El tamaño de la celda de punto que se aplicará para calcular la posición del punto resultante devuelta por :ref:`get_point_path()<class_AStarGrid2D_method_get_point_path>`. Si se cambia, es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` antes de encontrar el siguiente trayecto.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_default_compute_heuristic:
.. rst-class:: classref-property
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **default_compute_heuristic** = ``0`` :ref:`🔗<class_AStarGrid2D_property_default_compute_heuristic>`
.. rst-class:: classref-property-setget
- |void| **set_default_compute_heuristic**\ (\ value\: :ref:`Heuristic<enum_AStarGrid2D_Heuristic>`\ )
- :ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **get_default_compute_heuristic**\ (\ )
La :ref:`Heuristic<enum_AStarGrid2D_Heuristic>` predeterminada que se utilizará para calcular el coste entre dos puntos si :ref:`_compute_cost()<class_AStarGrid2D_private_method__compute_cost>` no se ha sobreescrito.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_default_estimate_heuristic:
.. rst-class:: classref-property
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **default_estimate_heuristic** = ``0`` :ref:`🔗<class_AStarGrid2D_property_default_estimate_heuristic>`
.. rst-class:: classref-property-setget
- |void| **set_default_estimate_heuristic**\ (\ value\: :ref:`Heuristic<enum_AStarGrid2D_Heuristic>`\ )
- :ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **get_default_estimate_heuristic**\ (\ )
La :ref:`Heuristic<enum_AStarGrid2D_Heuristic>` predeterminada que se utilizará para calcular el coste entre el punto y el punto final si :ref:`_estimate_cost()<class_AStarGrid2D_private_method__estimate_cost>` no se ha sobreescrito.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_diagonal_mode:
.. rst-class:: classref-property
:ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` **diagonal_mode** = ``0`` :ref:`🔗<class_AStarGrid2D_property_diagonal_mode>`
.. rst-class:: classref-property-setget
- |void| **set_diagonal_mode**\ (\ value\: :ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>`\ )
- :ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` **get_diagonal_mode**\ (\ )
Un modo :ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` específico que forzará a la ruta a evitar o aceptar las diagonales especificadas.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_jumping_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **jumping_enabled** = ``false`` :ref:`🔗<class_AStarGrid2D_property_jumping_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_jumping_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_jumping_enabled**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_offset:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **offset** = ``Vector2(0, 0)`` :ref:`🔗<class_AStarGrid2D_property_offset>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_offset**\ (\ )
El desplazamiento de la cuadrícula que se aplicará para calcular la posición del punto resultante devuelta por :ref:`get_point_path()<class_AStarGrid2D_method_get_point_path>`. Si se cambia, es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` antes de encontrar el siguiente trayecto.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_region:
.. rst-class:: classref-property
:ref:`Rect2i<class_Rect2i>` **region** = ``Rect2i(0, 0, 0, 0)`` :ref:`🔗<class_AStarGrid2D_property_region>`
.. rst-class:: classref-property-setget
- |void| **set_region**\ (\ value\: :ref:`Rect2i<class_Rect2i>`\ )
- :ref:`Rect2i<class_Rect2i>` **get_region**\ (\ )
La región de celdas de la cuadrícula disponibles para la búsqueda de trayectos. Si se cambia, es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` antes de encontrar el siguiente trayecto.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_property_size:
.. rst-class:: classref-property
:ref:`Vector2i<class_Vector2i>` **size** = ``Vector2i(0, 0)`` :ref:`🔗<class_AStarGrid2D_property_size>`
.. rst-class:: classref-property-setget
- |void| **set_size**\ (\ value\: :ref:`Vector2i<class_Vector2i>`\ )
- :ref:`Vector2i<class_Vector2i>` **get_size**\ (\ )
**Obsoleto:** Use :ref:`region<class_AStarGrid2D_property_region>` instead.
El tamaño de la cuadrícula (número de celdas de tamaño :ref:`cell_size<class_AStarGrid2D_property_cell_size>` en cada eje). Si se cambia, es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` antes de encontrar el siguiente trayecto.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_AStarGrid2D_private_method__compute_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **_compute_cost**\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, to_id\: :ref:`Vector2i<class_Vector2i>`\ ) |virtual| |const| :ref:`🔗<class_AStarGrid2D_private_method__compute_cost>`
Llamado al calcular el coste entre dos puntos conectados.
Ten en cuenta que esta función está oculta en la clase **AStarGrid2D** por defecto.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_private_method__estimate_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **_estimate_cost**\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, end_id\: :ref:`Vector2i<class_Vector2i>`\ ) |virtual| |const| :ref:`🔗<class_AStarGrid2D_private_method__estimate_cost>`
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.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_AStarGrid2D_method_clear>`
Limpia la cuadrícula y establece :ref:`region<class_AStarGrid2D_property_region>` a ``Rect2i(0, 0, 0, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_fill_solid_region:
.. rst-class:: classref-method
|void| **fill_solid_region**\ (\ region\: :ref:`Rect2i<class_Rect2i>`, solid\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_AStarGrid2D_method_fill_solid_region>`
Rellena la ``region`` dada en la cuadrícula con el valor especificado para la bandera de sólido.
\ **Nota:** No es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` después de la llamada a esta función.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_fill_weight_scale_region:
.. rst-class:: classref-method
|void| **fill_weight_scale_region**\ (\ region\: :ref:`Rect2i<class_Rect2i>`, weight_scale\: :ref:`float<class_float>`\ ) :ref:`🔗<class_AStarGrid2D_method_fill_weight_scale_region>`
Rellena la ``region`` dada en la cuadrícula con el valor especificado para la escala de peso.
\ **Nota:** No es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>` después de la llamada a esta función.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_get_id_path:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] **get_id_path**\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, to_id\: :ref:`Vector2i<class_Vector2i>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_AStarGrid2D_method_get_id_path>`
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.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_get_point_data_in_region:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Dictionary<class_Dictionary>`\] **get_point_data_in_region**\ (\ region\: :ref:`Rect2i<class_Rect2i>`\ ) |const| :ref:`🔗<class_AStarGrid2D_method_get_point_data_in_region>`
Devuelve un array de diccionarios con información de los puntos (``id``: :ref:`Vector2i<class_Vector2i>`, ``position``: :ref:`Vector2<class_Vector2>`, ``solid``: :ref:`bool<class_bool>`, ``weight_scale``: :ref:`float<class_float>`) dentro de una ``region``.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_get_point_path:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **get_point_path**\ (\ from_id\: :ref:`Vector2i<class_Vector2i>`, to_id\: :ref:`Vector2i<class_Vector2i>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_AStarGrid2D_method_get_point_path>`
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 :ref:`Thread<class_Thread>` a la vez. Considera usar :ref:`Mutex<class_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.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_get_point_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_point_position**\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_AStarGrid2D_method_get_point_position>`
Devuelve la posición del punto asociado con el ``id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_get_point_weight_scale:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_point_weight_scale**\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_AStarGrid2D_method_get_point_weight_scale>`
Devuelve la escala de peso del punto asociado con el ``id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_is_dirty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_dirty**\ (\ ) |const| :ref:`🔗<class_AStarGrid2D_method_is_dirty>`
Indica que los parámetros de la cuadrícula se han cambiado y que es necesario llamar a :ref:`update()<class_AStarGrid2D_method_update>`.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_is_in_bounds:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_in_bounds**\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStarGrid2D_method_is_in_bounds>`
Devuelve ``true`` si ``x`` e ``y`` son coordenadas de cuadrícula válidas (id), es decir, si están dentro de :ref:`region<class_AStarGrid2D_property_region>`. Equivalente a ``region.has_point(Vector2i(x, y))``.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_is_in_boundsv:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_in_boundsv**\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_AStarGrid2D_method_is_in_boundsv>`
Devuelve ``true`` si el vector ``id`` es una coordenada de cuadrícula válida, es decir, si está dentro de :ref:`region<class_AStarGrid2D_property_region>`. Equivalente a ``region.has_point(id)``.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_is_point_solid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_point_solid**\ (\ id\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_AStarGrid2D_method_is_point_solid>`
Devuelve ``true`` si un punto está deshabilitado para la búsqueda de trayectos. Por defecto, todos los puntos están habilitados.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_set_point_solid:
.. rst-class:: classref-method
|void| **set_point_solid**\ (\ id\: :ref:`Vector2i<class_Vector2i>`, solid\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_AStarGrid2D_method_set_point_solid>`
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 :ref:`update()<class_AStarGrid2D_method_update>` después de llamar a esta función.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_set_point_weight_scale:
.. rst-class:: classref-method
|void| **set_point_weight_scale**\ (\ id\: :ref:`Vector2i<class_Vector2i>`, weight_scale\: :ref:`float<class_float>`\ ) :ref:`🔗<class_AStarGrid2D_method_set_point_weight_scale>`
Establece el ``weight_scale`` para el punto con el ``id`` dado. El ``weight_scale`` se multiplica por el resultado de :ref:`_compute_cost()<class_AStarGrid2D_private_method__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 :ref:`update()<class_AStarGrid2D_method_update>` después de llamar a esta función.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_update:
.. rst-class:: classref-method
|void| **update**\ (\ ) :ref:`🔗<class_AStarGrid2D_method_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 :ref:`region<class_AStarGrid2D_property_region>`, :ref:`cell_size<class_AStarGrid2D_property_cell_size>` o :ref:`offset<class_AStarGrid2D_property_offset>` cambian. :ref:`is_dirty()<class_AStarGrid2D_method_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.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink