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

705 lines
38 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_AStarGrid2D:
AStarGrid2D
===========
**Eredita:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Un'implementazione di A\* per trovare il percorso più breve tra due punti su una griglia parziale 2D.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
**AStarGrid2D** è una variante di :ref:`AStar2D<class_AStar2D>` che è specializzata per le griglie 2D parziali. È più semplice da usare perché non richiede di creare manualmente i punti e collegarli insieme. Questa classe supporta anche più tipi di euristica, modalità per movimento diagonale, e una modalità di salto per velocizzare i calcoli.
Per utilizzare **AStarGrid2D**, è sufficiente solo impostare la regione (:ref:`region<class_AStarGrid2D_property_region>`) della griglia, impostando facoltativamente le dimensioni della cella (:ref:`cell_size<class_AStarGrid2D_property_cell_size>`), e infine chiamare il metodo :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))) # Stampa [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
print(astar_grid.get_point_path(Vector2i(0, 0), Vector2i(3, 4))) # Stampa [(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))); // Stampa [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
GD.Print(astarGrid.GetPointPath(Vector2I.Zero, new Vector2I(3, 4))); // Stampa [(0, 0), (16, 16), (32, 32), (48, 48), (48, 64)]
Per rimuovere un punto dalla griglia di rilevamento del percorso, deve essere impostato come "solido" con :ref:`set_point_solid()<class_AStarGrid2D_method_set_point_solid>`.
.. 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:`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
Metodi
------------
.. 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
Enumerazioni
------------------------
.. _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``
L'`euristico euclideo <https://it.wikipedia.org/wiki/Distanza_euclidea>`__ da utilizzare per la ricerca del percorso, utilizzando la seguente formula:
::
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
risultato = sqrt(dx * dx + dy * dy)
\ **Nota:** Questo è anche l'euristico interno utilizzato in :ref:`AStar3D<class_AStar3D>` e :ref:`AStar2D<class_AStar2D>` per impostazione predefinita (con l'inclusione di possibile coordinate sull'asse z).
.. _class_AStarGrid2D_constant_HEURISTIC_MANHATTAN:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **HEURISTIC_MANHATTAN** = ``1``
L'`euristico di Manhattan <https://it.wikipedia.org/wiki/Geometria_del_taxi>`__ da utilizzare per la ricerca del percorso, utilizzando la seguente formula:
::
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
risultato = dx + dy
\ **Nota:** Questo euristico è destinato a essere utilizzato con movimenti ortogonali a 4 lati, forniti impostando :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``
L'euristico ottale da utilizzare per la ricerca del percorso utilizzando la seguente formula:
::
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
f = sqrt(2) - 1
risultato = (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``
L'`euristico di Čebyšëv <https://it.wikipedia.org/wiki/Distanza_di_%C4%8Ceby%C5%A1%C3%ABv>`__ da utilizzare per la ricerca del percorso utilizzando la seguente formula:
::
dx = abs(to_id.x - from_id.x)
dy = abs(to_id.y - from_id.y)
risultato = max(dx, dy)
.. _class_AStarGrid2D_constant_HEURISTIC_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Heuristic<enum_AStarGrid2D_Heuristic>` **HEURISTIC_MAX** = ``4``
Rappresenta la dimensione dell'enumerazione :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``
L'algoritmo di ricerca del percorso ignorerà i vicini solidi intorno alla cella di destinazione e permetterà di passare tramite le diagonali.
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_NEVER:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` **DIAGONAL_MODE_NEVER** = ``1``
L'algoritmo di ricerca del percorso ignorerà tutte le diagonali e la strada sarà sempre ortogonale.
.. _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``
L'algoritmo di ricerca del percorso eviterà di usare le diagonali se almeno due ostacoli sono stati posti intorno alle celle vicine del segmento specifico del percorso.
.. _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``
L'algoritmo di ricerca del percorso eviterà di usare le diagonali se qualsiasi ostacolo è stato posto intorno alle celle vicine del segmento specifico del percorso.
.. _class_AStarGrid2D_constant_DIAGONAL_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>` **DIAGONAL_MODE_MAX** = ``4``
Rappresenta la dimensione dell'enumerazione :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 di cella rettangolare.
.. _class_AStarGrid2D_constant_CELL_SHAPE_ISOMETRIC_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_CellShape>` **CELL_SHAPE_ISOMETRIC_RIGHT** = ``1``
Forma di cella a diamante (per un aspetto isometrico). La disposizione delle coordinate delle celle in cui l'asse orizzontale va verso l'alto e a destra, e quello verticale va verso il basso e a destra.
.. _class_AStarGrid2D_constant_CELL_SHAPE_ISOMETRIC_DOWN:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_CellShape>` **CELL_SHAPE_ISOMETRIC_DOWN** = ``2``
Forma di cella a diamante (per un aspetto isometrico). La disposizione delle coordinate delle celle in cui l'asse orizzontale va verso il basso e a destra, e quello verticale va verso l'alto e a destra.
.. _class_AStarGrid2D_constant_CELL_SHAPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`CellShape<enum_AStarGrid2D_CellShape>` **CELL_SHAPE_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`CellShape<enum_AStarGrid2D_CellShape>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _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 delle celle. Influenza come le posizioni sono collocate nella griglia. Se cambiata, bisogna chiamare :ref:`update()<class_AStarGrid2D_method_update>` prima di trovare il prossimo percorso.
.. 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**\ (\ )
Le dimensioni delle celle dei punti che verranno applicate per calcolare la posizione del punto risultante restituita da :ref:`get_point_path()<class_AStarGrid2D_method_get_point_path>`. Se cambiata, bisogna chiamare :ref:`update()<class_AStarGrid2D_method_update>` prima di trovare il prossimo percorso.
.. 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**\ (\ )
L'euristica (:ref:`Heuristic<enum_AStarGrid2D_Heuristic>`) predefinita che verrà utilizzata per calcolare il costo tra due punti se :ref:`_compute_cost()<class_AStarGrid2D_private_method__compute_cost>` non è stato sovrascritto.
.. 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**\ (\ )
L'euristica (:ref:`Heuristic<enum_AStarGrid2D_Heuristic>`) predefinita che verrà utilizzata per calcolare il costo tra il punto e il punto finale se :ref:`_estimate_cost()<class_AStarGrid2D_private_method__estimate_cost>` non è stato sovrascritto.
.. 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**\ (\ )
Una specifica modalità di diagonale (:ref:`DiagonalMode<enum_AStarGrid2D_DiagonalMode>`) che costringe il percorso a evitare o accettare le diagonali specificate.
.. 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**\ (\ )
Abilita o disabilita il salto per saltare i punti intermedi e velocizzare l'algoritmo di ricerca.
\ **Nota:** Attualmente, abilitare questa opzione disabilita la considerazione della scala del peso nella ricerca del percorso.
.. 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**\ (\ )
Lo scostamento della griglia che verrà applicato per calcolare la posizione del punto risultante restituita da :ref:`get_point_path()<class_AStarGrid2D_method_get_point_path>`. Se cambiato, bisogna chiamare :ref:`update()<class_AStarGrid2D_method_update>` prima di trovare il prossimo percorso.
.. 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 regione delle celle della griglia disponibile per la ricerca del percorso. Se cambiato, bisogna chiamare :ref:`update()<class_AStarGrid2D_method_update>` prima di trovare il prossimo percorso.
.. 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**\ (\ )
**Deprecato:** Use :ref:`region<class_AStarGrid2D_property_region>` instead.
Le dimensioni della griglia (numero di celle di dimensione :ref:`cell_size<class_AStarGrid2D_property_cell_size>` su ogni asse). Se cambiate, bisogna chiamare :ref:`update()<class_AStarGrid2D_method_update>` prima di trovare il prossimo percorso.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _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>`
Chiamato quando si calcola il costo tra due punti collegati.
Si noti che questa funzione è nascosta nella classe predefinita **AStarGrid2D**.
.. 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>`
Chiamato quando si stima il costo tra un punto e il punto finale del percorso.
Si noti che questa funzione è nascosta nella classe predefinita **AStarGrid2D**.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_AStarGrid2D_method_clear>`
Cancella la griglia e imposta :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>`
Riempi la determinata regione ``region`` sulla griglia con il valore specificato per il flag solido.
\ **Nota:** Chiamare :ref:`update()<class_AStarGrid2D_method_update>` non è necessario dopo aver chiamato questa funzione.
.. 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>`
Riempie la determinata regione ``region`` sulla griglia con il valore specificato per la scala di peso.
\ **Nota:** Chiamare :ref:`update()<class_AStarGrid2D_method_update>` non è necessario dopo aver chiamato questa funzione.
.. 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>`
Restituisce un array con i 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`` è solido, la ricerca potrebbe richiedere un tempo insolitamente lungo per essere completata.
.. 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>`
Restituisce un array di dizionari con i dati dei punti (``id``: :ref:`Vector2i<class_Vector2i>`, ``position``: :ref:`Vector2<class_Vector2>`, ``solid``: :ref:`bool<class_bool>`, ``weight_scale``: :ref:`float<class_float>`) all'interno della regione ``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>`
Restituisce un array con i punti che sono presenti nel percorso trovato da **AStarGrid2D** 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. Se chiamato da un :ref:`Thread<class_Thread>`, restituirà un array vuoto e stamperà un messaggio di errore.
Inoltre, quando ``allow_partial_path`` è ``true`` e ``to_id`` è solido, la ricerca potrebbe richiedere un tempo insolitamente lungo per essere completata.
.. 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>`
Restituisce la posizione del punto associato all'``id`` fornito.
.. 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>`
Restituisce la scala di peso del punto associato all'``id`` fornito.
.. 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 che i parametri della griglia sono stati modificati ed è necessario chiamare :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>`
Restituisce ``true`` se il ``x`` e ``y`` è una valida coordinate di griglia (id), cioè se è all'interno di :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>`
Restituisce ``true`` se il vettore ``id`` è una valida coordinata di griglia, cioè se è all'interno di :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>`
Restituisce ``true`` se un punto è disabilitato per il rilevamento del percorso. Per impostazione predefinita, tutti i punti sono abilitati.
.. 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>`
Disabilita o abilita il punto specificato per il rilevamento del percorso. Utile per creare un ostacolo. Per impostazione predefinita, tutti i punti sono abilitati.
\ **Nota:** Non è necessario chiamare :ref:`update()<class_AStarGrid2D_method_update>` dopo aver chiamato questa funzione.
.. 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>`
Imposta la scala del peso (``weight_scale``) per il punto con l'``id`` fornito. ``weight_scale`` viene moltiplicato per il risultato di :ref:`_compute_cost()<class_AStarGrid2D_private_method__compute_cost>` quando si determina il costo complessivo del viaggio attraverso un segmento da un punto vicino a questo punto.
\ **Nota:** Non è necessario chiamare :ref:`update()<class_AStarGrid2D_method_update>` dopo aver chiamato questa funzione.
.. rst-class:: classref-item-separator
----
.. _class_AStarGrid2D_method_update:
.. rst-class:: classref-method
|void| **update**\ (\ ) :ref:`🔗<class_AStarGrid2D_method_update>`
Aggiorna lo stato interno della griglia in base ai parametri per prepararla alla ricerca del percorso. Deve essere chiamato se vengono modificati parametri come :ref:`region<class_AStarGrid2D_property_region>`, :ref:`cell_size<class_AStarGrid2D_property_cell_size>` o :ref:`offset<class_AStarGrid2D_property_offset>`. :ref:`is_dirty()<class_AStarGrid2D_method_is_dirty>` restituirà ``true`` se questo è il caso e deve essere chiamato.
\ **Nota:** Tutti i dati dei punti (solidità e scala del peso) verranno cancellati.
.. |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