:github_url: hide .. _class_AStar3D: AStar3D ======= **Eredita:** :ref:`RefCounted` **<** :ref:`Object` Un'implementazione di A\* per trovare il percorso più breve tra due vertici su un grafico collegato nello spazio 3D. .. rst-class:: classref-introduction-group Descrizione ---------------------- A\* (A star) è un algoritmo informatico utilizzato per le ricerche di percorsi e l'attraversamento di grafi, ovvero il processo di tracciare brevi percorsi tra vertici (punti) che passano per un determinato insieme di spigoli (segmenti). È ampiamente utilizzato grazie alle sue prestazioni e alla sua precisione. L'implementazione di A\* di Godot utilizza punti nello spazio 3D e distanze euclidee per impostazione predefinita. È necessario aggiungere manualmente i punti con :ref:`add_point()` e creare manualmente i segmenti con :ref:`connect_points()`. Una volta fatto, è possibile verificare se esiste un percorso tra due punti con la funzione :ref:`are_points_connected()`, ottenere un percorso contenente indici con :ref:`get_id_path()` o uno contenente coordinate effettive con :ref:`get_point_path()`. È anche possibile utilizzare distanze non euclidee. Per farlo, è necessario creare uno script che estenda **AStar3D** e sovrascriva i metodi :ref:`_compute_cost()` e :ref:`_estimate_cost()`. Entrambi dovrebbero accettare due ID punto e restituire la distanza tra i punti corrispondenti. \ **Esempio:** Usa la distanza di Manhattan invece della distanza euclidea: .. 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()` dovrebbe restituire un limite inferiore della distanza, ovvero ``_estimate_cost(u, v) <= _compute_cost(u, v)``. Questo serve come suggerimento per l'algoritmo, poiché il metodo personalizzato :ref:`_compute_cost()` potrebbe richiedere un'elaborazione complessa. In caso contrario, assicurarsi che :ref:`_estimate_cost()` restituisca lo stesso valore di :ref:`_compute_cost()` per fornire all'algoritmo le informazioni più accurate. Se sono utilizzati i metodi predefiniti :ref:`_estimate_cost()` e :ref:`_compute_cost()`, o se il metodo :ref:`_estimate_cost()` fornito restituisce un limite inferiore del costo, i percorsi restituiti da A\* saranno quelli con il costo più basso. In questo caso, il costo di un percorso è uguale alla somma dei risultati di :ref:`_compute_cost()` di tutti i segmenti del percorso, moltiplicati per i valori di ``weight_scale`` dei punti finali dei rispettivi segmenti. Se sono utilizzati i metodi predefiniti, e i valori di ``weight_scale`` di tutti i punti sono impostati su ``1.0``, questo è uguale alla somma delle distanze euclidee di tutti i segmenti del percorso. .. rst-class:: classref-reftable-group Proprietà ------------------ .. table:: :widths: auto +-------------------------+--------------------------------------------------------------------------------+-----------+ | :ref:`bool` | :ref:`neighbor_filter_enabled` | ``false`` | +-------------------------+--------------------------------------------------------------------------------+-----------+ .. rst-class:: classref-reftable-group Metodi ------------ .. table:: :widths: auto +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`_compute_cost`\ (\ from_id\: :ref:`int`, to_id\: :ref:`int`\ ) |virtual| |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`_estimate_cost`\ (\ from_id\: :ref:`int`, end_id\: :ref:`int`\ ) |virtual| |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`_filter_neighbor`\ (\ from_id\: :ref:`int`, neighbor_id\: :ref:`int`\ ) |virtual| |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`add_point`\ (\ id\: :ref:`int`, position\: :ref:`Vector3`, weight_scale\: :ref:`float` = 1.0\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`are_points_connected`\ (\ id\: :ref:`int`, to_id\: :ref:`int`, bidirectional\: :ref:`bool` = true\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear`\ (\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`connect_points`\ (\ id\: :ref:`int`, to_id\: :ref:`int`, bidirectional\: :ref:`bool` = true\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`disconnect_points`\ (\ id\: :ref:`int`, to_id\: :ref:`int`, bidirectional\: :ref:`bool` = true\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_available_point_id`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_closest_point`\ (\ to_position\: :ref:`Vector3`, include_disabled\: :ref:`bool` = false\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector3` | :ref:`get_closest_position_in_segment`\ (\ to_position\: :ref:`Vector3`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedInt64Array` | :ref:`get_id_path`\ (\ from_id\: :ref:`int`, to_id\: :ref:`int`, allow_partial_path\: :ref:`bool` = false\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_point_capacity`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedInt64Array` | :ref:`get_point_connections`\ (\ id\: :ref:`int`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_point_count`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedInt64Array` | :ref:`get_point_ids`\ (\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector3Array` | :ref:`get_point_path`\ (\ from_id\: :ref:`int`, to_id\: :ref:`int`, allow_partial_path\: :ref:`bool` = false\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector3` | :ref:`get_point_position`\ (\ id\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_point_weight_scale`\ (\ id\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has_point`\ (\ id\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_point_disabled`\ (\ id\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`remove_point`\ (\ id\: :ref:`int`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reserve_space`\ (\ num_nodes\: :ref:`int`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_point_disabled`\ (\ id\: :ref:`int`, disabled\: :ref:`bool` = true\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_point_position`\ (\ id\: :ref:`int`, position\: :ref:`Vector3`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_point_weight_scale`\ (\ id\: :ref:`int`, weight_scale\: :ref:`float`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni delle proprietà ------------------------------------------------------ .. _class_AStar3D_property_neighbor_filter_enabled: .. rst-class:: classref-property :ref:`bool` **neighbor_filter_enabled** = ``false`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_neighbor_filter_enabled**\ (\ value\: :ref:`bool`\ ) - :ref:`bool` **is_neighbor_filter_enabled**\ (\ ) Se ``true`` abilita il filtraggio dei vicini tramite :ref:`_filter_neighbor()`. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei metodi -------------------------------------------- .. _class_AStar3D_private_method__compute_cost: .. rst-class:: classref-method :ref:`float` **_compute_cost**\ (\ from_id\: :ref:`int`, to_id\: :ref:`int`\ ) |virtual| |const| :ref:`🔗` Chiamato quando si calcola il costo tra due punti collegati. Si noti che questa funzione è nascosta nella classe predefinita **AStar3D**. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_private_method__estimate_cost: .. rst-class:: classref-method :ref:`float` **_estimate_cost**\ (\ from_id\: :ref:`int`, end_id\: :ref:`int`\ ) |virtual| |const| :ref:`🔗` Chiamato quando si stima il costo tra un punto e il punto finale del percorso. Si noti che questa funzione è nascosta nella classe predefinita **AStar3D**. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_private_method__filter_neighbor: .. rst-class:: classref-method :ref:`bool` **_filter_neighbor**\ (\ from_id\: :ref:`int`, neighbor_id\: :ref:`int`\ ) |virtual| |const| :ref:`🔗` Chiamato quando il punto adiacente entra in elaborazione e se :ref:`neighbor_filter_enabled` è ``true``. Se viene restituito ``true``, il punto non sarà elaborato. Si noti che questa funzione è nascosta nella classe predefinita **AStar3D**. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_add_point: .. rst-class:: classref-method |void| **add_point**\ (\ id\: :ref:`int`, position\: :ref:`Vector3`, weight_scale\: :ref:`float` = 1.0\ ) :ref:`🔗` Aggiunge un nuovo punto nella posizione specificata con l'identificatore specificato. ``id`` deve essere uguale o superiore a 0 e ``weight_scale`` deve essere uguale o superiore a 0,0. \ ``weight_scale`` viene moltiplicato per il risultato di :ref:`_compute_cost()` quando si determina il costo complessivo del viaggio attraverso un segmento da un punto vicino a questo punto. Pertanto, a parità di condizioni, l'algoritmo preferisce i punti con ``weight_scale`` più bassi per formare un percorso. .. tabs:: .. code-tab:: gdscript var astar = AStar3D.new() astar.add_point(1, Vector3(1, 0, 0), 4) # Aggiunge il punto (1, 0, 0) con weight_scale 4 e id 1 .. code-tab:: csharp var astar = new AStar3D(); astar.AddPoint(1, nuovo Vector3(1, 0, 0), 4); // Aggiunge il punto (1, 0, 0) con weight_scale 4 e id 1 Se esiste già un punto per l'``id`` specificato, la sua posizione e la sua scala di peso vengono aggiornate ai valori specificati. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_are_points_connected: .. rst-class:: classref-method :ref:`bool` **are_points_connected**\ (\ id\: :ref:`int`, to_id\: :ref:`int`, bidirectional\: :ref:`bool` = true\ ) |const| :ref:`🔗` Restituisce se i due punti indicati sono collegati direttamente da un segmento. Se ``bidirectional`` è ``false``, restituisce se il movimento da ``id`` a ``to_id`` è possibile attraverso questo segmento. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_clear: .. rst-class:: classref-method |void| **clear**\ (\ ) :ref:`🔗` Cancella tutti i punti e i segmenti. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_connect_points: .. rst-class:: classref-method |void| **connect_points**\ (\ id\: :ref:`int`, to_id\: :ref:`int`, bidirectional\: :ref:`bool` = true\ ) :ref:`🔗` 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 = 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`, to_id\: :ref:`int`, bidirectional\: :ref:`bool` = true\ ) :ref:`🔗` 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_AStar3D_method_get_available_point_id: .. rst-class:: classref-method :ref:`int` **get_available_point_id**\ (\ ) |const| :ref:`🔗` Restituisce il prossimo disponibile ID di punto senza alcun punto ad esso associato. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_closest_point: .. rst-class:: classref-method :ref:`int` **get_closest_point**\ (\ to_position\: :ref:`Vector3`, include_disabled\: :ref:`bool` = false\ ) |const| :ref:`🔗` 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_AStar3D_method_get_closest_position_in_segment: .. rst-class:: classref-method :ref:`Vector3` **get_closest_position_in_segment**\ (\ to_position\: :ref:`Vector3`\ ) |const| :ref:`🔗` Restituisce la posizione più vicina a ``to_position`` che si trova all'interno di un segmento tra due punti collegati. .. 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)) # Returns (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)); // Returns (0, 3, 0) Il risultato è nel segmento che va da ``y = 0`` a ``y = 5``. È la posizione più vicina nel segmento al punto specificato. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_id_path: .. rst-class:: classref-method :ref:`PackedInt64Array` **get_id_path**\ (\ from_id\: :ref:`int`, to_id\: :ref:`int`, allow_partial_path\: :ref:`bool` = false\ ) :ref:`🔗` Restituisce un array con gli ID dei punti che formano il percorso trovato da AStar3D 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 = AStar3D.new() astar.add_point(1, Vector3(0, 0, 0)) astar.add_point(2, Vector3(0, 1, 0), 1) # Il peso predefinito è 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) # Restituisce [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); // Il peso predefinito è 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); // 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_AStar3D_method_get_point_capacity: .. rst-class:: classref-method :ref:`int` **get_point_capacity**\ (\ ) |const| :ref:`🔗` Restituisce la capacità della struttura che sostiene i punti, utile in combinazione con :ref:`reserve_space()`. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_point_connections: .. rst-class:: classref-method :ref:`PackedInt64Array` **get_point_connections**\ (\ id\: :ref:`int`\ ) :ref:`🔗` Restituisce un array con gli ID dei punti che formano la connessione con il punto indicato. .. 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 neighbors = astar.get_point_connections(1) # Returns [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[] neighbors = astar.GetPointConnections(1); // Returns [2, 3] .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_point_count: .. rst-class:: classref-method :ref:`int` **get_point_count**\ (\ ) |const| :ref:`🔗` Restituisce il numero di punti attualmente nell'insieme dei punti. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_point_ids: .. rst-class:: classref-method :ref:`PackedInt64Array` **get_point_ids**\ (\ ) :ref:`🔗` Restituisce un array di tutti gli ID dei punti. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_point_path: .. rst-class:: classref-method :ref:`PackedVector3Array` **get_point_path**\ (\ from_id\: :ref:`int`, to_id\: :ref:`int`, allow_partial_path\: :ref:`bool` = false\ ) :ref:`🔗` Restituisce un array con i punti che sono presenti nel percorso trovato da AStar3D 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` alla volta. Si consiglia di utilizzare :ref:`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_AStar3D_method_get_point_position: .. rst-class:: classref-method :ref:`Vector3` **get_point_position**\ (\ id\: :ref:`int`\ ) |const| :ref:`🔗` Restituisce la posizione del punto associato all'``id`` fornito. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_get_point_weight_scale: .. rst-class:: classref-method :ref:`float` **get_point_weight_scale**\ (\ id\: :ref:`int`\ ) |const| :ref:`🔗` Restituisce la scala di peso del punto associato all'``id`` fornito. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_has_point: .. rst-class:: classref-method :ref:`bool` **has_point**\ (\ id\: :ref:`int`\ ) |const| :ref:`🔗` Restituisce se esiste un punto associato all'``id`` fornito. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_is_point_disabled: .. rst-class:: classref-method :ref:`bool` **is_point_disabled**\ (\ id\: :ref:`int`\ ) |const| :ref:`🔗` 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_AStar3D_method_remove_point: .. rst-class:: classref-method |void| **remove_point**\ (\ id\: :ref:`int`\ ) :ref:`🔗` Rimuove il punto associato all'``id`` fornito dall'insieme di punti. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_reserve_space: .. rst-class:: classref-method |void| **reserve_space**\ (\ num_nodes\: :ref:`int`\ ) :ref:`🔗` 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_AStar3D_method_set_point_disabled: .. rst-class:: classref-method |void| **set_point_disabled**\ (\ id\: :ref:`int`, disabled\: :ref:`bool` = true\ ) :ref:`🔗` Disabilita o abilita il punto specificato per il rilevamento del percorso. Utile per creare un ostacolo temporaneo. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_set_point_position: .. rst-class:: classref-method |void| **set_point_position**\ (\ id\: :ref:`int`, position\: :ref:`Vector3`\ ) :ref:`🔗` Imposta la posizione ``position`` per il punto con l'``id`` fornito. .. rst-class:: classref-item-separator ---- .. _class_AStar3D_method_set_point_weight_scale: .. rst-class:: classref-method |void| **set_point_weight_scale**\ (\ id\: :ref:`int`, weight_scale\: :ref:`float`\ ) :ref:`🔗` Imposta la scala del peso (``weight_scale``) per il punto con l'``id`` fornito. ``weight_scale`` è moltiplicato per il risultato di :ref:`_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.)`