godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/es/class_navigationserver2d.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

2164 lines
190 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_NavigationServer2D:
NavigationServer2D
==================
**Experimental:** This class may be changed or removed in future versions.
**Hereda:** :ref:`Object<class_Object>`
Una interfaz de servidor para acceso de navegación 2D de bajo nivel.
.. rst-class:: classref-introduction-group
Descripción
----------------------
NavigationServer2D es el servidor que gestiona los mapas, regiones y agentes de navegación. No gestiona la navegación A\* desde :ref:`AStar2D<class_AStar2D>` o :ref:`AStarGrid2D<class_AStarGrid2D>`.
Los mapas se dividen en regiones, que se componen de polígonos de navegación. Juntos, definen las áreas transitables en el mundo 2D.
\ **Nota:** La mayoría de los cambios de **NavigationServer2D** surten efecto después del siguiente fotograma de física y no inmediatamente. Esto incluye todos los cambios realizados en mapas, regiones o agentes por nodos relacionados con la navegación en el árbol de escenas o realizados a través de scripts.
Para que dos regiones se conecten entre sí, deben compartir un borde similar. Se considera que un borde está conectado a otro si ambos vértices están a una distancia inferior a ``edge_connection_margin`` del vértice del otro borde respectivo.
Puedes asignar capas de navegación a las regiones con :ref:`region_set_navigation_layers()<class_NavigationServer2D_method_region_set_navigation_layers>`, que luego se pueden verificar al solicitar una ruta con :ref:`map_get_path()<class_NavigationServer2D_method_map_get_path>`. Esto se puede utilizar para permitir o denegar ciertas áreas para algunos objetos.
Para utilizar el sistema de evitación de colisiones, puedes utilizar agentes. Puedes establecer la velocidad objetivo de un agente, luego los servidores emitirán una retrollamada con una velocidad modificada.
\ **Nota:** El sistema de evitación de colisiones ignora las regiones. El uso directo de la velocidad modificada puedes mover un agente fuera del área transitable. Esta es una limitación del sistema de evitación de colisiones, cualquier situación más compleja puedes requerir el uso del motor de física.
Este servidor realiza un seguimiento de cualquier llamada y la ejecuta durante la fase de sincronización. Esto significa que puedes solicitar cualquier cambio en el mapa, utilizando cualquier hilo, sin preocuparte.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Usar NavigationServer <../tutorials/navigation/navigation_using_navigationservers>`
- `Demo de Polígono de Navegación en 2D <https://godotengine.org/asset-library/asset/2722>`__
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`agent_create<class_NavigationServer2D_method_agent_create>`\ (\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_get_avoidance_enabled<class_NavigationServer2D_method_agent_get_avoidance_enabled>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`agent_get_avoidance_layers<class_NavigationServer2D_method_agent_get_avoidance_layers>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`agent_get_avoidance_mask<class_NavigationServer2D_method_agent_get_avoidance_mask>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_avoidance_priority<class_NavigationServer2D_method_agent_get_avoidance_priority>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`agent_get_map<class_NavigationServer2D_method_agent_get_map>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`agent_get_max_neighbors<class_NavigationServer2D_method_agent_get_max_neighbors>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_max_speed<class_NavigationServer2D_method_agent_get_max_speed>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_neighbor_distance<class_NavigationServer2D_method_agent_get_neighbor_distance>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_get_paused<class_NavigationServer2D_method_agent_get_paused>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`agent_get_position<class_NavigationServer2D_method_agent_get_position>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_radius<class_NavigationServer2D_method_agent_get_radius>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_time_horizon_agents<class_NavigationServer2D_method_agent_get_time_horizon_agents>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_time_horizon_obstacles<class_NavigationServer2D_method_agent_get_time_horizon_obstacles>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`agent_get_velocity<class_NavigationServer2D_method_agent_get_velocity>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_has_avoidance_callback<class_NavigationServer2D_method_agent_has_avoidance_callback>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_is_map_changed<class_NavigationServer2D_method_agent_is_map_changed>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_callback<class_NavigationServer2D_method_agent_set_avoidance_callback>`\ (\ agent\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_enabled<class_NavigationServer2D_method_agent_set_avoidance_enabled>`\ (\ agent\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_layers<class_NavigationServer2D_method_agent_set_avoidance_layers>`\ (\ agent\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_mask<class_NavigationServer2D_method_agent_set_avoidance_mask>`\ (\ agent\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_priority<class_NavigationServer2D_method_agent_set_avoidance_priority>`\ (\ agent\: :ref:`RID<class_RID>`, priority\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_map<class_NavigationServer2D_method_agent_set_map>`\ (\ agent\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_max_neighbors<class_NavigationServer2D_method_agent_set_max_neighbors>`\ (\ agent\: :ref:`RID<class_RID>`, count\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_max_speed<class_NavigationServer2D_method_agent_set_max_speed>`\ (\ agent\: :ref:`RID<class_RID>`, max_speed\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_neighbor_distance<class_NavigationServer2D_method_agent_set_neighbor_distance>`\ (\ agent\: :ref:`RID<class_RID>`, distance\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_paused<class_NavigationServer2D_method_agent_set_paused>`\ (\ agent\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_position<class_NavigationServer2D_method_agent_set_position>`\ (\ agent\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_radius<class_NavigationServer2D_method_agent_set_radius>`\ (\ agent\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_time_horizon_agents<class_NavigationServer2D_method_agent_set_time_horizon_agents>`\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_time_horizon_obstacles<class_NavigationServer2D_method_agent_set_time_horizon_obstacles>`\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_velocity<class_NavigationServer2D_method_agent_set_velocity>`\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_velocity_forced<class_NavigationServer2D_method_agent_set_velocity_forced>`\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bake_from_source_geometry_data<class_NavigationServer2D_method_bake_from_source_geometry_data>`\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bake_from_source_geometry_data_async<class_NavigationServer2D_method_bake_from_source_geometry_data_async>`\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`free_rid<class_NavigationServer2D_method_free_rid>`\ (\ rid\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_debug_enabled<class_NavigationServer2D_method_get_debug_enabled>`\ (\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`get_maps<class_NavigationServer2D_method_get_maps>`\ (\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_process_info<class_NavigationServer2D_method_get_process_info>`\ (\ process_info\: :ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_baking_navigation_polygon<class_NavigationServer2D_method_is_baking_navigation_polygon>`\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`link_create<class_NavigationServer2D_method_link_create>`\ (\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`link_get_enabled<class_NavigationServer2D_method_link_get_enabled>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`link_get_end_position<class_NavigationServer2D_method_link_get_end_position>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`link_get_enter_cost<class_NavigationServer2D_method_link_get_enter_cost>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`link_get_iteration_id<class_NavigationServer2D_method_link_get_iteration_id>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`link_get_map<class_NavigationServer2D_method_link_get_map>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`link_get_navigation_layers<class_NavigationServer2D_method_link_get_navigation_layers>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`link_get_owner_id<class_NavigationServer2D_method_link_get_owner_id>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`link_get_start_position<class_NavigationServer2D_method_link_get_start_position>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`link_get_travel_cost<class_NavigationServer2D_method_link_get_travel_cost>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`link_is_bidirectional<class_NavigationServer2D_method_link_is_bidirectional>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_bidirectional<class_NavigationServer2D_method_link_set_bidirectional>`\ (\ link\: :ref:`RID<class_RID>`, bidirectional\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_enabled<class_NavigationServer2D_method_link_set_enabled>`\ (\ link\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_end_position<class_NavigationServer2D_method_link_set_end_position>`\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_enter_cost<class_NavigationServer2D_method_link_set_enter_cost>`\ (\ link\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_map<class_NavigationServer2D_method_link_set_map>`\ (\ link\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_navigation_layers<class_NavigationServer2D_method_link_set_navigation_layers>`\ (\ link\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_owner_id<class_NavigationServer2D_method_link_set_owner_id>`\ (\ link\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_start_position<class_NavigationServer2D_method_link_set_start_position>`\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_travel_cost<class_NavigationServer2D_method_link_set_travel_cost>`\ (\ link\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`map_create<class_NavigationServer2D_method_map_create>`\ (\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_force_update<class_NavigationServer2D_method_map_force_update>`\ (\ map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_agents<class_NavigationServer2D_method_map_get_agents>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_cell_size<class_NavigationServer2D_method_map_get_cell_size>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`map_get_closest_point<class_NavigationServer2D_method_map_get_closest_point>`\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`map_get_closest_point_owner<class_NavigationServer2D_method_map_get_closest_point_owner>`\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_edge_connection_margin<class_NavigationServer2D_method_map_get_edge_connection_margin>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`map_get_iteration_id<class_NavigationServer2D_method_map_get_iteration_id>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_link_connection_radius<class_NavigationServer2D_method_map_get_link_connection_radius>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_links<class_NavigationServer2D_method_map_get_links>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_merge_rasterizer_cell_scale<class_NavigationServer2D_method_map_get_merge_rasterizer_cell_scale>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_obstacles<class_NavigationServer2D_method_map_get_obstacles>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`map_get_path<class_NavigationServer2D_method_map_get_path>`\ (\ map\: :ref:`RID<class_RID>`, origin\: :ref:`Vector2<class_Vector2>`, destination\: :ref:`Vector2<class_Vector2>`, optimize\: :ref:`bool<class_bool>`, navigation_layers\: :ref:`int<class_int>` = 1\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`map_get_random_point<class_NavigationServer2D_method_map_get_random_point>`\ (\ map\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_regions<class_NavigationServer2D_method_map_get_regions>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`map_get_use_async_iterations<class_NavigationServer2D_method_map_get_use_async_iterations>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`map_get_use_edge_connections<class_NavigationServer2D_method_map_get_use_edge_connections>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`map_is_active<class_NavigationServer2D_method_map_is_active>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_active<class_NavigationServer2D_method_map_set_active>`\ (\ map\: :ref:`RID<class_RID>`, active\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_cell_size<class_NavigationServer2D_method_map_set_cell_size>`\ (\ map\: :ref:`RID<class_RID>`, cell_size\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_edge_connection_margin<class_NavigationServer2D_method_map_set_edge_connection_margin>`\ (\ map\: :ref:`RID<class_RID>`, margin\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_link_connection_radius<class_NavigationServer2D_method_map_set_link_connection_radius>`\ (\ map\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_merge_rasterizer_cell_scale<class_NavigationServer2D_method_map_set_merge_rasterizer_cell_scale>`\ (\ map\: :ref:`RID<class_RID>`, scale\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_use_async_iterations<class_NavigationServer2D_method_map_set_use_async_iterations>`\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_use_edge_connections<class_NavigationServer2D_method_map_set_use_edge_connections>`\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`obstacle_create<class_NavigationServer2D_method_obstacle_create>`\ (\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`obstacle_get_avoidance_enabled<class_NavigationServer2D_method_obstacle_get_avoidance_enabled>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`obstacle_get_avoidance_layers<class_NavigationServer2D_method_obstacle_get_avoidance_layers>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`obstacle_get_map<class_NavigationServer2D_method_obstacle_get_map>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`obstacle_get_paused<class_NavigationServer2D_method_obstacle_get_paused>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`obstacle_get_position<class_NavigationServer2D_method_obstacle_get_position>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`obstacle_get_radius<class_NavigationServer2D_method_obstacle_get_radius>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`obstacle_get_velocity<class_NavigationServer2D_method_obstacle_get_velocity>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`obstacle_get_vertices<class_NavigationServer2D_method_obstacle_get_vertices>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_avoidance_enabled<class_NavigationServer2D_method_obstacle_set_avoidance_enabled>`\ (\ obstacle\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_avoidance_layers<class_NavigationServer2D_method_obstacle_set_avoidance_layers>`\ (\ obstacle\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_map<class_NavigationServer2D_method_obstacle_set_map>`\ (\ obstacle\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_paused<class_NavigationServer2D_method_obstacle_set_paused>`\ (\ obstacle\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_position<class_NavigationServer2D_method_obstacle_set_position>`\ (\ obstacle\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_radius<class_NavigationServer2D_method_obstacle_set_radius>`\ (\ obstacle\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_velocity<class_NavigationServer2D_method_obstacle_set_velocity>`\ (\ obstacle\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_vertices<class_NavigationServer2D_method_obstacle_set_vertices>`\ (\ obstacle\: :ref:`RID<class_RID>`, vertices\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`parse_source_geometry_data<class_NavigationServer2D_method_parse_source_geometry_data>`\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`, root_node\: :ref:`Node<class_Node>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`query_path<class_NavigationServer2D_method_query_path>`\ (\ parameters\: :ref:`NavigationPathQueryParameters2D<class_NavigationPathQueryParameters2D>`, result\: :ref:`NavigationPathQueryResult2D<class_NavigationPathQueryResult2D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`region_create<class_NavigationServer2D_method_region_create>`\ (\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`region_get_bounds<class_NavigationServer2D_method_region_get_bounds>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`region_get_closest_point<class_NavigationServer2D_method_region_get_closest_point>`\ (\ region\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`region_get_connection_pathway_end<class_NavigationServer2D_method_region_get_connection_pathway_end>`\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`region_get_connection_pathway_start<class_NavigationServer2D_method_region_get_connection_pathway_start>`\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_connections_count<class_NavigationServer2D_method_region_get_connections_count>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_get_enabled<class_NavigationServer2D_method_region_get_enabled>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`region_get_enter_cost<class_NavigationServer2D_method_region_get_enter_cost>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_iteration_id<class_NavigationServer2D_method_region_get_iteration_id>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`region_get_map<class_NavigationServer2D_method_region_get_map>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_navigation_layers<class_NavigationServer2D_method_region_get_navigation_layers>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_owner_id<class_NavigationServer2D_method_region_get_owner_id>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`region_get_random_point<class_NavigationServer2D_method_region_get_random_point>`\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`region_get_transform<class_NavigationServer2D_method_region_get_transform>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`region_get_travel_cost<class_NavigationServer2D_method_region_get_travel_cost>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_get_use_async_iterations<class_NavigationServer2D_method_region_get_use_async_iterations>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_get_use_edge_connections<class_NavigationServer2D_method_region_get_use_edge_connections>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_owns_point<class_NavigationServer2D_method_region_owns_point>`\ (\ region\: :ref:`RID<class_RID>`, point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_enabled<class_NavigationServer2D_method_region_set_enabled>`\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_enter_cost<class_NavigationServer2D_method_region_set_enter_cost>`\ (\ region\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_map<class_NavigationServer2D_method_region_set_map>`\ (\ region\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_navigation_layers<class_NavigationServer2D_method_region_set_navigation_layers>`\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_navigation_polygon<class_NavigationServer2D_method_region_set_navigation_polygon>`\ (\ region\: :ref:`RID<class_RID>`, navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_owner_id<class_NavigationServer2D_method_region_set_owner_id>`\ (\ region\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_transform<class_NavigationServer2D_method_region_set_transform>`\ (\ region\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_travel_cost<class_NavigationServer2D_method_region_set_travel_cost>`\ (\ region\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_use_async_iterations<class_NavigationServer2D_method_region_set_use_async_iterations>`\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_use_edge_connections<class_NavigationServer2D_method_region_set_use_edge_connections>`\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_active<class_NavigationServer2D_method_set_active>`\ (\ active\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_debug_enabled<class_NavigationServer2D_method_set_debug_enabled>`\ (\ enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`simplify_path<class_NavigationServer2D_method_simplify_path>`\ (\ path\: :ref:`PackedVector2Array<class_PackedVector2Array>`, epsilon\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`source_geometry_parser_create<class_NavigationServer2D_method_source_geometry_parser_create>`\ (\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`source_geometry_parser_set_callback<class_NavigationServer2D_method_source_geometry_parser_set_callback>`\ (\ parser\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Señales
--------------
.. _class_NavigationServer2D_signal_avoidance_debug_changed:
.. rst-class:: classref-signal
**avoidance_debug_changed**\ (\ ) :ref:`🔗<class_NavigationServer2D_signal_avoidance_debug_changed>`
Se emite cuando se cambian los ajustes de depuración de la evitación. Solo disponible en compilaciones de depuración.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_signal_map_changed:
.. rst-class:: classref-signal
**map_changed**\ (\ map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_signal_map_changed>`
Se emite cuando se actualiza un mapa de navegación, cuando una región se mueve o se modifica.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_signal_navigation_debug_changed:
.. rst-class:: classref-signal
**navigation_debug_changed**\ (\ ) :ref:`🔗<class_NavigationServer2D_signal_navigation_debug_changed>`
Se emite cuando se cambian los ajustes de depuración de la navegación. Solo disponible en compilaciones de depuración.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_NavigationServer2D_ProcessInfo:
.. rst-class:: classref-enumeration
enum **ProcessInfo**: :ref:`🔗<enum_NavigationServer2D_ProcessInfo>`
.. _class_NavigationServer2D_constant_INFO_ACTIVE_MAPS:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_ACTIVE_MAPS** = ``0``
Constante para obtener el número de mapas de navegación activos.
.. _class_NavigationServer2D_constant_INFO_REGION_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_REGION_COUNT** = ``1``
Constante para obtener el número de regiones de navegación activas.
.. _class_NavigationServer2D_constant_INFO_AGENT_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_AGENT_COUNT** = ``2``
Constante para obtener el número de agentes de navegación activos que procesan la evitación.
.. _class_NavigationServer2D_constant_INFO_LINK_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_LINK_COUNT** = ``3``
Constante para obtener el número de enlaces de navegación activos.
.. _class_NavigationServer2D_constant_INFO_POLYGON_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_POLYGON_COUNT** = ``4``
Constante para obtener el número de polígonos de malla de navegación.
.. _class_NavigationServer2D_constant_INFO_EDGE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_EDGE_COUNT** = ``5``
Constante para obtener el número de bordes de polígono de malla de navegación.
.. _class_NavigationServer2D_constant_INFO_EDGE_MERGE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_EDGE_MERGE_COUNT** = ``6``
Constante para obtener el número de bordes de polígono de la malla de navegación que se fusionaron debido a la superposición de claves de borde.
.. _class_NavigationServer2D_constant_INFO_EDGE_CONNECTION_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_EDGE_CONNECTION_COUNT** = ``7``
Constante para obtener el número de bordes de polígono de la malla de navegación que se consideran conectados por proximidad de borde.
.. _class_NavigationServer2D_constant_INFO_EDGE_FREE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_EDGE_FREE_COUNT** = ``8``
Constante para obtener el número de bordes de polígono de la malla de navegación que no se pudieron fusionar, pero que aún pueden estar conectados por proximidad de borde o con enlaces.
.. _class_NavigationServer2D_constant_INFO_OBSTACLE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>` **INFO_OBSTACLE_COUNT** = ``9``
Constante para obtener el número de obstáculos de navegación activos.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_NavigationServer2D_method_agent_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **agent_create**\ (\ ) :ref:`🔗<class_NavigationServer2D_method_agent_create>`
Crea el agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_avoidance_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_get_avoidance_enabled**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_avoidance_enabled>`
Devuelve ``true`` si el ``agent`` especificado utiliza evitación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_avoidance_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **agent_get_avoidance_layers**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_avoidance_layers>`
Devuelve la máscara de bits de ``avoidance_layers`` del ``agent`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_avoidance_mask:
.. rst-class:: classref-method
:ref:`int<class_int>` **agent_get_avoidance_mask**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_avoidance_mask>`
Devuelve la máscara de bits de ``avoidance_mask`` del ``agent`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_avoidance_priority:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_avoidance_priority**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_avoidance_priority>`
Devuelve la ``avoidance_priority`` del ``agent`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **agent_get_map**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_map>`
Devuelve el mapa de navegación :ref:`RID<class_RID>` al que está asignado actualmente el ``agent`` solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_max_neighbors:
.. rst-class:: classref-method
:ref:`int<class_int>` **agent_get_max_neighbors**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_max_neighbors>`
Devuelve el número máximo de otros agentes que el ``agent`` especificado tiene en cuenta en la navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_max_speed:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_max_speed**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_max_speed>`
Devuelve la velocidad máxima del ``agent`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_neighbor_distance:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_neighbor_distance**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_neighbor_distance>`
Devuelve la distancia máxima a otros agentes que el ``agent`` especificado tiene en cuenta en la navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_paused:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_get_paused**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_paused>`
Devuelve ``true`` si el ``agent`` especificado está en pausa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **agent_get_position**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_position>`
Devuelve la posición del ``agent`` especificado en el espacio global.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_radius:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_radius**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_radius>`
Devuelve el radio del ``agent`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_time_horizon_agents:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_time_horizon_agents**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_time_horizon_agents>`
Devuelve la cantidad mínima de tiempo durante la cual las velocidades del ``agent`` especificado que son calculadas por la simulación son seguras con respecto a otros agentes.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_time_horizon_obstacles:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_time_horizon_obstacles**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_time_horizon_obstacles>`
Devuelve la cantidad mínima de tiempo durante la cual las velocidades del ``agent`` especificado que son calculadas por la simulación son seguras con respecto a los obstáculos estáticos de evitación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_get_velocity:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **agent_get_velocity**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_get_velocity>`
Devuelve la velocidad del ``agent`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_has_avoidance_callback:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_has_avoidance_callback**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_has_avoidance_callback>`
Return ``true`` if the specified ``agent`` has an avoidance callback.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_is_map_changed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_is_map_changed**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_agent_is_map_changed>`
Devuelve ``true`` si el mapa cambió en el fotograma anterior.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_avoidance_callback:
.. rst-class:: classref-method
|void| **agent_set_avoidance_callback**\ (\ agent\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_avoidance_callback>`
Sets the callback :ref:`Callable<class_Callable>` that gets called after each avoidance processing step for the ``agent``. The calculated ``safe_velocity`` will be dispatched with a signal to the object just before the physics calculations.
\ **Note:** Created callbacks are always processed independently of the SceneTree state as long as the agent is on a navigation map and not freed. To disable the dispatch of a callback from an agent use :ref:`agent_set_avoidance_callback()<class_NavigationServer2D_method_agent_set_avoidance_callback>` again with an empty :ref:`Callable<class_Callable>`.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_avoidance_enabled:
.. rst-class:: classref-method
|void| **agent_set_avoidance_enabled**\ (\ agent\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_avoidance_enabled>`
Si ``enabled`` es ``true``, el ``agent`` especificado usa la evitación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_avoidance_layers:
.. rst-class:: classref-method
|void| **agent_set_avoidance_layers**\ (\ agent\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_avoidance_layers>`
Establece la máscara de bits ``avoidance_layers`` del agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_avoidance_mask:
.. rst-class:: classref-method
|void| **agent_set_avoidance_mask**\ (\ agent\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_avoidance_mask>`
Establece la máscara de bits ``avoidance_mask`` del agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_avoidance_priority:
.. rst-class:: classref-method
|void| **agent_set_avoidance_priority**\ (\ agent\: :ref:`RID<class_RID>`, priority\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_avoidance_priority>`
Establece la ``avoidance_priority`` del agente con una ``priority`` entre 0.0 (prioridad más baja) y 1.0 (prioridad más alta).
El ``agent`` especificado no ajusta la velocidad para otros agentes que coincidan con la ``avoidance_mask`` pero que tengan una ``avoidance_priority`` más baja. Esto a su vez hace que los otros agentes con menor prioridad ajusten aún más sus velocidades para evitar la colisión con este agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_map:
.. rst-class:: classref-method
|void| **agent_set_map**\ (\ agent\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_map>`
Pone al agente en el mapa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_max_neighbors:
.. rst-class:: classref-method
|void| **agent_set_max_neighbors**\ (\ agent\: :ref:`RID<class_RID>`, count\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_max_neighbors>`
Establece el número máximo de otros agentes que el agente tiene en cuenta en la navegación. Cuanto mayor sea este número, mayor será el tiempo de ejecución de la simulación. Si el número es demasiado bajo, la simulación no será segura.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_max_speed:
.. rst-class:: classref-method
|void| **agent_set_max_speed**\ (\ agent\: :ref:`RID<class_RID>`, max_speed\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_max_speed>`
Establece la velocidad máxima del agente. Debe ser positiva.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_neighbor_distance:
.. rst-class:: classref-method
|void| **agent_set_neighbor_distance**\ (\ agent\: :ref:`RID<class_RID>`, distance\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_neighbor_distance>`
Establece la distancia máxima a otros agentes que este agente tiene en cuenta en la navegación. Cuanto mayor sea este número, mayor será el tiempo de ejecución de la simulación. Si el número es demasiado bajo, la simulación no será segura.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_paused:
.. rst-class:: classref-method
|void| **agent_set_paused**\ (\ agent\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_paused>`
If ``paused`` is ``true`` the specified ``agent`` will not be processed. For example, it will not calculate avoidance velocities or receive avoidance callbacks.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_position:
.. rst-class:: classref-method
|void| **agent_set_position**\ (\ agent\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_position>`
Establece la posición del agente en el espacio mundial.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_radius:
.. rst-class:: classref-method
|void| **agent_set_radius**\ (\ agent\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_radius>`
Establece el radio del agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_time_horizon_agents:
.. rst-class:: classref-method
|void| **agent_set_time_horizon_agents**\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_time_horizon_agents>`
La cantidad mínima de tiempo durante la cual las velocidades del agente que son calculadas por la simulación son seguras con respecto a otros agentes. Cuanto mayor sea este número, antes responderá este agente a la presencia de otros agentes, pero menos libertad tendrá este agente para elegir sus velocidades. Un valor demasiado alto ralentizará considerablemente el movimiento de los agentes. Debe ser positivo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_time_horizon_obstacles:
.. rst-class:: classref-method
|void| **agent_set_time_horizon_obstacles**\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_time_horizon_obstacles>`
La cantidad mínima de tiempo durante la cual las velocidades del agente que son calculadas por la simulación son seguras con respecto a los obstáculos estáticos de evitación. Cuanto mayor sea este número, antes responderá este agente a la presencia de obstáculos estáticos de evitación, pero menos libertad tendrá este agente para elegir sus velocidades. Un valor demasiado alto ralentizará considerablemente el movimiento de los agentes. Debe ser positivo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_velocity:
.. rst-class:: classref-method
|void| **agent_set_velocity**\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_velocity>`
Establece ``velocity`` como la nueva velocidad deseada para el ``agent`` especificado. La simulación de evitación intentará cumplir con esta velocidad si es posible, pero la modificará para evitar colisiones con otros agentes y obstáculos. Cuando un agente se teletransporta a una nueva posición lejana, usa :ref:`agent_set_velocity_forced()<class_NavigationServer2D_method_agent_set_velocity_forced>` en su lugar para restablecer el estado de velocidad interno.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_agent_set_velocity_forced:
.. rst-class:: classref-method
|void| **agent_set_velocity_forced**\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_agent_set_velocity_forced>`
Reemplaza la velocidad interna en la simulación de evitación de colisiones con ``velocity`` para el ``agent`` especificado. Cuando un agente se teletransporta a una nueva posición lejana, esta función debe usarse en el mismo fotograma. Si se llama con frecuencia, esta función puede atascar a los agentes.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_bake_from_source_geometry_data:
.. rst-class:: classref-method
|void| **bake_from_source_geometry_data**\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer2D_method_bake_from_source_geometry_data>`
Procesa el ``navigation_polygon`` proporcionado con los datos del ``source_geometry_data`` proporcionado. Una vez finalizado el proceso, se llamará a la ``callback`` opcional.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_bake_from_source_geometry_data_async:
.. rst-class:: classref-method
|void| **bake_from_source_geometry_data_async**\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer2D_method_bake_from_source_geometry_data_async>`
Procesa el ``navigation_polygon`` proporcionado con los datos del ``source_geometry_data`` proporcionado como una tarea asíncrona que se ejecuta en un hilo en segundo plano. Una vez finalizado el proceso, se llamará a la ``callback`` opcional.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_free_rid:
.. rst-class:: classref-method
|void| **free_rid**\ (\ rid\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_method_free_rid>`
Destruye el RID dado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_get_debug_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_debug_enabled**\ (\ ) |const| :ref:`🔗<class_NavigationServer2D_method_get_debug_enabled>`
Devuelve ``true`` cuando NavigationServer tiene habilitada la depuración.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_get_maps:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **get_maps**\ (\ ) |const| :ref:`🔗<class_NavigationServer2D_method_get_maps>`
Devuelve todos los :ref:`RID<class_RID>` del mapa de navegación creados en el NavigationServer. Esto devuelve los mapas de navegación 2D y 3D creados, ya que técnicamente no hay distinción entre ellos.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_get_process_info:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_process_info**\ (\ process_info\: :ref:`ProcessInfo<enum_NavigationServer2D_ProcessInfo>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_get_process_info>`
Devuelve información sobre el estado actual del NavigationServer.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_is_baking_navigation_polygon:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_baking_navigation_polygon**\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_is_baking_navigation_polygon>`
Devuelve ``true`` cuando el polígono de navegación proporcionado se está procesando en un hilo en segundo plano.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **link_create**\ (\ ) :ref:`🔗<class_NavigationServer2D_method_link_create>`
Crea un nuevo enlace entre dos posiciones en un mapa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **link_get_enabled**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_enabled>`
Devuelve ``true`` si el ``link`` especificado está habilitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_end_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **link_get_end_position**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_end_position>`
Devuelve la posición final de este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_enter_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **link_get_enter_cost**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_enter_cost>`
Devuelve el costo de entrada de este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_iteration_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **link_get_iteration_id**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_iteration_id>`
Devuelve el ID de iteración actual del enlace de navegación. Cada vez que el enlace de navegación cambia y se sincroniza, el ID de iteración aumenta. Un ID de iteración de ``0`` significa que el enlace de navegación nunca se ha sincronizado.
\ **Nota:** El ID de iteración volverá a ``1`` después de alcanzar su límite de rango.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **link_get_map**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_map>`
Devuelve el mapa de navegación :ref:`RID<class_RID>` al que está asignado actualmente el ``link`` solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_navigation_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **link_get_navigation_layers**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_navigation_layers>`
Devuelve las capas de navegación para este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_owner_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **link_get_owner_id**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_owner_id>`
Devuelve el ``ObjectID`` del objeto que administra este vínculo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_start_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **link_get_start_position**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_start_position>`
Devuelve la posición inicial de este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_get_travel_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **link_get_travel_cost**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_get_travel_cost>`
Devuelve el costo del viaje de este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_is_bidirectional:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **link_is_bidirectional**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_link_is_bidirectional>`
Devuelve si este ``link`` se puede recorrer en ambas direcciones.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_bidirectional:
.. rst-class:: classref-method
|void| **link_set_bidirectional**\ (\ link\: :ref:`RID<class_RID>`, bidirectional\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_bidirectional>`
Establece si este ``link`` se puede recorrer en ambas direcciones.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_enabled:
.. rst-class:: classref-method
|void| **link_set_enabled**\ (\ link\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_enabled>`
Si ``enabled`` es ``true``, el ``link`` especificado contribuirá a su mapa de navegación actual.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_end_position:
.. rst-class:: classref-method
|void| **link_set_end_position**\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_end_position>`
Establece la posición de salida para el ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_enter_cost:
.. rst-class:: classref-method
|void| **link_set_enter_cost**\ (\ link\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_enter_cost>`
Establece el ``enter_cost`` para este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_map:
.. rst-class:: classref-method
|void| **link_set_map**\ (\ link\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_map>`
Establece el :ref:`RID<class_RID>` del mapa de navegación para el enlace.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_navigation_layers:
.. rst-class:: classref-method
|void| **link_set_navigation_layers**\ (\ link\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_navigation_layers>`
Establece las capas de navegación del enlace. Esto permite seleccionar enlaces de una solicitud de ruta (cuando se usa :ref:`map_get_path()<class_NavigationServer2D_method_map_get_path>`).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_owner_id:
.. rst-class:: classref-method
|void| **link_set_owner_id**\ (\ link\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_owner_id>`
Establece el ``ObjectID`` del objeto que gestiona este enlace.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_start_position:
.. rst-class:: classref-method
|void| **link_set_start_position**\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_start_position>`
Establece la posición de entrada para este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_link_set_travel_cost:
.. rst-class:: classref-method
|void| **link_set_travel_cost**\ (\ link\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_link_set_travel_cost>`
Establece el ``travel_cost`` para este ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **map_create**\ (\ ) :ref:`🔗<class_NavigationServer2D_method_map_create>`
Crea un nuevo mapa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_force_update:
.. rst-class:: classref-method
|void| **map_force_update**\ (\ map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_force_update>`
**Obsoleto:** 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.
Esta función fuerza inmediatamente la sincronización del ``map`` de navegación especificado :ref:`RID<class_RID>`. Por defecto, los mapas de navegación solo se sincronizan al final de cada fotograma de física. Esta función se puede utilizar para (re)calcular inmediatamente todas las mallas de navegación y las conexiones de región del mapa de navegación. Esto permite consultar un camino de navegación para un mapa cambiado inmediatamente y en el mismo fotograma (varias veces si es necesario).
Debido a restricciones técnicas, la cola de comandos actual de NavigationServer se vaciará. Esto significa que todos los comandos de actualización ya en cola para este fotograma de física se ejecutarán, incluso aquellos destinados a otros mapas, regiones y agentes que no forman parte del mapa especificado. El costoso cálculo de las mallas de navegación y las conexiones de región de un mapa solo se realizará para el mapa especificado. Otros mapas recibirán la sincronización normal al final del fotograma de física. Si el mapa especificado recibe cambios después de la actualización forzada, también se actualizará de nuevo cuando los otros mapas reciban su actualización.
El procesamiento de evitación y el envío de las señales de ``safe_velocity`` no se ven afectados por esta función y continúan ocurriendo para todos los mapas y agentes al final del fotograma de física.
\ **Nota:** Un gran poder conlleva una gran responsabilidad. Esta función solo debe ser utilizada por usuarios que realmente sepan lo que están haciendo y tengan una buena razón para ello. Forzar una actualización inmediata de un mapa de navegación requiere bloquear el NavigationServer y vaciar toda la cola de comandos del NavigationServer. Esto no solo puede afectar gravemente al rendimiento de un juego, sino que también puede introducir errores si se utiliza de forma inapropiada sin mucha previsión.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_agents:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_agents**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_agents>`
Devuelve todos los :ref:`RID<class_RID>` de agentes de navegación que están actualmente asignados al ``map`` de navegación solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_cell_size:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_cell_size**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_cell_size>`
Devuelve el tamaño de celda del mapa utilizado para rasterizar los vértices de la malla de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_closest_point:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **map_get_closest_point**\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_closest_point>`
Devuelve el punto de la superficie de la malla de navegación más cercano al ``to_point`` proporcionado en el ``map`` de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_closest_point_owner:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **map_get_closest_point_owner**\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_closest_point_owner>`
Devuelve el RID de la región propietaria del punto de la superficie de la malla de navegación más cercano al ``to_point`` proporcionado en el ``map`` de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_edge_connection_margin:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_edge_connection_margin**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_edge_connection_margin>`
Devuelve el margen de conexión de borde del mapa. El margen de conexión de borde es una distancia utilizada para conectar dos regiones.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_iteration_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **map_get_iteration_id**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_iteration_id>`
Devuelve el ID de iteración actual del mapa de navegación. Cada vez que el mapa de navegación cambia y se sincroniza, el ID de iteración aumenta. Un ID de iteración de 0 significa que el mapa de navegación nunca se ha sincronizado.
\ **Nota:** El ID de iteración volverá a 1 después de alcanzar el límite de su rango.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_link_connection_radius:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_link_connection_radius**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_link_connection_radius>`
Devuelve el radio de conexión del enlace del mapa. Esta distancia es el alcance máximo que cualquier enlace buscará para los polígonos de la malla de navegación a los que conectarse.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_links:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_links**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_links>`
Devuelve todos los :ref:`RID<class_RID>` de enlaces de navegación que están actualmente asignados al ``map`` de navegación solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_merge_rasterizer_cell_scale:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_merge_rasterizer_cell_scale**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_merge_rasterizer_cell_scale>`
Devuelve la escala de celda interna del rasterizador de fusión del mapa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_obstacles:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_obstacles**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_obstacles>`
Devuelve todos los :ref:`RID<class_RID>` de obstáculos de navegación que están actualmente asignados al ``map`` de navegación solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_path:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **map_get_path**\ (\ map\: :ref:`RID<class_RID>`, origin\: :ref:`Vector2<class_Vector2>`, destination\: :ref:`Vector2<class_Vector2>`, optimize\: :ref:`bool<class_bool>`, navigation_layers\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_NavigationServer2D_method_map_get_path>`
Devuelve la ruta de navegación para alcanzar el destino desde el origen. ``navigation_layers`` es una máscara de bits de todas las capas de navegación de la región que pueden estar en la ruta.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_random_point:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **map_get_random_point**\ (\ map\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_random_point>`
Devuelve una posición aleatoria seleccionada de todos los polígonos de la región del mapa que coincidan con ``navigation_layers``.
Si ``uniformly`` es ``true``, todas las regiones del mapa, los polígonos y las caras se ponderan por su área de superficie (más lento).
Si ``uniformly`` es ``false``, solo se elige una región aleatoria y un polígono aleatorio (más rápido).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_regions:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_regions**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_regions>`
Devuelve todos los :ref:`RID<class_RID>` de las regiones de navegación que están actualmente asignadas al ``map`` de navegación solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_use_async_iterations:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **map_get_use_async_iterations**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_use_async_iterations>`
Devuelve ``true`` si la sincronización del ``map`` utiliza un proceso asíncrono que se ejecuta en un hilo en segundo plano.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_get_use_edge_connections:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **map_get_use_edge_connections**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_get_use_edge_connections>`
Devuelve si el ``map`` de navegación permite que las regiones de navegación utilicen conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_is_active:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **map_is_active**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_map_is_active>`
Devuelve ``true`` si el mapa está activo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_active:
.. rst-class:: classref-method
|void| **map_set_active**\ (\ map\: :ref:`RID<class_RID>`, active\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_active>`
Establece el mapa como activo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_cell_size:
.. rst-class:: classref-method
|void| **map_set_cell_size**\ (\ map\: :ref:`RID<class_RID>`, cell_size\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_cell_size>`
Establece el tamaño de celda del mapa utilizado para rasterizar los vértices de la malla de navegación. Debe coincidir con el tamaño de celda de las mallas de navegación utilizadas.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_edge_connection_margin:
.. rst-class:: classref-method
|void| **map_set_edge_connection_margin**\ (\ map\: :ref:`RID<class_RID>`, margin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_edge_connection_margin>`
Establece el margen de conexión de borde del mapa utilizado para soldar los bordes de región compatibles.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_link_connection_radius:
.. rst-class:: classref-method
|void| **map_set_link_connection_radius**\ (\ map\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_link_connection_radius>`
Establece el radio de conexión del enlace del mapa utilizado para conectar los enlaces a los polígonos de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_merge_rasterizer_cell_scale:
.. rst-class:: classref-method
|void| **map_set_merge_rasterizer_cell_scale**\ (\ map\: :ref:`RID<class_RID>`, scale\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_merge_rasterizer_cell_scale>`
Establece la escala de celda interna del rasterizador de fusión del mapa utilizada para controlar la sensibilidad de la fusión.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_use_async_iterations:
.. rst-class:: classref-method
|void| **map_set_use_async_iterations**\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_use_async_iterations>`
Si ``enabled`` es ``true``, la sincronización del ``map`` utiliza un proceso asíncrono que se ejecuta en un hilo en segundo plano.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_map_set_use_edge_connections:
.. rst-class:: classref-method
|void| **map_set_use_edge_connections**\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_map_set_use_edge_connections>`
Establece el uso de la conexión de borde del ``map`` de navegación. Si ``enabled`` es ``true``, el mapa de navegación permite que las regiones de navegación utilicen conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **obstacle_create**\ (\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_create>`
Crea un nuevo obstáculo de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_avoidance_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **obstacle_get_avoidance_enabled**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_avoidance_enabled>`
Devuelve ``true`` si el ``obstacle`` proporcionado tiene la evitación habilitada.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_avoidance_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **obstacle_get_avoidance_layers**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_avoidance_layers>`
Devuelve la máscara de bits de ``avoidance_layers`` del ``obstacle`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **obstacle_get_map**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_map>`
Devuelve el :ref:`RID<class_RID>` del mapa de navegación al que está asignado actualmente el ``obstacle`` solicitado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_paused:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **obstacle_get_paused**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_paused>`
Devuelve ``true`` si el ``obstacle`` especificado está en pausa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **obstacle_get_position**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_position>`
Devuelve la posición del ``obstacle`` especificado en el espacio mundial.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_radius:
.. rst-class:: classref-method
:ref:`float<class_float>` **obstacle_get_radius**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_radius>`
Devuelve el radio del ``obstacle`` dinámico especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_velocity:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **obstacle_get_velocity**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_velocity>`
Devuelve la velocidad del ``obstacle`` dinámico especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_get_vertices:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **obstacle_get_vertices**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_obstacle_get_vertices>`
Devuelve los vértices del contorno para el ``obstacle`` especificado.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_avoidance_enabled:
.. rst-class:: classref-method
|void| **obstacle_set_avoidance_enabled**\ (\ obstacle\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_avoidance_enabled>`
Si ``enabled`` es ``true``, el ``obstacle`` proporcionado afecta la evitación usando agentes.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_avoidance_layers:
.. rst-class:: classref-method
|void| **obstacle_set_avoidance_layers**\ (\ obstacle\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_avoidance_layers>`
Establece la máscara de bits ``avoidance_layers`` del obstáculo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_map:
.. rst-class:: classref-method
|void| **obstacle_set_map**\ (\ obstacle\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_map>`
Establece el :ref:`RID<class_RID>` del mapa de navegación para el obstáculo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_paused:
.. rst-class:: classref-method
|void| **obstacle_set_paused**\ (\ obstacle\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_paused>`
Si ``paused`` es ``true``, el ``obstacle`` especificado no se procesará. Por ejemplo, ya no afectará las velocidades de evitación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_position:
.. rst-class:: classref-method
|void| **obstacle_set_position**\ (\ obstacle\: :ref:`RID<class_RID>`, position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_position>`
Establece la posición del obstáculo en el espacio del mundo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_radius:
.. rst-class:: classref-method
|void| **obstacle_set_radius**\ (\ obstacle\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_radius>`
Establece el radio del obstáculo dinámico.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_velocity:
.. rst-class:: classref-method
|void| **obstacle_set_velocity**\ (\ obstacle\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_velocity>`
Establece ``velocity`` del ``obstacle`` dinámico. Permite que otros agentes predigan mejor el movimiento del obstáculo dinámico. Solo funciona en combinación con el radio del obstáculo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_obstacle_set_vertices:
.. rst-class:: classref-method
|void| **obstacle_set_vertices**\ (\ obstacle\: :ref:`RID<class_RID>`, vertices\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_NavigationServer2D_method_obstacle_set_vertices>`
Establece los vértices del contorno para el obstáculo. Si los vértices se enrollan en el sentido de las agujas del reloj, los agentes serán empujados hacia adentro por el obstáculo, de lo contrario, serán empujados hacia afuera.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_parse_source_geometry_data:
.. rst-class:: classref-method
|void| **parse_source_geometry_data**\ (\ navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`, root_node\: :ref:`Node<class_Node>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer2D_method_parse_source_geometry_data>`
Analiza el :ref:`SceneTree<class_SceneTree>` para la geometría de origen de acuerdo con las propiedades de ``navigation_polygon``. Actualiza el recurso ``source_geometry_data`` proporcionado con los datos resultantes. El recurso se puede utilizar para procesar una malla de navegación con :ref:`bake_from_source_geometry_data()<class_NavigationServer2D_method_bake_from_source_geometry_data>`. Una vez finalizado el proceso, se llamará a la ``callback`` opcional.
\ **Nota:** Esta función debe ejecutarse en el hilo principal o con una llamada diferida, ya que SceneTree no es seguro para subprocesos.
\ **Rendimiento:** Si bien es conveniente, leer arrays de datos de los recursos :ref:`Mesh<class_Mesh>` puede afectar negativamente la velocidad de fotogramas. Los datos deben recibirse de la GPU, lo que detiene el :ref:`RenderingServer<class_RenderingServer>` en el proceso. Para el rendimiento, prefiera el uso de, p. formas de colisión o crear arrays de datos completamente en el código.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_query_path:
.. rst-class:: classref-method
|void| **query_path**\ (\ parameters\: :ref:`NavigationPathQueryParameters2D<class_NavigationPathQueryParameters2D>`, result\: :ref:`NavigationPathQueryResult2D<class_NavigationPathQueryResult2D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer2D_method_query_path>`
Consulta una ruta en un mapa de navegación dado. La posición de inicio y destino y otros parámetros se definen a través de :ref:`NavigationPathQueryParameters2D<class_NavigationPathQueryParameters2D>`. Actualiza el objeto de resultado :ref:`NavigationPathQueryResult2D<class_NavigationPathQueryResult2D>` proporcionado con la ruta entre otros resultados solicitados por la consulta. Una vez finalizado el proceso, se llamará a la ``callback`` opcional.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **region_create**\ (\ ) :ref:`🔗<class_NavigationServer2D_method_region_create>`
Crea una nueva región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_bounds:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **region_get_bounds**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_bounds>`
Devuelve el rectángulo alineado con los ejes para la malla de navegación transformada de la ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_closest_point:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **region_get_closest_point**\ (\ region\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_closest_point>`
Devuelve el punto de la superficie de la malla de navegación más cercano al ``to_point`` proporcionado en la ``region`` de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_connection_pathway_end:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **region_get_connection_pathway_end**\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_connection_pathway_end>`
Devuelve el punto final de una puerta de conexión. ``connection`` es un índice entre 0 y el valor de retorno de :ref:`region_get_connections_count()<class_NavigationServer2D_method_region_get_connections_count>`.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_connection_pathway_start:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **region_get_connection_pathway_start**\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_connection_pathway_start>`
Devuelve el punto de inicio de una puerta de conexión. ``connection`` es un índice entre 0 y el valor de retorno de :ref:`region_get_connections_count()<class_NavigationServer2D_method_region_get_connections_count>`.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_connections_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_connections_count**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_connections_count>`
Devuelve cuántas conexiones tiene esta ``region`` con otras regiones en el mapa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_get_enabled**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_enabled>`
Devuelve ``true`` si la ``region`` especificada está habilitada.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_enter_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **region_get_enter_cost**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_enter_cost>`
Devuelve el costo de entrada de esta ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_iteration_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_iteration_id**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_iteration_id>`
Devuelve el ID de iteración actual de la región de navegación. Cada vez que la región de navegación cambia y se sincroniza, el ID de iteración aumenta. Un ID de iteración de ``0`` significa que la región de navegación nunca se ha sincronizado.
\ **Nota:** El ID de iteración volverá a ``1`` después de alcanzar su límite de rango.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **region_get_map**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_map>`
Devuelve el mapa de navegación :ref:`RID<class_RID>` al que está asignada actualmente la ``region`` solicitada.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_navigation_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_navigation_layers**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_navigation_layers>`
Devuelve las capas de navegación de la región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_owner_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_owner_id**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_owner_id>`
Devuelve el ``ObjectID`` del objeto que gestiona esta región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_random_point:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **region_get_random_point**\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_random_point>`
Devuelve una posición aleatoria seleccionada de todos los polígonos de la región que coinciden con ``navigation_layers``.
Si ``uniformly`` es ``true``, todos los polígonos y caras de la región se ponderan por su área de superficie (más lento).
Si ``uniformly`` es ``false``, solo se elige un polígono y una cara aleatorios (más rápido).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **region_get_transform**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_transform>`
Devuelve la transformación global de esta ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_travel_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **region_get_travel_cost**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_travel_cost>`
Devuelve el costo de viaje de esta ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_use_async_iterations:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_get_use_async_iterations**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_use_async_iterations>`
Devuelve ``true`` si la ``region`` utiliza un proceso de sincronización asíncrono que se ejecuta en un hilo secundario.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_get_use_edge_connections:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_get_use_edge_connections**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_get_use_edge_connections>`
Devuelve si la ``region`` de navegación está configurada para utilizar conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_owns_point:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_owns_point**\ (\ region\: :ref:`RID<class_RID>`, point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_NavigationServer2D_method_region_owns_point>`
Returns ``true`` if the provided ``point`` in world space is currently owned by the provided navigation ``region``. Owned in this context means that one of the region's navigation mesh polygon faces has a possible position at the closest distance to this point compared to all other navigation meshes from other navigation regions that are also registered on the navigation map of the provided region.
If multiple navigation meshes have positions at equal distance the navigation region whose polygons are processed first wins the ownership. Polygons are processed in the same order that navigation regions were registered on the NavigationServer.
\ **Note:** If navigation meshes from different navigation regions overlap (which should be avoided in general) the result might not be what is expected.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_enabled:
.. rst-class:: classref-method
|void| **region_set_enabled**\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_enabled>`
Si ``enabled`` es ``true``, la ``region`` especificada contribuirá a su mapa de navegación actual.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_enter_cost:
.. rst-class:: classref-method
|void| **region_set_enter_cost**\ (\ region\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_enter_cost>`
Establece el ``enter_cost`` para esta ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_map:
.. rst-class:: classref-method
|void| **region_set_map**\ (\ region\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_map>`
Establece el mapa para la región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_navigation_layers:
.. rst-class:: classref-method
|void| **region_set_navigation_layers**\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_navigation_layers>`
Establece las capas de navegación de la región. Esto permite seleccionar regiones de una solicitud de ruta (cuando se usa :ref:`map_get_path()<class_NavigationServer2D_method_map_get_path>`).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_navigation_polygon:
.. rst-class:: classref-method
|void| **region_set_navigation_polygon**\ (\ region\: :ref:`RID<class_RID>`, navigation_polygon\: :ref:`NavigationPolygon<class_NavigationPolygon>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_navigation_polygon>`
Establece el ``navigation_polygon`` para la región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_owner_id:
.. rst-class:: classref-method
|void| **region_set_owner_id**\ (\ region\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_owner_id>`
Establece el ``ObjectID`` del objeto que gestiona esta región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_transform:
.. rst-class:: classref-method
|void| **region_set_transform**\ (\ region\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_transform>`
Establece la transformación global para la región.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_travel_cost:
.. rst-class:: classref-method
|void| **region_set_travel_cost**\ (\ region\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_travel_cost>`
Establece el ``travel_cost`` para esta ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_use_async_iterations:
.. rst-class:: classref-method
|void| **region_set_use_async_iterations**\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_use_async_iterations>`
Si ``enabled`` es ``true``, la ``region`` utiliza un proceso de sincronización asíncrono que se ejecuta en un hilo secundario.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_region_set_use_edge_connections:
.. rst-class:: classref-method
|void| **region_set_use_edge_connections**\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_region_set_use_edge_connections>`
Si ``enabled`` es ``true``, la ``region`` de navegación utilizará conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_set_active:
.. rst-class:: classref-method
|void| **set_active**\ (\ active\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_set_active>`
Controlar la activación de este servidor.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_set_debug_enabled:
.. rst-class:: classref-method
|void| **set_debug_enabled**\ (\ enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer2D_method_set_debug_enabled>`
Si es ``true``, habilita el modo de depuración en NavigationServer.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_simplify_path:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **simplify_path**\ (\ path\: :ref:`PackedVector2Array<class_PackedVector2Array>`, epsilon\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer2D_method_simplify_path>`
Devuelve una versión simplificada de ``path`` con menos puntos de ruta críticos eliminados. La cantidad de simplificación está en unidades del mundo y está controlada por ``epsilon``. La simplificación utiliza una variante del algoritmo de Ramer-Douglas-Peucker para la decimación de puntos de curva.
La simplificación de la ruta puede ser útil para mitigar varios problemas de seguimiento de la ruta que pueden surgir con ciertos tipos de agentes y comportamientos de script. P.ej. agentes de "dirección" o evitación en "campos abiertos".
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_source_geometry_parser_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **source_geometry_parser_create**\ (\ ) :ref:`🔗<class_NavigationServer2D_method_source_geometry_parser_create>`
Crea un nuevo analizador de geometría de origen. Si se establece un :ref:`Callable<class_Callable>` para el analizador con :ref:`source_geometry_parser_set_callback()<class_NavigationServer2D_method_source_geometry_parser_set_callback>`, se llamará al callback para cada nodo que se analice siempre que se utilice :ref:`parse_source_geometry_data()<class_NavigationServer2D_method_parse_source_geometry_data>`.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer2D_method_source_geometry_parser_set_callback:
.. rst-class:: classref-method
|void| **source_geometry_parser_set_callback**\ (\ parser\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_NavigationServer2D_method_source_geometry_parser_set_callback>`
Establece la ``callback`` :ref:`Callable<class_Callable>` para la geometría de origen específica ``parser``. El :ref:`Callable<class_Callable>` recibirá una llamada con los siguientes parámetros:
- ``navigation_mesh`` - La referencia :ref:`NavigationPolygon<class_NavigationPolygon>` utilizada para definir la configuración de análisis. NO edite ni agregue directamente a la malla de navegación.
- ``source_geometry_data`` - La referencia :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`. Agregue geometría de origen personalizada para el procesado de la malla de navegación a este objeto.
- ``node`` - El :ref:`Node<class_Node>` que se analiza.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink