NavigationServer2D
Sperimentale: This class may be changed or removed in future versions.
Eredita: Object
Un'interfaccia server per l'accesso di basso livello alla navigazione 2D.
Descrizione
NavigationServer2D è il server che gestisce le mappe di navigazione, le regioni e gli agenti. Non gestisce la navigazione A* da AStar2D o AStarGrid2D.
Le mappe sono divise in regioni, composte da poligoni di navigazione. Insieme, definiscono le aree attraversabili nel mondo 2D.
Nota: La maggior parte delle modifiche nel NavigationServer2D ha effetto dopo il frame di fisica successivo e non immediatamente. Ciò include tutte le modifiche apportate a mappe, regioni o agenti da nodi nell'albero di scene che riguardano la navigazione, oppure tramite script.
Affinché due regioni siano collegate tra loro, devono condividere un bordo simile. Un bordo è considerato collegato a un altro se entrambi i suoi due vertici sono a una distanza inferiore a edge_connection_margin dal vertice dell'altro bordo rispettivo.
Puoi assegnare strati di navigazione alle regioni con region_set_navigation_layers(), che possono poi essere controllati quando si richiede un percorso con map_get_path(). Questo può essere usato per consentire o vietare determinate aree per alcuni oggetti.
Per usare il sistema di evasione delle collisioni, puoi usare gli agenti. Puoi impostare la velocità di destinazione di un agente, quindi i server emetteranno un callback con una velocità modificata.
Nota: Il sistema di evasione delle collisioni ignora le regioni. L'uso diretto della velocità modificata potrebbe spostare un agente al di fuori dell'area attraversabile. Questa è una limitazione del sistema di evasione delle collisioni, qualsiasi situazione più complessa potrebbe richiedere l'uso del motore di fisica.
Questo server tiene traccia di qualsiasi chiamata e la esegue durante la fase di sincronizzazione. Ciò significa che è possibile richiedere qualsiasi modifica alla mappa, usando qualsiasi thread, senza preoccupazioni.
Tutorial
Metodi
Segnali
avoidance_debug_changed() 🔗
Emesso quando vengono modificate le impostazioni di debug di evasione. Disponibile solo nelle build di debug.
Emesso quando una mappa di navigazione viene aggiornata, quando una regione si sposta o viene modificata.
navigation_debug_changed() 🔗
Emesso quando le impostazioni di debug di navigazione vengono modificate. Disponibile solo nelle build di debug.
Enumerazioni
enum ProcessInfo: 🔗
ProcessInfo INFO_ACTIVE_MAPS = 0
Costante per ottenere il numero di mappe di navigazione attive.
ProcessInfo INFO_REGION_COUNT = 1
Costante per ottenere il numero di regioni di navigazione attive.
ProcessInfo INFO_AGENT_COUNT = 2
Costante per ottenere il numero di agenti di navigazione attivi che stanno elaborando l'evasione.
ProcessInfo INFO_LINK_COUNT = 3
Costante per ottenere il numero di collegamenti di navigazione attivi.
ProcessInfo INFO_POLYGON_COUNT = 4
Costante per ottenere il numero di poligoni di mesh di navigazione.
ProcessInfo INFO_EDGE_COUNT = 5
Costante per ottenere il numero di bordi dei poligoni delle mesh di navigazione.
ProcessInfo INFO_EDGE_MERGE_COUNT = 6
Constant to get the number of navigation mesh polygon edges that were merged due to edge key overlap.
ProcessInfo INFO_EDGE_CONNECTION_COUNT = 7
Costante per ottenere il numero di bordi dei poligoni delle mesh di navigazione che sono considerati collegati dalla prossimità dei bordi.
ProcessInfo INFO_EDGE_FREE_COUNT = 8
Costante per ottenere il numero di bordi dei poligoni delle mesh di navigazione che non possono essere uniti ma che possono essere comunque collegati tramite prossimità dei bordi o tramite collegamenti.
ProcessInfo INFO_OBSTACLE_COUNT = 9
Costante per ottenere il numero di ostacoli di navigazione attivi.
Descrizioni dei metodi
Crea l'agente.
bool agent_get_avoidance_enabled(agent: RID) const 🔗
Restituisce true se l'agente specificato agent usa l'evasione.
int agent_get_avoidance_layers(agent: RID) const 🔗
Restituisce la bitmask avoidance_layers dell'agente specificato agent.
int agent_get_avoidance_mask(agent: RID) const 🔗
Restituisce il bitmask avoidance_mask dell'agente specificato agent.
float agent_get_avoidance_priority(agent: RID) const 🔗
Restituisce l'avoidance_priority dell'agente specificato agent.
RID agent_get_map(agent: RID) const 🔗
Restituisce il RID della mappa di navigazione a cui è attualmente assegnato l'agente agent richiesto.
int agent_get_max_neighbors(agent: RID) const 🔗
Restituisce il numero massimo di altri agenti che l'agente specificato agent tiene conto nella navigazione.
float agent_get_max_speed(agent: RID) const 🔗
Restituisce la velocità massima dell'agente specificato agent.
float agent_get_neighbor_distance(agent: RID) const 🔗
Restituisce la distanza massima da altri agenti che l'agente specificato agent tiene conto nella navigazione.
bool agent_get_paused(agent: RID) const 🔗
Restituisce true se l'agente specificato agent è in pausa.
Vector2 agent_get_position(agent: RID) const 🔗
Restituisce la posizione dell'agente specificato agent in spazio mondiale.
float agent_get_radius(agent: RID) const 🔗
Restituisce il raggio dell'agente specificato agent.
float agent_get_time_horizon_agents(agent: RID) const 🔗
Restituisce il periodo di tempo minimo per il quale le velocità dell'agente agent, calcolate dalla simulazione, sono sicure rispetto ad altri agenti.
float agent_get_time_horizon_obstacles(agent: RID) const 🔗
Restituisce il periodo di tempo minimo per il quale le velocità dell'agente agent, calcolate dalla simulazione, sono sicure rispetto agli ostacoli di evasione.
Vector2 agent_get_velocity(agent: RID) const 🔗
Restituisce la velocità dell'agente specificato agent.
bool agent_has_avoidance_callback(agent: RID) const 🔗
Restituisce true se l'agente agent ha un callback di evasione.
bool agent_is_map_changed(agent: RID) const 🔗
Restituisce true se la mappa è stata modificata nel frame precedente.
void agent_set_avoidance_callback(agent: RID, callback: Callable) 🔗
Imposta il callback Callable che viene chiamato dopo ogni fase di elaborazione dell'evasione per l'agente agent. Il safe_velocity calcolato sarà inviato con un segnale all'oggetto appena prima dei calcoli della fisica.
Nota: I callback creati sono sempre elaborati a prescindere dallo stato del SceneTree fin quando l'agente si trova su una mappa di navigazione e non è liberato. Per disabilitare l'invio di un callback da un agente, utilizza di nuovo agent_set_avoidance_callback() con un Callable vuoto.
void agent_set_avoidance_enabled(agent: RID, enabled: bool) 🔗
Se enabled è true, l'agente specificato agent usa l'evasione.
void agent_set_avoidance_layers(agent: RID, layers: int) 🔗
Imposta la bitmask avoidance_layers dell'agente.
void agent_set_avoidance_mask(agent: RID, mask: int) 🔗
Imposta la maschera di bit avoidance_mask dell'agente.
void agent_set_avoidance_priority(agent: RID, priority: float) 🔗
Imposta la priorità di evasione (avoidance_priority) dell'agente su priority, compreso tra 0,0 (priorità più bassa) e 1,0 (priorità più alta).
L'agente agent specificato non regola la velocità per altri agenti che corrisponderebbero alla maschera (avoidance_mask) ma hanno una priorità (avoidance_priority) inferiore. Ciò a sua volta fa in modo che gli altri agenti con priorità inferiore regolino ulteriormente le loro velocità per evitare collisioni con questo agente.
void agent_set_map(agent: RID, map: RID) 🔗
Mette l'agente nella mappa.
void agent_set_max_neighbors(agent: RID, count: int) 🔗
Imposta il numero massimo di altri agenti che l'agente prende in considerazione nella navigazione. Maggiore è questo numero, più lungo sarà il tempo di esecuzione della simulazione. Se il numero è troppo basso, la simulazione non sarà sicura.
void agent_set_max_speed(agent: RID, max_speed: float) 🔗
Imposta la velocità massima dell'agente. Dev'essere positiva.
void agent_set_neighbor_distance(agent: RID, distance: float) 🔗
Imposta la distanza massima da altri agenti che questo agente prende in considerazione nella navigazione. Maggiore è questo numero, più lungo sarà il tempo di esecuzione della simulazione. Se il numero è troppo basso, la simulazione non sarà sicura.
void agent_set_paused(agent: RID, paused: bool) 🔗
Se paused è true, l'agente agent non sarà elaborato. Ad esempio, non calcolerà le velocità di evasione o riceverà i callback di evasione.
void agent_set_position(agent: RID, position: Vector2) 🔗
Imposta la posizione dell'agente nello spazio mondiale.
void agent_set_radius(agent: RID, radius: float) 🔗
Imposta il raggio dell'agente.
void agent_set_time_horizon_agents(agent: RID, time_horizon: float) 🔗
La quantità minima di tempo per cui le velocità dell'agente calcolate dalla simulazione sono sicure rispetto ad altri agenti. Maggiore è questo numero, prima questo agente risponderà alla presenza di altri agenti, ma minore sarà la libertà che questo agente ha nello scegliere le sue velocità. Un valore troppo alto rallenterà notevolmente il movimento degli agenti. Deve essere positivo.
void agent_set_time_horizon_obstacles(agent: RID, time_horizon: float) 🔗
La quantità minima di tempo per cui le velocità dell'agente calcolate dalla simulazione sono sicure rispetto agli ostacoli statici di evasione. Maggiore è questo numero, prima questo agente risponderà alla presenza di ostacoli statici di evasione, ma minore è la libertà che questo agente ha nello scegliere le sue velocità. Un valore troppo alto rallenterà notevolmente il movimento degli agenti. Deve essere positivo.
void agent_set_velocity(agent: RID, velocity: Vector2) 🔗
Imposta velocity come la nuova velocità desiderata per l'agente agent. La simulazione di evasione cercherà di soddisfare questa velocità se possibile, ma la modificherà per evitare collisioni con altri agenti e ostacoli. Quando un agente viene teletrasportato in una nuova posizione lontana, usa invece agent_set_velocity_forced() per reimpostare lo stato interno della velocità.
void agent_set_velocity_forced(agent: RID, velocity: Vector2) 🔗
Sostituisce la velocità interna nella simulazione di evasione delle collisioni con velocity per l'agente agent. Quando un agente è teletrasportato in una nuova posizione lontana, questa funzione dovrebbe essere utilizzata nello stesso frame. Se chiamata frequentemente, questa funzione può bloccare gli agenti.
void bake_from_source_geometry_data(navigation_polygon: NavigationPolygon, source_geometry_data: NavigationMeshSourceGeometryData2D, callback: Callable = Callable()) 🔗
Prepara il poligono di navigazione navigation_polygon con i dati della geometria sorgente source_geometry_data. Una volta terminato il processo, verrà chiamato il callback facoltativo.
void bake_from_source_geometry_data_async(navigation_polygon: NavigationPolygon, source_geometry_data: NavigationMeshSourceGeometryData2D, callback: Callable = Callable()) 🔗
Prepara il poligono di navigazione navigation_polygon con i dati della geometria sorgente source_geometry_data come un'attività asincrona in esecuzione su un thread in background. Dopo che il processo è terminato, verrà chiamato il callback facoltativo.
Distrugge il RID specificato.
bool get_debug_enabled() const 🔗
Restituisce true quando il NavigationServer ha il debug abilitato.
Restituisce tutti i RID delle mappe di navigazione create sul NavigationServer. Restituisce sia le mappe di navigazione create in 2D sia quelle in 3D, poiché tecnicamente non c'è distinzione tra loro.
int get_process_info(process_info: ProcessInfo) const 🔗
Restituisce informazioni sullo stato attuale del NavigationServer.
bool is_baking_navigation_polygon(navigation_polygon: NavigationPolygon) const 🔗
Restituisce true quando il poligono di navigazione fornito è in fase di preparazione su un thread in background.
Crea un nuovo collegamento tra due posizioni su una mappa.
bool link_get_enabled(link: RID) const 🔗
Restituisce true se il collegamento link specificato è abilitato.
Vector2 link_get_end_position(link: RID) const 🔗
Restituisce la posizione finale di questo collegamento link.
float link_get_enter_cost(link: RID) const 🔗
Restituisce il costo di entrata di questo collegamento link.
int link_get_iteration_id(link: RID) const 🔗
Restituisce l'ID d'iterazione attuale del collegamento di navigazione. Ogni volta che il collegamento di navigazione cambia e si sincronizza, l'ID d'iterazione aumenta. Un ID d'iterazione pari a 0 significa che il collegamento di navigazione non si è mai sincronizzato.
Nota: L'ID d'iterazione ritornerà a 1 dopo aver raggiunto il suo limite di intervallo.
RID link_get_map(link: RID) const 🔗
Restituisce il RID della mappa di navigazione a cui è attualmente assegnato il collegamento (link) richiesto.
int link_get_navigation_layers(link: RID) const 🔗
Restituisce gli strati di navigazione per questo collegamento (link).
int link_get_owner_id(link: RID) const 🔗
Restituisce il ObjectID dell'oggetto che gestisce questo collegamento.
Vector2 link_get_start_position(link: RID) const 🔗
Restituisce la posizione di partenza di questo collegamento link.
float link_get_travel_cost(link: RID) const 🔗
Restituisce il costo di viaggio di questo collegamento link.
bool link_is_bidirectional(link: RID) const 🔗
Restituisce se questo collegamento link può essere viaggiato in entrambe le direzioni.
void link_set_bidirectional(link: RID, bidirectional: bool) 🔗
Imposta se questo collegamento link può essere viaggiato in entrambe le direzioni.
void link_set_enabled(link: RID, enabled: bool) 🔗
Se enabled è true, il collegamento specificato link contribuirà alla sua attuale mappa di navigazione.
void link_set_end_position(link: RID, position: Vector2) 🔗
Imposta la posizione di uscita per il collegamento link.
void link_set_enter_cost(link: RID, enter_cost: float) 🔗
Imposta il costo di entrata per questo collegamento link a enter_cost.
void link_set_map(link: RID, map: RID) 🔗
Imposta il RID della mappa di navigazione per il collegamento.
void link_set_navigation_layers(link: RID, navigation_layers: int) 🔗
Imposta gli strati di navigazione dei collegamento. Ciò consente di selezionare i collegamenti da una richiesta di percorso (quando si utilizza map_get_path()).
void link_set_owner_id(link: RID, owner_id: int) 🔗
Imposta l'ObjectID dell'oggetto che gestisce questo collegamento.
void link_set_start_position(link: RID, position: Vector2) 🔗
Imposta la posizione di ingresso per questo collegamento link.
void link_set_travel_cost(link: RID, travel_cost: float) 🔗
Imposta il costo di viaggio per questo collegamento link a travel_cost.
Crea una nuova mappa.
void map_force_update(map: RID) 🔗
Deprecato: This method is no longer supported, as it is incompatible with asynchronous updates. It can only be used in a single-threaded context, at your own risk.
Questa funzione forza immediatamente la sincronizzazione della mappa di navigazione specificata con il RID map. Come predefinito, le mappe di navigazione vengono sincronizzate solo alla fine di ogni frame di fisica. Questa funzione può essere utilizzata per (ri)calcolare immediatamente tutte le mesh di navigazione e le connessioni tra regioni della mappa di navigazione. Ciò consente di interrogare un percorso di navigazione per una mappa modificata immediatamente e nello stesso frame (più volte se necessario).
A causa di restrizioni tecniche, la coda attuale dei comandi del NavigationServer verrà svuotata. Ciò significa che tutti i comandi di aggiornamento già in coda per questo frame di fisica verranno eseguiti, anche quelli destinati ad altre mappe, regioni e agenti che non fanno parte della mappa specificata. Il costoso calcolo delle mesh di navigazione e delle connessioni tra regioni di una mappa verrà eseguito solo per la mappa specificata. Le altre mappe riceveranno la normale sincronizzazione alla fine del frame di fisica. Se la mappa specificata riceve modifiche dopo l'aggiornamento forzato, verrà aggiornata di nuovo anche quando le altre mappe riceveranno il loro aggiornamento.
L'elaborazione dell'evasione e l'invio dei segnali safe_velocity non sono influenzati da questa funzione e continuano ad accadere per tutte le mappe e gli agenti alla fine del frame di fisica.
Nota: Da un grande potere derivano grandi responsabilità. Questa funzione dovrebbe essere utilizzata solo da utenti che sanno davvero cosa stanno facendo e hanno una buona ragione per farlo. Forzare un aggiornamento immediato di una mappa di navigazione richiede il blocco del NavigationServer e lo svuotamento dell'intera coda dei comandi del NavigationServer. Ciò non solo può avere un impatto significativo sulle prestazioni di un gioco, ma può anche introdurre bug se utilizzato in modo inappropriato senza molta prudenza.
Array[RID] map_get_agents(map: RID) const 🔗
Restituisce i RID di tutti gli agenti di navigazione attualmente assegnati alla mappa di navigazione (map) richiesta.
float map_get_cell_size(map: RID) const 🔗
Restituisce le dimensioni della cella della mappa utilizzata per rasterizzare i vertici della mesh di navigazione.
Vector2 map_get_closest_point(map: RID, to_point: Vector2) const 🔗
Restituisce il punto sulla superfice della mesh di navigazione che è più vicino al punto to_point sulla mappa di navigazione map.
RID map_get_closest_point_owner(map: RID, to_point: Vector2) const 🔗
Restituisce il RID proprietario di regione per il punto sulla superfice della mesh di navigazione che è più vicino al punto to_point sulla mappa di navigazione map.
float map_get_edge_connection_margin(map: RID) const 🔗
Restituisce il margine di connessione ai bordi della mappa. Il margine di connessione ai bordi è una distanza utilizzata per collegare due regioni.
int map_get_iteration_id(map: RID) const 🔗
Restituisce l'ID d'iterazione attuale della mappa di navigazione. Ogni volta che la mappa di navigazione cambia e si sincronizza, l'ID d'iterazione aumenta. Un ID d'iterazione pari a 0 significa che la mappa di navigazione non si è mai sincronizzata.
Nota: L'ID d'iterazione tornerà a 1 dopo aver raggiunto il limite di intervallo.
float map_get_link_connection_radius(map: RID) const 🔗
Restituisce il raggio di connessione del collegamento nella mappa. Questa distanza è l'intervallo massimo in cui un collegamento cercherà i poligoni dei mesh di navigazione a cui collegarsi.
Array[RID] map_get_links(map: RID) const 🔗
Restituisce gli RID di tutti i collegamenti di navigazione che sono attualmente assegnati alla mappa di navigazione richiesta map.
float map_get_merge_rasterizer_cell_scale(map: RID) const 🔗
Restituisce la scala delle celle del rasterizzatore interno di unione della mappa.
Array[RID] map_get_obstacles(map: RID) const 🔗
Restituisce i RID di tutti gli ostacoli di navigazione attualmente assegnati alla mappa di navigazione specificata da map.
PackedVector2Array map_get_path(map: RID, origin: Vector2, destination: Vector2, optimize: bool, navigation_layers: int = 1) 🔗
Restituisce il percorso di navigazione per raggiungere la destinazione dall'origine. navigation_layers è una maschera di bit di tutti gli strati di navigazione della regione che possono essere presenti nel percorso.
Vector2 map_get_random_point(map: RID, navigation_layers: int, uniformly: bool) const 🔗
Restituisce una posizione casuale selezionata da tutti i poligoni della regione della mappa con gli strati di navigazione corrispondenti a navigation_layers.
Se uniformly è true, tutte le regioni della mappa, i poligoni e le facce sono pesati in base alla loro area superficiale (più lento).
Se uniformly è false, solo una regione casuale e un poligono casuale sono selezionati (più veloce).
Array[RID] map_get_regions(map: RID) const 🔗
Restituisce tutti i RID delle regioni di navigazione attualmente assegnate alla mappa di navigazione specificata da map.
bool map_get_use_async_iterations(map: RID) const 🔗
Restituisce true se la sincronizzazione della mappa map usa un processo asincrono che viene eseguito su un thread in background.
bool map_get_use_edge_connections(map: RID) const 🔗
Restituisce se la mappa di navigazione map consente alle regioni di navigazione di utilizzare le connessioni ai bordi per collegarsi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
bool map_is_active(map: RID) const 🔗
Restituisce true se la mappa è attiva.
void map_set_active(map: RID, active: bool) 🔗
Imposta la mappa come attiva.
void map_set_cell_size(map: RID, cell_size: float) 🔗
Imposta la dimensione delle celle della mappa utilizzata per rasterizzare i vertici della mesh di navigazione. Deve corrispondere alla dimensione delle celle delle mesh di navigazione utilizzate.
void map_set_edge_connection_margin(map: RID, margin: float) 🔗
Imposta il margine di connessione ai bordi della mappa utilizzato per unire i bordi delle regioni compatibili.
void map_set_link_connection_radius(map: RID, radius: float) 🔗
Imposta il raggio di connessione dei collegamenti della mappa utilizzato per collegare i collegamenti ai poligoni di navigazione.
void map_set_merge_rasterizer_cell_scale(map: RID, scale: float) 🔗
Imposta la scala delle celle del rasterizzatore interno di unione della mappa, utilizzata per controllare la sensibilità dell'unione.
void map_set_use_async_iterations(map: RID, enabled: bool) 🔗
Se enabled è true, la sincronizzazione della mappa map usa un processo asincrono che viene eseguito su un thread in background.
void map_set_use_edge_connections(map: RID, enabled: bool) 🔗
Imposta l'uso della connessione ai bordi della mappa di navigazione map. Se enabled è true, la mappa di navigazione consente alle regioni di navigazione di usare connessioni ai bordi per connettersi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
Crea un nuovo ostacolo di navigazione.
bool obstacle_get_avoidance_enabled(obstacle: RID) const 🔗
Restituisce true se l'ostacolo fornito obstacle ha l'evasione abilitata.
int obstacle_get_avoidance_layers(obstacle: RID) const 🔗
Restituisce il bitmask avoidance_layers dell'ostacolo specificato obstacle.
RID obstacle_get_map(obstacle: RID) const 🔗
Restituisce il RID della mappa di navigazione a cui è attualmente assegnato l'ostacolo (obstacle) richiesto.
bool obstacle_get_paused(obstacle: RID) const 🔗
Restituisce true se l'ostacolo specificato obstacle è in pausa.
Vector2 obstacle_get_position(obstacle: RID) const 🔗
Restituisce la posizione dell'ostacolo specificato obstacle in spazio mondiale.
float obstacle_get_radius(obstacle: RID) const 🔗
Restituisce il raggio dell'ostacolo dinamico specificato obstacle.
Vector2 obstacle_get_velocity(obstacle: RID) const 🔗
Restituisce la velocità dell'ostacolo dinamico specificato obstacle.
PackedVector2Array obstacle_get_vertices(obstacle: RID) const 🔗
Restituisce i vertici dei contorni per l'ostacolo specificato obstacle.
void obstacle_set_avoidance_enabled(obstacle: RID, enabled: bool) 🔗
Se enabled è true, l'ostacolo fornito obstacle influisce sull'evitasione usando degli agenti.
void obstacle_set_avoidance_layers(obstacle: RID, layers: int) 🔗
Imposta il bitmask avoidance_layers dell'ostacolo.
void obstacle_set_map(obstacle: RID, map: RID) 🔗
Imposta il RID della mappa di navigazione per l'ostacolo.
void obstacle_set_paused(obstacle: RID, paused: bool) 🔗
Se paused è true l'ostacolo obstacle non sarà elaborato. Ad esempio, non influirà più sulle velocità di evasione.
void obstacle_set_position(obstacle: RID, position: Vector2) 🔗
Imposta la posizione dell'ostacolo in spazio mondiale.
void obstacle_set_radius(obstacle: RID, radius: float) 🔗
Imposta il raggio dell'ostacolo dinamico.
void obstacle_set_velocity(obstacle: RID, velocity: Vector2) 🔗
Imposta la velocità dell'ostacolo obstacle dinamico su velocity. Consente ad altri agenti di prevedere meglio il movimento dell'ostacolo dinamico. Funziona solo in combinazione con il raggio dell'ostacolo.
void obstacle_set_vertices(obstacle: RID, vertices: PackedVector2Array) 🔗
Imposta i vertici di contorno per l'ostacolo. Se i vertici sono avvolti in senso orario, gli agenti saranno spinti dentro dall'ostacolo, altrimenti saranno spinti fuori.
void parse_source_geometry_data(navigation_polygon: NavigationPolygon, source_geometry_data: NavigationMeshSourceGeometryData2D, root_node: Node, callback: Callable = Callable()) 🔗
Analizza il SceneTree per la geometria sorgente in base alle proprietà di navigation_polygon. Aggiorna la risorsa source_geometry_data fornita con i dati risultanti. La risorsa può quindi essere utilizzata per preparare una mesh di navigazione con bake_from_source_geometry_data(). Dopo che il processo è terminato, verrà chiamato il callback facoltativo.
Nota: Questa funzione deve essere eseguita sul thread principale o con una chiamata differita poiché il SceneTree non è sicuro su altri thread.
Prestazioni: Sebbene sia conveniente, leggere gli array di dati dalle risorse Mesh può influire negativamente sul frame rate. I dati devono essere ricevuti dalla GPU, bloccando il RenderingServer nel processo. Per le prestazioni, si preferisce utilizzare, ad esempio, forme di collisione o creare gli array di dati interamente in codice.
void query_path(parameters: NavigationPathQueryParameters2D, result: NavigationPathQueryResult2D, callback: Callable = Callable()) 🔗
Ricerca un percorso in una mappa di navigazione specificata. La posizione di partenza e di arrivo e altri parametri sono definiti tramite NavigationPathQueryParameters2D. Aggiorna l'oggetto fornito NavigationPathQueryResult2D risultante con il percorso, assieme agli altri risultati richiesti dalla query. Dopo che il processo ha terminato, verrà chiamato il callback facoltativo.
Crea una nuova regione.
Rect2 region_get_bounds(region: RID) const 🔗
Restituisce il rettangolo allineato agli assi per la mesh trasformata di navigazione della regione region.
Vector2 region_get_closest_point(region: RID, to_point: Vector2) const 🔗
Restituisce il punto sulla superfice della mesh di navigazione che è più vicino al punto to_point sulla regione di navigazione region.
Vector2 region_get_connection_pathway_end(region: RID, connection: int) const 🔗
Restituisce il punto finale di una porta di connessione. connection è un indice compreso tra 0 e il valore restituito di region_get_connections_count().
Vector2 region_get_connection_pathway_start(region: RID, connection: int) const 🔗
Restituisce il punto iniziale di una porta di connessione. connection è un indice compreso tra 0 e il valore restituito di region_get_connections_count().
int region_get_connections_count(region: RID) const 🔗
Restituisce il numero di collegamenti che la regione region ha con altre regioni nella mappa.
bool region_get_enabled(region: RID) const 🔗
Restituisce true se la regione specifica region è abilitata.
float region_get_enter_cost(region: RID) const 🔗
Restituisce il costo di entrata di questa regione region.
int region_get_iteration_id(region: RID) const 🔗
Restituisce l'ID d'iterazione attuale della regione di navigazione. Ogni volta che la regione di navigazione cambia e si sincronizza, l'ID d'iterazione aumenta. Un ID d'iterazione pari a 0 significa che la regione di navigazione non si è mai sincronizzata.
Nota: L'ID d'iterazione ritornerà a 1 dopo aver raggiunto il suo limite di intervallo.
RID region_get_map(region: RID) const 🔗
Restituisce il RID della mappa di navigazione a cui è attualmente assegnata la regione region.
int region_get_navigation_layers(region: RID) const 🔗
Restituisce gli strati di navigazione della regione.
int region_get_owner_id(region: RID) const 🔗
Restituisce il ObjectID dell'oggetto che gestisce questa regione.
Vector2 region_get_random_point(region: RID, navigation_layers: int, uniformly: bool) const 🔗
Restituisce una posizione casuale selezionata da tutti i poligoni della regione con gli strati di navigazione corrispondenti a navigation_layers.
Se uniformly è true, tutti i poligoni e le facce della regione sono pesati in base alla loro area superficiale (più lento).
Se uniformly è false, solo un poligono casuale e una faccia sono selezionati (più veloce).
Transform2D region_get_transform(region: RID) const 🔗
Restituisce la trasformazione globale di questa region.
float region_get_travel_cost(region: RID) const 🔗
Restituisce il costo di viaggio di questa regione region.
bool region_get_use_async_iterations(region: RID) const 🔗
Restituisce true se la regione region usa un processo asincrono che viene eseguito su un thread in background.
bool region_get_use_edge_connections(region: RID) const 🔗
Restituisce se la regione di navigazione region è impostata per utilizzare le connessioni ai bordi per collegarsi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
bool region_owns_point(region: RID, point: Vector2) const 🔗
Restituisce true se il punto point nello spazio mondiale è attualmente appartenente alla regione di navigazione region. "Appartenente" in questo contesto significa che una delle facce del poligono della mesh di navigazione della regione ha una possibile posizione alla distanza più vicina a questo punto rispetto a tutte le altre mesh di navigazione da altre regioni di navigazione che sono registrate sulla stessa mappa di navigazione della regione.
Se più mesh di navigazione hanno posizioni a uguale distanza, la regione di navigazione i cui poligoni sono elaborati per primi vince l'appartenenza. I poligoni sono elaborati nello stesso ordine in cui le regioni di navigazione sono state registrate sul NavigationServer.
Nota: Se le mesh di navigazione da diverse regioni di navigazione si sovrappongono (cosa che si dovrebbe evitare in generale), il risultato potrebbe non essere quello previsto.
void region_set_enabled(region: RID, enabled: bool) 🔗
Se enabled è true la regione specificata region contribuirà alla sua attuale mappa di navigazione.
void region_set_enter_cost(region: RID, enter_cost: float) 🔗
Imposta il costo di entrata per questa regione region a enter_cost.
void region_set_map(region: RID, map: RID) 🔗
Imposta la mappa per la regione.
void region_set_navigation_layers(region: RID, navigation_layers: int) 🔗
Imposta gli strati di navigazione della regione. Ciò consente di selezionare regioni da una ricerca di percorso (quando si utilizza map_get_path()).
void region_set_navigation_polygon(region: RID, navigation_polygon: NavigationPolygon) 🔗
Imposta il poligono di navigazione per la regione a navigation_polygon.
void region_set_owner_id(region: RID, owner_id: int) 🔗
Imposta il ObjectID dell'oggetto che gestisce questa regione.
void region_set_transform(region: RID, transform: Transform2D) 🔗
Imposta la trasformazione globale per la regione.
void region_set_travel_cost(region: RID, travel_cost: float) 🔗
Imposta il costo di viaggio per questa regione region a travel_cost.
void region_set_use_async_iterations(region: RID, enabled: bool) 🔗
Se enabled è true, la regione region usa un processo asincrono che viene eseguito su un thread in background.
void region_set_use_edge_connections(region: RID, enabled: bool) 🔗
Se enabled è true, la regione di navigazione region utilizzerà connessioni ai bordi per collegarsi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
void set_active(active: bool) 🔗
Controlla l'attivazione di questo server.
void set_debug_enabled(enabled: bool) 🔗
Se true abilita la modalità di debug sul NavigationServer.
PackedVector2Array simplify_path(path: PackedVector2Array, epsilon: float) 🔗
Restituisce una versione semplificata del percorso path, con punti meno critici del percorso rimossi. La quantità di semplificazione è controllata da epsilon. La semplificazione utilizza una variazione dell'algoritmo Ramer-Douglas-Peucker per decimare i punti della curva.
La semplificazione del percorso può essere utile per mitigare vari problemi di seguimento del percorso che possono sorgere con certi tipi di agenti e comportamenti di script. Ad esempio, agenti che "sterzano" o evasione in "campi aperti".
RID source_geometry_parser_create() 🔗
Crea un nuovo parser di geometria sorgente. Se un Callable è impostato per il parser con source_geometry_parser_set_callback(), il callback verrà chiamato per ogni singolo nodo che viene analizzato, ogni volta che parse_source_geometry_data() viene utilizzato.
void source_geometry_parser_set_callback(parser: RID, callback: Callable) 🔗
Imposta il Callable callback per il parser della geometria sorgente specifico da parser. Il Callable riceverà una chiamata con i seguenti parametri:
navigation_mesh- Il riferimento NavigationPolygon utilizzato per definire la configurazione dell'analisi. NON modificarlo o aggiungerlo direttamente alla mesh di navigazione.source_geometry_data- Il riferimento NavigationMeshSourceGeometryData2D. Aggiungi una geometria sorgente personalizzata per la preparazione della mesh di navigazione a questo oggetto.node- Il Node che è analizzato.