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_astar3d.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

638 lines
35 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_AStar3D:
AStar3D
=======
**Hereda:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Una implementación de A\* para encontrar el camino más corto entre dos vértices en un grafo conectado en un espacio 3D.
.. rst-class:: classref-introduction-group
Descripción
----------------------
A\* (A Star) es un algoritmo informático utilizado en la búsqueda de rutas y el recorrido de grafos, el proceso de trazar rutas cortas entre vértices (puntos), pasando por un conjunto dado de aristas (segmentos). Goza de un uso generalizado debido a su rendimiento y precisión. La implementación de A\* de Godot utiliza puntos en el espacio 3D y distancias euclidianas por defecto.
Debes añadir puntos manualmente con :ref:`add_point()<class_AStar3D_method_add_point>` y crear segmentos manualmente con :ref:`connect_points()<class_AStar3D_method_connect_points>`. Una vez hecho, puedes comprobar si hay una ruta entre dos puntos con la función :ref:`are_points_connected()<class_AStar3D_method_are_points_connected>`, obtener una ruta que contenga índices con :ref:`get_id_path()<class_AStar3D_method_get_id_path>`, o una que contenga coordenadas reales con :ref:`get_point_path()<class_AStar3D_method_get_point_path>`.
También es posible utilizar distancias no euclidianas. Para ello, crea un script que extienda **AStar3D** y sobrescribe los métodos :ref:`_compute_cost()<class_AStar3D_private_method__compute_cost>` y :ref:`_estimate_cost()<class_AStar3D_private_method__estimate_cost>`. Ambos deben tomar dos ID de puntos y devolver la distancia entre los puntos correspondientes.
\ **Ejemplo:** Usa la distancia Manhattan en lugar de la distancia euclidiana:
.. tabs::
.. code-tab:: gdscript
class_name MyAStar3D
extends AStar3D
func _compute_cost(u, v):
var u_pos = get_point_position(u)
var v_pos = get_point_position(v)
return abs(u_pos.x - v_pos.x) + abs(u_pos.y - v_pos.y) + abs(u_pos.z - v_pos.z)
func _estimate_cost(u, v):
var u_pos = get_point_position(u)
var v_pos = get_point_position(v)
return abs(u_pos.x - v_pos.x) + abs(u_pos.y - v_pos.y) + abs(u_pos.z - v_pos.z)
.. code-tab:: csharp
using Godot;
[GlobalClass]
public partial class MyAStar3D : AStar3D
{
public override float _ComputeCost(long fromId, long toId)
{
Vector3 fromPoint = GetPointPosition(fromId);
Vector3 toPoint = GetPointPosition(toId);
return Mathf.Abs(fromPoint.X - toPoint.X) + Mathf.Abs(fromPoint.Y - toPoint.Y) + Mathf.Abs(fromPoint.Z - toPoint.Z);
}
public override float _EstimateCost(long fromId, long toId)
{
Vector3 fromPoint = GetPointPosition(fromId);
Vector3 toPoint = GetPointPosition(toId);
return Mathf.Abs(fromPoint.X - toPoint.X) + Mathf.Abs(fromPoint.Y - toPoint.Y) + Mathf.Abs(fromPoint.Z - toPoint.Z);
}
}
\ :ref:`_estimate_cost()<class_AStar3D_private_method__estimate_cost>` debería devolver un límite inferior de la distancia, es decir, ``_estimate_cost(u, v) <= _compute_cost(u, v)``. Esto sirve como una pista para el algoritmo porque el :ref:`_compute_cost()<class_AStar3D_private_method__compute_cost>` personalizado podría ser computacionalmente pesado. Si este no es el caso, haz que :ref:`_estimate_cost()<class_AStar3D_private_method__estimate_cost>` devuelva el mismo valor que :ref:`_compute_cost()<class_AStar3D_private_method__compute_cost>` para proporcionar al algoritmo la información más precisa.
Si se utilizan los métodos predeterminados :ref:`_estimate_cost()<class_AStar3D_private_method__estimate_cost>` y :ref:`_compute_cost()<class_AStar3D_private_method__compute_cost>`, o si el método :ref:`_estimate_cost()<class_AStar3D_private_method__estimate_cost>` proporcionado devuelve un límite inferior del costo, entonces las rutas devueltas por A\* serán las rutas de menor costo. Aquí, el costo de una ruta es igual a la suma de los resultados de :ref:`_compute_cost()<class_AStar3D_private_method__compute_cost>` de todos los segmentos en la ruta multiplicada por las ``weight_scale``\ s de los puntos finales de los segmentos respectivos. Si se utilizan los métodos predeterminados y las ``weight_scale``\ s de todos los puntos se establecen en ``1.0``, entonces esto es igual a la suma de las distancias euclidianas de todos los segmentos en la ruta.
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+-------------------------+--------------------------------------------------------------------------------+-----------+
| :ref:`bool<class_bool>` | :ref:`neighbor_filter_enabled<class_AStar3D_property_neighbor_filter_enabled>` | ``false`` |
+-------------------------+--------------------------------------------------------------------------------+-----------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`_compute_cost<class_AStar3D_private_method__compute_cost>`\ (\ from_id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`\ ) |virtual| |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`_estimate_cost<class_AStar3D_private_method__estimate_cost>`\ (\ from_id\: :ref:`int<class_int>`, end_id\: :ref:`int<class_int>`\ ) |virtual| |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`_filter_neighbor<class_AStar3D_private_method__filter_neighbor>`\ (\ from_id\: :ref:`int<class_int>`, neighbor_id\: :ref:`int<class_int>`\ ) |virtual| |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_point<class_AStar3D_method_add_point>`\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`, weight_scale\: :ref:`float<class_float>` = 1.0\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`are_points_connected<class_AStar3D_method_are_points_connected>`\ (\ id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, bidirectional\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear<class_AStar3D_method_clear>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`connect_points<class_AStar3D_method_connect_points>`\ (\ id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, bidirectional\: :ref:`bool<class_bool>` = true\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`disconnect_points<class_AStar3D_method_disconnect_points>`\ (\ id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, bidirectional\: :ref:`bool<class_bool>` = true\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_available_point_id<class_AStar3D_method_get_available_point_id>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_closest_point<class_AStar3D_method_get_closest_point>`\ (\ to_position\: :ref:`Vector3<class_Vector3>`, include_disabled\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_closest_position_in_segment<class_AStar3D_method_get_closest_position_in_segment>`\ (\ to_position\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`get_id_path<class_AStar3D_method_get_id_path>`\ (\ from_id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_point_capacity<class_AStar3D_method_get_point_capacity>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`get_point_connections<class_AStar3D_method_get_point_connections>`\ (\ id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_point_count<class_AStar3D_method_get_point_count>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`get_point_ids<class_AStar3D_method_get_point_ids>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`get_point_path<class_AStar3D_method_get_point_path>`\ (\ from_id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_point_position<class_AStar3D_method_get_point_position>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_point_weight_scale<class_AStar3D_method_get_point_weight_scale>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_point<class_AStar3D_method_has_point>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_point_disabled<class_AStar3D_method_is_point_disabled>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_point<class_AStar3D_method_remove_point>`\ (\ id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`reserve_space<class_AStar3D_method_reserve_space>`\ (\ num_nodes\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_disabled<class_AStar3D_method_set_point_disabled>`\ (\ id\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>` = true\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_position<class_AStar3D_method_set_point_position>`\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_weight_scale<class_AStar3D_method_set_point_weight_scale>`\ (\ id\: :ref:`int<class_int>`, weight_scale\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_AStar3D_property_neighbor_filter_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **neighbor_filter_enabled** = ``false`` :ref:`🔗<class_AStar3D_property_neighbor_filter_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_neighbor_filter_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_neighbor_filter_enabled**\ (\ )
Si es ``true``, habilita el filtrado de vecinos a través de :ref:`_filter_neighbor()<class_AStar3D_private_method__filter_neighbor>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_AStar3D_private_method__compute_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **_compute_cost**\ (\ from_id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`\ ) |virtual| |const| :ref:`🔗<class_AStar3D_private_method__compute_cost>`
Se llama al calcular el coste entre dos puntos conectados.
Ten en cuenta que esta función está oculta en la clase **AStar3D** predeterminada.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_private_method__estimate_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **_estimate_cost**\ (\ from_id\: :ref:`int<class_int>`, end_id\: :ref:`int<class_int>`\ ) |virtual| |const| :ref:`🔗<class_AStar3D_private_method__estimate_cost>`
Se llama 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 **AStar3D** predeterminada.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_private_method__filter_neighbor:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **_filter_neighbor**\ (\ from_id\: :ref:`int<class_int>`, neighbor_id\: :ref:`int<class_int>`\ ) |virtual| |const| :ref:`🔗<class_AStar3D_private_method__filter_neighbor>`
Se llama cuando un punto vecino entra en el procesamiento y si :ref:`neighbor_filter_enabled<class_AStar3D_property_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 **AStar3D** predeterminada.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_add_point:
.. rst-class:: classref-method
|void| **add_point**\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`, weight_scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_AStar3D_method_add_point>`
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 :ref:`_compute_cost()<class_AStar3D_private_method__compute_cost>` al determinar el coste total de viajar a través de un segmento desde un punto vecino a este punto. Por lo tanto, en igualdad de condiciones, el algoritmo prefiere los puntos con ``weight_scale``\ s más bajos para formar un camino.
.. tabs::
.. code-tab:: gdscript
var astar = AStar3D.new()
astar.add_point(1, Vector3(1, 0, 0), 4) # Añade el punto (1, 0, 0) con weight_scale 4 e id 1
.. code-tab:: csharp
var astar = new AStar3D();
astar.AddPoint(1, new Vector3(1, 0, 0), 4); // Añade el punto (1, 0, 0) con weight_scale 4 e id 1
Si ya existe un punto para el ``id`` dado, su posición y escala de peso se actualizan a los valores dados.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_are_points_connected:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **are_points_connected**\ (\ id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, bidirectional\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_AStar3D_method_are_points_connected>`
Devuelve si los dos puntos dados están directamente conectados por un segmento. Si ``bidirectional`` es ``false``, devuelve si el movimiento desde ``id`` a ``to_id`` es posible a través de este segmento.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_AStar3D_method_clear>`
Limpia todos los puntos y segmentos.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_connect_points:
.. rst-class:: classref-method
|void| **connect_points**\ (\ id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, bidirectional\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_AStar3D_method_connect_points>`
Crea un segmento entre los puntos dados. Si ``bidirectional`` es ``false``, solo el movimiento desde ``id`` hasta ``to_id`` está permitido, no en la dirección inversa.
.. tabs::
.. code-tab:: gdscript
var astar = AStar3D.new()
astar.add_point(1, Vector3(1, 1, 0))
astar.add_point(2, Vector3(0, 5, 0))
astar.connect_points(1, 2, false)
.. code-tab:: csharp
var astar = new AStar3D();
astar.AddPoint(1, new Vector3(1, 1, 0));
astar.AddPoint(2, new Vector3(0, 5, 0));
astar.ConnectPoints(1, 2, false);
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_disconnect_points:
.. rst-class:: classref-method
|void| **disconnect_points**\ (\ id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, bidirectional\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_AStar3D_method_disconnect_points>`
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.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_available_point_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_available_point_id**\ (\ ) |const| :ref:`🔗<class_AStar3D_method_get_available_point_id>`
Devuelve el punto de Ide proximo disponible con ningun punto asociado a el.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_closest_point:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_closest_point**\ (\ to_position\: :ref:`Vector3<class_Vector3>`, include_disabled\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_AStar3D_method_get_closest_point>`
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.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_closest_position_in_segment:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_closest_position_in_segment**\ (\ to_position\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_AStar3D_method_get_closest_position_in_segment>`
Devuelve la posición más cercana a ``to_position`` que reside dentro de un segmento entre dos puntos conectados.
.. tabs::
.. code-tab:: gdscript
var astar = AStar3D.new()
astar.add_point(1, Vector3(0, 0, 0))
astar.add_point(2, Vector3(0, 5, 0))
astar.connect_points(1, 2)
var res = astar.get_closest_position_in_segment(Vector3(3, 3, 0)) # Devuelve (0, 3, 0)
.. code-tab:: csharp
var astar = new AStar3D();
astar.AddPoint(1, new Vector3(0, 0, 0));
astar.AddPoint(2, new Vector3(0, 5, 0));
astar.ConnectPoints(1, 2);
Vector3 res = astar.GetClosestPositionInSegment(new Vector3(3, 3, 0)); // Devuelve (0, 3, 0)
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.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_id_path:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **get_id_path**\ (\ from_id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_AStar3D_method_get_id_path>`
Devuelve un array con los ID de los puntos que forman el camino encontrado por AStar3D entre los puntos dados. El array está ordenado 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 pueda alcanzar.
\ **Nota:** Cuando ``allow_partial_path`` es ``true`` y ``to_id`` está deshabilitado, la búsqueda puede tardar mucho tiempo en terminar.
.. tabs::
.. code-tab:: gdscript
var astar = AStar3D.new()
astar.add_point(1, Vector3(0, 0, 0))
astar.add_point(2, Vector3(0, 1, 0), 1) # El peso por defecto es 1
astar.add_point(3, Vector3(1, 1, 0))
astar.add_point(4, Vector3(2, 0, 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]
.. code-tab:: csharp
var astar = new AStar3D();
astar.AddPoint(1, new Vector3(0, 0, 0));
astar.AddPoint(2, new Vector3(0, 1, 0), 1); // Default weight is 1
astar.AddPoint(3, new Vector3(1, 1, 0));
astar.AddPoint(4, new Vector3(2, 0, 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 tu cambias el peso del segundo punto a 3, entonces el resultado será ``[1, 4, 3]`` en su lugar, porque ahora, aunque la distancia sea mayor, es "más fácil" pasar por el punto 4 que por el punto 2.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_capacity:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_point_capacity**\ (\ ) |const| :ref:`🔗<class_AStar3D_method_get_point_capacity>`
Devuelve la capacidad de la estructura que respalda los puntos, útil en conjunto con :ref:`reserve_space()<class_AStar3D_method_reserve_space>`.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_connections:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **get_point_connections**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_AStar3D_method_get_point_connections>`
Devuelve un array con los ID de los puntos que forman la conneccion con el punto dado.
.. tabs::
.. code-tab:: gdscript
var astar = AStar3D.new()
astar.add_point(1, Vector3(0, 0, 0))
astar.add_point(2, Vector3(0, 1, 0))
astar.add_point(3, Vector3(1, 1, 0))
astar.add_point(4, Vector3(2, 0, 0))
astar.connect_points(1, 2, true)
astar.connect_points(1, 3, true)
var vecinos = astar.get_point_connections(1) # Devuelve [2, 3]
.. code-tab:: csharp
var astar = new AStar3D();
astar.AddPoint(1, new Vector3(0, 0, 0));
astar.AddPoint(2, new Vector3(0, 1, 0));
astar.AddPoint(3, new Vector3(1, 1, 0));
astar.AddPoint(4, new Vector3(2, 0, 0));
astar.ConnectPoints(1, 2, true);
astar.ConnectPoints(1, 3, true);
long[] vecinos = astar.GetPointConnections(1); // Devuelve [2, 3]
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_point_count**\ (\ ) |const| :ref:`🔗<class_AStar3D_method_get_point_count>`
Devuelve el numero de puntos actualmente en el grupo(pool) de puntos.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_ids:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **get_point_ids**\ (\ ) :ref:`🔗<class_AStar3D_method_get_point_ids>`
Devuelve un array de todos los ID de los puntos.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_path:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **get_point_path**\ (\ from_id\: :ref:`int<class_int>`, to_id\: :ref:`int<class_int>`, allow_partial_path\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_AStar3D_method_get_point_path>`
Devuelve un array con los puntos que están en la ruta encontrada por AStar3D entre los puntos dados. El array se ordena desde el punto de inicio hasta el punto final de la ruta.
Si no hay una ruta válida al destino, y ``allow_partial_path`` es ``true``, devuelve una ruta al punto más cercano al destino 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`` está deshabilitado, la búsqueda puede tardar un tiempo inusualmente largo en finalizar.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_position:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_point_position**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar3D_method_get_point_position>`
Devuelve la posición del punto asociado con el ``id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_get_point_weight_scale:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_point_weight_scale**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar3D_method_get_point_weight_scale>`
Devuelve la escala de peso del punto asociado con el ``id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_has_point:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_point**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar3D_method_has_point>`
Devuelve si existe un punto asociado con el ``id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_is_point_disabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_point_disabled**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar3D_method_is_point_disabled>`
Devuelve si un punto esta deshabilitado or no para el buscador de rutas. Por defecto, todos los puntos estan habilitados.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_remove_point:
.. rst-class:: classref-method
|void| **remove_point**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_AStar3D_method_remove_point>`
Elimina el punto asociado con el ``id`` dado del grupo de puntos.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_reserve_space:
.. rst-class:: classref-method
|void| **reserve_space**\ (\ num_nodes\: :ref:`int<class_int>`\ ) :ref:`🔗<class_AStar3D_method_reserve_space>`
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.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_set_point_disabled:
.. rst-class:: classref-method
|void| **set_point_disabled**\ (\ id\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_AStar3D_method_set_point_disabled>`
Deshabilita o habilita el punto especificado para el buscador de rutas. Util para crear obstaculos temporales.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_set_point_position:
.. rst-class:: classref-method
|void| **set_point_position**\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_AStar3D_method_set_point_position>`
Establece la ``position`` para el punto con el ``id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_AStar3D_method_set_point_weight_scale:
.. rst-class:: classref-method
|void| **set_point_weight_scale**\ (\ id\: :ref:`int<class_int>`, weight_scale\: :ref:`float<class_float>`\ ) :ref:`🔗<class_AStar3D_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_AStar3D_private_method__compute_cost>` al determinar el coste total de viajar a través de un segmento desde un punto vecino a este punto.
.. |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