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/it/class_astar2d.rst
Rémi Verschelde b20bcbb88b Sync classref with 4.5 branch
2025-09-30 13:31:55 +02:00

596 lines
32 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_AStar2D:
AStar2D
=======
**Eredita:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Un'implementazione di A\* per trovare il percorso più breve tra due vertici su un grafico collegato nello spazio 2D.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Un'implementazione dell'algoritmo A\*, usato per trovare il percorso più breve tra due vertici su un grafico collegato nello spazio 2D.
Vedi :ref:`AStar3D<class_AStar3D>` per una spiegazione più approfondita su come utilizzare questa classe. **AStar2D** è un wrapper per :ref:`AStar3D<class_AStar3D>` che impone coordinate in 2D.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- `Demo di navigazione basata su griglia con AStarGrid2D <https://godotengine.org/asset-library/asset/2723>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+-------------------------+--------------------------------------------------------------------------------+-----------+
| :ref:`bool<class_bool>` | :ref:`neighbor_filter_enabled<class_AStar2D_property_neighbor_filter_enabled>` | ``false`` |
+-------------------------+--------------------------------------------------------------------------------+-----------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`_compute_cost<class_AStar2D_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_AStar2D_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_AStar2D_private_method__filter_neighbor>`\ (\ from_id\: :ref:`int<class_int>`, neighbor_id\: :ref:`int<class_int>`\ ) |virtual| |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_point<class_AStar2D_method_add_point>`\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector2<class_Vector2>`, weight_scale\: :ref:`float<class_float>` = 1.0\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`are_points_connected<class_AStar2D_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_AStar2D_method_clear>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`connect_points<class_AStar2D_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_AStar2D_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_AStar2D_method_get_available_point_id>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_closest_point<class_AStar2D_method_get_closest_point>`\ (\ to_position\: :ref:`Vector2<class_Vector2>`, include_disabled\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_closest_position_in_segment<class_AStar2D_method_get_closest_position_in_segment>`\ (\ to_position\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`get_id_path<class_AStar2D_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_AStar2D_method_get_point_capacity>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`get_point_connections<class_AStar2D_method_get_point_connections>`\ (\ id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_point_count<class_AStar2D_method_get_point_count>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`get_point_ids<class_AStar2D_method_get_point_ids>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`get_point_path<class_AStar2D_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:`Vector2<class_Vector2>` | :ref:`get_point_position<class_AStar2D_method_get_point_position>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_point_weight_scale<class_AStar2D_method_get_point_weight_scale>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_point<class_AStar2D_method_has_point>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_point_disabled<class_AStar2D_method_is_point_disabled>`\ (\ id\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_point<class_AStar2D_method_remove_point>`\ (\ id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`reserve_space<class_AStar2D_method_reserve_space>`\ (\ num_nodes\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_disabled<class_AStar2D_method_set_point_disabled>`\ (\ id\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>` = true\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_position<class_AStar2D_method_set_point_position>`\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_point_weight_scale<class_AStar2D_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
Descrizioni delle proprietà
------------------------------------------------------
.. _class_AStar2D_property_neighbor_filter_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **neighbor_filter_enabled** = ``false`` :ref:`🔗<class_AStar2D_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**\ (\ )
Se ``true`` abilita il filtraggio dei vicini tramite :ref:`_filter_neighbor()<class_AStar2D_private_method__filter_neighbor>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_AStar2D_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_AStar2D_private_method__compute_cost>`
Chiamato quando si calcola il costo tra due punti collegati.
Si noti che questa funzione è nascosta nella classe predefinita **AStar2D**.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_private_method__estimate_cost>`
Chiamato quando si stima il costo tra un punto e il punto finale del percorso.
Si noti che questa funzione è nascosta nella classe predefinita **AStar2D**.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_private_method__filter_neighbor>`
Chiamato quando il punto adiacente entra in elaborazione e se :ref:`neighbor_filter_enabled<class_AStar2D_property_neighbor_filter_enabled>` è ``true``. Se viene restituito ``true``, il punto non sarà elaborato.
Si noti che questa funzione è nascosta nella classe predefinita **AStar2D**.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_add_point:
.. rst-class:: classref-method
|void| **add_point**\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector2<class_Vector2>`, weight_scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_AStar2D_method_add_point>`
Aggiunge un nuovo punto nella posizione specificata con l'identificatore specificato. ``id`` deve essere 0 o maggiore e la sua scala di peso (``weight_scale``) deve essere 0,0 o maggiore.
\ ``weight_scale`` viene moltiplicato per il risultato di :ref:`_compute_cost()<class_AStar2D_private_method__compute_cost>` quando si determina il costo complessivo del viaggio attraverso un segmento da un punto vicino a questo punto. Pertanto, a parità di tutto il resto, l'algoritmo preferisce i punti con ``weight_scale`` minori per formare un percorso.
.. tabs::
.. code-tab:: gdscript
var astar = AStar2D.new()
astar.add_point(1, Vector2(1, 0), 4) # Aggiunge il punto (1, 0) con weight_scale 4 e id 1
.. code-tab:: csharp
var astar = new AStar2D();
astar.AddPoint(1, new Vector2(1, 0), 4); // Aggiunge il punto (1, 0) con weight_scale 4 e id 1
Se esiste già un punto per l'``id`` fornito, la sua posizione e la sua scala di peso vengono aggiornate ai valori forniti.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_are_points_connected>`
Restituisce se c'è un collegamento/segmento tra i punti specificati. Se ``bidirectional`` è ``false``, restituisce se è possibile il movimento da ``id`` a ``to_id`` attraverso questo segmento.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_AStar2D_method_clear>`
Cancella tutti i punti e i segmenti.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_connect_points>`
Crea un segmento tra i punti specificati. Se ``bidirectional`` è ``false``, è consentito solo il movimento da ``id`` a ``to_id``, non la direzione opposta.
.. tabs::
.. code-tab:: gdscript
var astar = AStar2D.new()
astar.add_point(1, Vector2(1, 1))
astar.add_point(2, Vector2(0, 5))
astar.connect_points(1, 2, false)
.. code-tab:: csharp
var astar = new AStar2D();
astar.AddPoint(1, new Vector2(1, 1));
astar.AddPoint(2, new Vector2(0, 5));
astar.ConnectPoints(1, 2, false);
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_disconnect_points>`
Elimina il segmento tra i punti indicati. Se ``bidirectional`` è ``false``, solo il movimento da ``id`` a ``to_id`` è impedito, e un segmento unidirezionale può rimanere.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_available_point_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_available_point_id**\ (\ ) |const| :ref:`🔗<class_AStar2D_method_get_available_point_id>`
Restituisce il prossimo disponibile ID di punto senza alcun punto ad esso associato.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_closest_point:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_closest_point**\ (\ to_position\: :ref:`Vector2<class_Vector2>`, include_disabled\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_AStar2D_method_get_closest_point>`
Restituisce l'ID del punto più vicino a ``to_position``, facoltativamente prendendo in considerazione i punti disabilitati. Restituisce ``-1`` se non ci sono punti nella pool dei punti.
\ **Nota:** Se diversi punti sono i più vicini a ``to_position``, quello con l'ID più piccolo sarà restituito, garantendo un risultato deterministico.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_closest_position_in_segment:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_closest_position_in_segment**\ (\ to_position\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_AStar2D_method_get_closest_position_in_segment>`
Restituisce la posizione più vicina a ``to_position`` che risiede all'interno di un segmento tra due punti collegati.
.. tabs::
.. code-tab:: gdscript
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)) # Restituisce (0, 3)
.. code-tab:: csharp
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)); // Restituisce (0, 3)
Il risultato è nel segmento che va da ``y = 0`` a ``y = 5``. È la posizione più vicina nel segmento al punto indicato.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_get_id_path>`
Restituisce un array con gli ID dei punti che formano il percorso trovato da AStar2D tra i punti indicati. L'array è ordinato dal punto iniziale al punto finale del percorso.
Se non c'è un percorso valido per la destinazione, e ``allow_partial_path`` è ``true``, restituisce un percorso al punto più vicino alla destinazione che può essere raggiunto.
\ **Nota:** Quando ``allow_partial_path`` è ``true`` e ``to_id`` è disabilitato, la ricerca potrebbe richiedere un tempo insolitamente lungo per essere completata.
.. tabs::
.. code-tab:: gdscript
var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 1), 1) # Il peso predefinito è 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) # Restituisce [1, 2, 3]
.. code-tab:: csharp
var astar = new AStar2D();
astar.AddPoint(1, new Vector2(0, 0));
astar.AddPoint(2, new Vector2(0, 1), 1); // Il peso predefinito è 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); // Restituisce [1, 2, 3]
Se si cambia il peso a 3 per il punto 2, allora il risultato sarà ``[1, 4, 3]`` invece, poiché adesso anche se la distanza è più lunga, è "più facile" arrivare attraverso il punto 4 che attraverso il punto 2.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_point_capacity:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_point_capacity**\ (\ ) |const| :ref:`🔗<class_AStar2D_method_get_point_capacity>`
Restituisce la capacità della struttura che sostiene i punti, utile in combinazione con :ref:`reserve_space()<class_AStar2D_method_reserve_space>`.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_point_connections:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **get_point_connections**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_AStar2D_method_get_point_connections>`
Restituisce un array con gli ID dei punti che formano il collegamento con il punto indicato.
.. tabs::
.. code-tab:: gdscript
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) # Restituisce [2, 3]
.. code-tab:: csharp
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); // Restituisce [2, 3]
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_point_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_point_count**\ (\ ) |const| :ref:`🔗<class_AStar2D_method_get_point_count>`
Restituisce il numero di punti attualmente nell'insieme dei punti.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_point_ids:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **get_point_ids**\ (\ ) :ref:`🔗<class_AStar2D_method_get_point_ids>`
Restituisce un array di tutti gli ID dei punti.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_point_path:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **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_AStar2D_method_get_point_path>`
Restituisce un array con i punti che sono presenti nel percorso trovato da AStar2D tra i punti indicati. L'array è ordinato dal punto iniziale al punto finale del percorso.
Se non c'è un percorso valido per la destinazione, e ``allow_partial_path`` è ``true``, restituisce un percorso al punto più vicino alla destinazione che può essere raggiunto.
\ **Nota:** Questo metodo non è thread-safe; si può usare solo da un singolo :ref:`Thread<class_Thread>` alla volta. Si consiglia di utilizzare :ref:`Mutex<class_Mutex>` per garantire l'accesso esclusivo a un thread ed evitare accessi concorrenti.
Inoltre, quando ``allow_partial_path`` è ``true`` e ``to_id`` è disabilitato, la ricerca potrebbe richiedere un tempo insolitamente lungo per essere completata.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_get_point_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_point_position**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar2D_method_get_point_position>`
Restituisce la posizione del punto associato all'``id`` fornito.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_get_point_weight_scale>`
Restituisce la scala di peso del punto associato all'``id`` fornito.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_has_point:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_point**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar2D_method_has_point>`
Restituisce se esiste un punto associato all'``id`` fornito.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_is_point_disabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_point_disabled**\ (\ id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_AStar2D_method_is_point_disabled>`
Restituisce se un punto è disabilitato o no per il rilevamento del percorso. Per impostazione predefinita, tutti i punti sono abilitati.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_remove_point:
.. rst-class:: classref-method
|void| **remove_point**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_AStar2D_method_remove_point>`
Rimuove il punto associato all'``id`` fornito dall'insieme di punti.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_reserve_space:
.. rst-class:: classref-method
|void| **reserve_space**\ (\ num_nodes\: :ref:`int<class_int>`\ ) :ref:`🔗<class_AStar2D_method_reserve_space>`
Riserva internamente lo spazio per il numero di punti ``num_nodes``, utile se si sta aggiungendo un gran numero di punti conosciuti alla volta, come punti su una griglia.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_set_point_disabled>`
Disabilita o abilita il punto specificato per il rilevamento del percorso. Utile per creare un ostacolo temporaneo.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_method_set_point_position:
.. rst-class:: classref-method
|void| **set_point_position**\ (\ id\: :ref:`int<class_int>`, position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_AStar2D_method_set_point_position>`
Imposta la posizione ``position`` per il punto con l'``id`` fornito.
.. rst-class:: classref-item-separator
----
.. _class_AStar2D_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_AStar2D_method_set_point_weight_scale>`
Imposta la scala del peso (``weight_scale``) per il punto con l'``id`` fornito. ``weight_scale`` è moltiplicato per il risultato di :ref:`_compute_cost()<class_AStar2D_private_method__compute_cost>` quando si determina il costo complessivo di viaggiare attraverso un segmento da un punto vicino a questo punto.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink