mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
1121 lines
84 KiB
ReStructuredText
1121 lines
84 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. meta::
|
|
:keywords: gridmap
|
|
|
|
.. _class_TileMap:
|
|
|
|
TileMap
|
|
=======
|
|
|
|
**Obsoleto:** Use multiple :ref:`TileMapLayer<class_TileMapLayer>` nodes instead. To convert a TileMap to a set of TileMapLayer nodes, open the TileMap bottom panel with the node selected, click the toolbox icon in the top-right corner and choose 'Extract TileMap layers as individual TileMapLayer nodes'.
|
|
|
|
**Hereda:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
|
|
|
|
Nodo para mapas basados en tiles 2D.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Nodo para mapas 2D basados en tiles. Los Tilemaps usan un :ref:`TileSet<class_TileSet>` que contiene una lista de tiles que se utilizan para crear mapas basados en cuadrículas. Un TileMap puede tener varias capas, colocando tiles uno encima del otro.
|
|
|
|
Por razones de rendimiento, todas las actualizaciones de TileMap se procesan por lotes al final de un fotograma. Notablemente, esto significa que los tiles de escena de un :ref:`TileSetScenesCollectionSource<class_TileSetScenesCollectionSource>` pueden inicializarse después de su padre. Esto solo se pone en cola cuando está dentro del árbol de la escena.
|
|
|
|
Para forzar una actualización antes, llama a :ref:`update_internals()<class_TileMap_method_update_internals>`.
|
|
|
|
\ **Nota:** Por razones de rendimiento y compatibilidad, las coordenadas serializadas por **TileMap** están limitadas a enteros con signo de 16 bits, es decir, el rango para las coordenadas X e Y es de ``-32768`` a ``32767``. Al guardar los datos del tile, los tiles fuera de este rango se ajustan.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutoriales
|
|
--------------------
|
|
|
|
- :doc:`Usando TileMaps <../tutorials/2d/using_tilemaps>`
|
|
|
|
- `Demo de Plataformas en 2D <https://godotengine.org/asset-library/asset/2727>`__
|
|
|
|
- `Demo Isométrica en 2D <https://godotengine.org/asset-library/asset/2718>`__
|
|
|
|
- `Demo Hexagonal en 2D <https://godotengine.org/asset-library/asset/2717>`__
|
|
|
|
- `Demo de navegación 2D basada en cuadrícula con AStarGrid2D <https://godotengine.org/asset-library/asset/2723>`__
|
|
|
|
- `2D Role Playing Game (RPG) Demo <https://godotengine.org/asset-library/asset/2729>`__
|
|
|
|
- `Demo de Personaje Cinemático en 2D <https://godotengine.org/asset-library/asset/2719>`__
|
|
|
|
- `Demo de capas dinámicas de TileMap 2D <https://godotengine.org/asset-library/asset/2713>`__
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Propiedades
|
|
----------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+----------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`bool<class_bool>` | :ref:`collision_animatable<class_TileMap_property_collision_animatable>` | ``false`` |
|
|
+----------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`VisibilityMode<enum_TileMap_VisibilityMode>` | :ref:`collision_visibility_mode<class_TileMap_property_collision_visibility_mode>` | ``0`` |
|
|
+----------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`VisibilityMode<enum_TileMap_VisibilityMode>` | :ref:`navigation_visibility_mode<class_TileMap_property_navigation_visibility_mode>` | ``0`` |
|
|
+----------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`int<class_int>` | :ref:`rendering_quadrant_size<class_TileMap_property_rendering_quadrant_size>` | ``16`` |
|
|
+----------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
| :ref:`TileSet<class_TileSet>` | :ref:`tile_set<class_TileMap_property_tile_set>` | |
|
|
+----------------------------------------------------+--------------------------------------------------------------------------------------+-----------+
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Métodos
|
|
--------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`_tile_data_runtime_update<class_TileMap_private_method__tile_data_runtime_update>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, tile_data\: :ref:`TileData<class_TileData>`\ ) |virtual| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`_use_tile_data_runtime_update<class_TileMap_private_method__use_tile_data_runtime_update>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`\ ) |virtual| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`add_layer<class_TileMap_method_add_layer>`\ (\ to_position\: :ref:`int<class_int>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`clear<class_TileMap_method_clear>`\ (\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`clear_layer<class_TileMap_method_clear_layer>`\ (\ layer\: :ref:`int<class_int>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`erase_cell<class_TileMap_method_erase_cell>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`fix_invalid_tiles<class_TileMap_method_fix_invalid_tiles>`\ (\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`force_update<class_TileMap_method_force_update>`\ (\ layer\: :ref:`int<class_int>` = -1\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_cell_alternative_tile<class_TileMap_method_get_cell_alternative_tile>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2i<class_Vector2i>` | :ref:`get_cell_atlas_coords<class_TileMap_method_get_cell_atlas_coords>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_cell_source_id<class_TileMap_method_get_cell_source_id>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`TileData<class_TileData>` | :ref:`get_cell_tile_data<class_TileMap_method_get_cell_tile_data>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2i<class_Vector2i>` | :ref:`get_coords_for_body_rid<class_TileMap_method_get_coords_for_body_rid>`\ (\ body\: :ref:`RID<class_RID>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_layer_for_body_rid<class_TileMap_method_get_layer_for_body_rid>`\ (\ body\: :ref:`RID<class_RID>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Color<class_Color>` | :ref:`get_layer_modulate<class_TileMap_method_get_layer_modulate>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`get_layer_name<class_TileMap_method_get_layer_name>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`RID<class_RID>` | :ref:`get_layer_navigation_map<class_TileMap_method_get_layer_navigation_map>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_layer_y_sort_origin<class_TileMap_method_get_layer_y_sort_origin>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_layer_z_index<class_TileMap_method_get_layer_z_index>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`get_layers_count<class_TileMap_method_get_layers_count>`\ (\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`RID<class_RID>` | :ref:`get_navigation_map<class_TileMap_method_get_navigation_map>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2i<class_Vector2i>` | :ref:`get_neighbor_cell<class_TileMap_method_get_neighbor_cell>`\ (\ coords\: :ref:`Vector2i<class_Vector2i>`, neighbor\: :ref:`CellNeighbor<enum_TileSet_CellNeighbor>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`TileMapPattern<class_TileMapPattern>` | :ref:`get_pattern<class_TileMap_method_get_pattern>`\ (\ layer\: :ref:`int<class_int>`, coords_array\: :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\]\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] | :ref:`get_surrounding_cells<class_TileMap_method_get_surrounding_cells>`\ (\ coords\: :ref:`Vector2i<class_Vector2i>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] | :ref:`get_used_cells<class_TileMap_method_get_used_cells>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] | :ref:`get_used_cells_by_id<class_TileMap_method_get_used_cells_by_id>`\ (\ layer\: :ref:`int<class_int>`, source_id\: :ref:`int<class_int>` = -1, atlas_coords\: :ref:`Vector2i<class_Vector2i>` = Vector2i(-1, -1), alternative_tile\: :ref:`int<class_int>` = -1\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Rect2i<class_Rect2i>` | :ref:`get_used_rect<class_TileMap_method_get_used_rect>`\ (\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_cell_flipped_h<class_TileMap_method_is_cell_flipped_h>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_cell_flipped_v<class_TileMap_method_is_cell_flipped_v>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_cell_transposed<class_TileMap_method_is_cell_transposed>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_layer_enabled<class_TileMap_method_is_layer_enabled>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_layer_navigation_enabled<class_TileMap_method_is_layer_navigation_enabled>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_layer_y_sort_enabled<class_TileMap_method_is_layer_y_sort_enabled>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2i<class_Vector2i>` | :ref:`local_to_map<class_TileMap_method_local_to_map>`\ (\ local_position\: :ref:`Vector2<class_Vector2>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2i<class_Vector2i>` | :ref:`map_pattern<class_TileMap_method_map_pattern>`\ (\ position_in_tilemap\: :ref:`Vector2i<class_Vector2i>`, coords_in_pattern\: :ref:`Vector2i<class_Vector2i>`, pattern\: :ref:`TileMapPattern<class_TileMapPattern>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`map_to_local<class_TileMap_method_map_to_local>`\ (\ map_position\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`move_layer<class_TileMap_method_move_layer>`\ (\ layer\: :ref:`int<class_int>`, to_position\: :ref:`int<class_int>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`notify_runtime_tile_data_update<class_TileMap_method_notify_runtime_tile_data_update>`\ (\ layer\: :ref:`int<class_int>` = -1\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`remove_layer<class_TileMap_method_remove_layer>`\ (\ layer\: :ref:`int<class_int>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_cell<class_TileMap_method_set_cell>`\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, source_id\: :ref:`int<class_int>` = -1, atlas_coords\: :ref:`Vector2i<class_Vector2i>` = Vector2i(-1, -1), alternative_tile\: :ref:`int<class_int>` = 0\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_cells_terrain_connect<class_TileMap_method_set_cells_terrain_connect>`\ (\ layer\: :ref:`int<class_int>`, cells\: :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\], terrain_set\: :ref:`int<class_int>`, terrain\: :ref:`int<class_int>`, ignore_empty_terrains\: :ref:`bool<class_bool>` = true\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_cells_terrain_path<class_TileMap_method_set_cells_terrain_path>`\ (\ layer\: :ref:`int<class_int>`, path\: :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\], terrain_set\: :ref:`int<class_int>`, terrain\: :ref:`int<class_int>`, ignore_empty_terrains\: :ref:`bool<class_bool>` = true\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_enabled<class_TileMap_method_set_layer_enabled>`\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_modulate<class_TileMap_method_set_layer_modulate>`\ (\ layer\: :ref:`int<class_int>`, modulate\: :ref:`Color<class_Color>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_name<class_TileMap_method_set_layer_name>`\ (\ layer\: :ref:`int<class_int>`, name\: :ref:`String<class_String>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_navigation_enabled<class_TileMap_method_set_layer_navigation_enabled>`\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_navigation_map<class_TileMap_method_set_layer_navigation_map>`\ (\ layer\: :ref:`int<class_int>`, map\: :ref:`RID<class_RID>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_y_sort_enabled<class_TileMap_method_set_layer_y_sort_enabled>`\ (\ layer\: :ref:`int<class_int>`, y_sort_enabled\: :ref:`bool<class_bool>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_y_sort_origin<class_TileMap_method_set_layer_y_sort_origin>`\ (\ layer\: :ref:`int<class_int>`, y_sort_origin\: :ref:`int<class_int>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_layer_z_index<class_TileMap_method_set_layer_z_index>`\ (\ layer\: :ref:`int<class_int>`, z_index\: :ref:`int<class_int>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_navigation_map<class_TileMap_method_set_navigation_map>`\ (\ layer\: :ref:`int<class_int>`, map\: :ref:`RID<class_RID>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`set_pattern<class_TileMap_method_set_pattern>`\ (\ layer\: :ref:`int<class_int>`, position\: :ref:`Vector2i<class_Vector2i>`, pattern\: :ref:`TileMapPattern<class_TileMapPattern>`\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`update_internals<class_TileMap_method_update_internals>`\ (\ ) |
|
|
+--------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Señales
|
|
--------------
|
|
|
|
.. _class_TileMap_signal_changed:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**changed**\ (\ ) :ref:`🔗<class_TileMap_signal_changed>`
|
|
|
|
Emitida cuando el :ref:`TileSet<class_TileSet>` de este TileMap cambia.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Enumeraciones
|
|
--------------------------
|
|
|
|
.. _enum_TileMap_VisibilityMode:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **VisibilityMode**: :ref:`🔗<enum_TileMap_VisibilityMode>`
|
|
|
|
.. _class_TileMap_constant_VISIBILITY_MODE_DEFAULT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **VISIBILITY_MODE_DEFAULT** = ``0``
|
|
|
|
Usa la configuración de depuración para determinar la visibilidad.
|
|
|
|
.. _class_TileMap_constant_VISIBILITY_MODE_FORCE_HIDE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **VISIBILITY_MODE_FORCE_HIDE** = ``2``
|
|
|
|
Siempre ocultar.
|
|
|
|
.. _class_TileMap_constant_VISIBILITY_MODE_FORCE_SHOW:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **VISIBILITY_MODE_FORCE_SHOW** = ``1``
|
|
|
|
Siempre mostrar.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Propiedades
|
|
--------------------------------------------------------
|
|
|
|
.. _class_TileMap_property_collision_animatable:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **collision_animatable** = ``false`` :ref:`🔗<class_TileMap_property_collision_animatable>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_collision_animatable**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_collision_animatable**\ (\ )
|
|
|
|
Si está habilitado, el TileMap verá sus colisiones sincronizadas con el tick de la física y cambiará su tipo de colisión de estático a cinemático. Esto es necesario para crear plataformas móviles basadas en TileMap.
|
|
|
|
\ **Nota:** Habilitar :ref:`collision_animatable<class_TileMap_property_collision_animatable>` puede tener un pequeño impacto en el rendimiento, solo hazlo si el TileMap se está moviendo y tiene tiles que colisionan.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_property_collision_visibility_mode:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **collision_visibility_mode** = ``0`` :ref:`🔗<class_TileMap_property_collision_visibility_mode>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_collision_visibility_mode**\ (\ value\: :ref:`VisibilityMode<enum_TileMap_VisibilityMode>`\ )
|
|
- :ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **get_collision_visibility_mode**\ (\ )
|
|
|
|
Muestra u oculta las formas de colisión del TileMap. Si se establece en :ref:`VISIBILITY_MODE_DEFAULT<class_TileMap_constant_VISIBILITY_MODE_DEFAULT>`, esto depende de la configuración de depuración de visualización de colisiones.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_property_navigation_visibility_mode:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **navigation_visibility_mode** = ``0`` :ref:`🔗<class_TileMap_property_navigation_visibility_mode>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_navigation_visibility_mode**\ (\ value\: :ref:`VisibilityMode<enum_TileMap_VisibilityMode>`\ )
|
|
- :ref:`VisibilityMode<enum_TileMap_VisibilityMode>` **get_navigation_visibility_mode**\ (\ )
|
|
|
|
Muestra u oculta las mallas de navegación del TileMap. Si se establece en :ref:`VISIBILITY_MODE_DEFAULT<class_TileMap_constant_VISIBILITY_MODE_DEFAULT>`, esto depende de la configuración de depuración de visualización de navegación.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_property_rendering_quadrant_size:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`int<class_int>` **rendering_quadrant_size** = ``16`` :ref:`🔗<class_TileMap_property_rendering_quadrant_size>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_rendering_quadrant_size**\ (\ value\: :ref:`int<class_int>`\ )
|
|
- :ref:`int<class_int>` **get_rendering_quadrant_size**\ (\ )
|
|
|
|
El tamaño del cuadrante del TileMap. Un cuadrante es un grupo de tiles que se dibujan juntos en un solo elemento de lienzo, con fines de optimización. :ref:`rendering_quadrant_size<class_TileMap_property_rendering_quadrant_size>` define la longitud del lado de un cuadrado, en el sistema de coordenadas del mapa, que forma el cuadrante. Por lo tanto, el tamaño de cuadrante predeterminado agrupa ``16 * 16 = 256`` tiles.
|
|
|
|
El tamaño del cuadrante no se aplica en las capas ordenadas en Y, ya que los tiles se agrupan por posición Y en ese caso.
|
|
|
|
\ **Nota:** Como los cuadrantes se crean de acuerdo con el sistema de coordenadas del mapa, la "forma cuadrada" del cuadrante podría no parecerse a un cuadrado en el sistema de coordenadas local del TileMap.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_property_tile_set:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`TileSet<class_TileSet>` **tile_set** :ref:`🔗<class_TileMap_property_tile_set>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_tileset**\ (\ value\: :ref:`TileSet<class_TileSet>`\ )
|
|
- :ref:`TileSet<class_TileSet>` **get_tileset**\ (\ )
|
|
|
|
El :ref:`TileSet<class_TileSet>` utilizado por este **TileMap**. Las texturas, colisiones y el comportamiento adicional de todos los tiles disponibles se almacenan aquí.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_TileMap_private_method__tile_data_runtime_update:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **_tile_data_runtime_update**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, tile_data\: :ref:`TileData<class_TileData>`\ ) |virtual| :ref:`🔗<class_TileMap_private_method__tile_data_runtime_update>`
|
|
|
|
Se llama con un objeto TileData que está a punto de ser utilizado internamente por el TileMap, lo que permite su modificación en tiempo de ejecución.
|
|
|
|
Este método solo se llama si :ref:`_use_tile_data_runtime_update()<class_TileMap_private_method__use_tile_data_runtime_update>` está implementado y devuelve ``true`` para el tile dado ``coords`` y ``layer``.
|
|
|
|
\ **Advertencia:** Los subrecursos del objeto ``tile_data`` son los mismos que los del TileSet. Modificarlos podría afectar a todo el TileSet. En su lugar, asegúrate de duplicar esos recursos.
|
|
|
|
\ **Nota:** Si las propiedades del objeto ``tile_data`` deben cambiar con el tiempo, utiliza :ref:`notify_runtime_tile_data_update()<class_TileMap_method_notify_runtime_tile_data_update>` para notificar al TileMap que necesita una actualización.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_private_method__use_tile_data_runtime_update:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **_use_tile_data_runtime_update**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`\ ) |virtual| :ref:`🔗<class_TileMap_private_method__use_tile_data_runtime_update>`
|
|
|
|
Debería devolver ``true`` si el tile en las coordenadas ``coords`` en la capa ``layer`` requiere una actualización en tiempo de ejecución.
|
|
|
|
\ **Advertencia:** Asegúrate de que esta función solo devuelva ``true`` cuando sea necesario. Cualquier tile procesado en tiempo de ejecución sin necesidad de ello implicará una penalización significativa en el rendimiento.
|
|
|
|
\ **Nota:** Si el resultado de esta función debe cambiar, utiliza :ref:`notify_runtime_tile_data_update()<class_TileMap_method_notify_runtime_tile_data_update>` para notificar al TileMap que necesita una actualización.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_add_layer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **add_layer**\ (\ to_position\: :ref:`int<class_int>`\ ) :ref:`🔗<class_TileMap_method_add_layer>`
|
|
|
|
Añade una capa en la posición dada ``to_position`` en el array. Si ``to_position`` es negativo, la posición se cuenta desde el final, con ``-1`` añadiendo la capa al final del array.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_clear:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **clear**\ (\ ) :ref:`🔗<class_TileMap_method_clear>`
|
|
|
|
Limpia todas las celdas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_clear_layer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **clear_layer**\ (\ layer\: :ref:`int<class_int>`\ ) :ref:`🔗<class_TileMap_method_clear_layer>`
|
|
|
|
Limpia todas las celdas en la capa dada.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_erase_cell:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **erase_cell**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_TileMap_method_erase_cell>`
|
|
|
|
Borra la celda en la capa ``layer`` en las coordenadas ``coords``.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_fix_invalid_tiles:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **fix_invalid_tiles**\ (\ ) :ref:`🔗<class_TileMap_method_fix_invalid_tiles>`
|
|
|
|
Despeja las celdas que no existen en el tileset.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_force_update:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **force_update**\ (\ layer\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_TileMap_method_force_update>`
|
|
|
|
**Obsoleto:** Use :ref:`notify_runtime_tile_data_update()<class_TileMap_method_notify_runtime_tile_data_update>` and/or :ref:`update_internals()<class_TileMap_method_update_internals>` instead.
|
|
|
|
Fuerza la actualización del TileMap y la capa ``layer``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_cell_alternative_tile:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_cell_alternative_tile**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_get_cell_alternative_tile>`
|
|
|
|
Devuelve el ID alternativo del tile de la celda en la capa ``layer`` en ``coords``.
|
|
|
|
Si ``use_proxies`` es ``false``, ignora los proxies del tile del :ref:`TileSet<class_TileSet>`, devolviendo el identificador alternativo sin procesar. Véase :ref:`TileSet.map_tile_proxy()<class_TileSet_method_map_tile_proxy>`.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_cell_atlas_coords:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2i<class_Vector2i>` **get_cell_atlas_coords**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_get_cell_atlas_coords>`
|
|
|
|
Devuelve el ID de las coordenadas del atlas de tiles de la celda en la capa ``layer`` en las coordenadas ``coords``. Devuelve ``Vector2i(-1, -1)`` si la celda no existe.
|
|
|
|
Si ``use_proxies`` es ``false``, ignora los proxies del tile del :ref:`TileSet<class_TileSet>`, devolviendo el identificador de coordenadas del atlas sin procesar. Véase :ref:`TileSet.map_tile_proxy()<class_TileSet_method_map_tile_proxy>`.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_cell_source_id:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_cell_source_id**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_get_cell_source_id>`
|
|
|
|
Devuelve el ID de la fuente del tile de la celda en la capa ``layer`` en las coordenadas ``coords``. Devuelve ``-1`` si la celda no existe.
|
|
|
|
Si ``use_proxies`` es ``false``, ignora los proxies del tile del :ref:`TileSet<class_TileSet>`, devolviendo el identificador de la fuente sin procesar. Véase :ref:`TileSet.map_tile_proxy()<class_TileSet_method_map_tile_proxy>`.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_cell_tile_data:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`TileData<class_TileData>` **get_cell_tile_data**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_get_cell_tile_data>`
|
|
|
|
Devuelve el objeto :ref:`TileData<class_TileData>` asociado con la celda dada, o ``null`` si la celda no existe o no es una :ref:`TileSetAtlasSource<class_TileSetAtlasSource>`.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
::
|
|
|
|
func get_clicked_tile_power():
|
|
var celda_pulsada = tile_map.local_to_map(tile_map.get_local_mouse_position())
|
|
var datos = tile_map.get_cell_tile_data(0, celda_pulsada)
|
|
if datos:
|
|
return datos.get_custom_data("power")
|
|
else:
|
|
return 0
|
|
|
|
Si ``use_proxies`` es ``false``, ignora los proxies del tile del :ref:`TileSet<class_TileSet>`. Véase :ref:`TileSet.map_tile_proxy()<class_TileSet_method_map_tile_proxy>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_coords_for_body_rid:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2i<class_Vector2i>` **get_coords_for_body_rid**\ (\ body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_TileMap_method_get_coords_for_body_rid>`
|
|
|
|
Devuelve las coordenadas del tile para el RID del cuerpo físico dado. Dicho RID se puede obtener de :ref:`KinematicCollision2D.get_collider_rid()<class_KinematicCollision2D_method_get_collider_rid>`, al colisionar con un tile.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layer_for_body_rid:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_layer_for_body_rid**\ (\ body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_TileMap_method_get_layer_for_body_rid>`
|
|
|
|
Devuelve la capa del tilemap del tile para el RID del cuerpo físico dado. Dicho RID se puede obtener de :ref:`KinematicCollision2D.get_collider_rid()<class_KinematicCollision2D_method_get_collider_rid>`, al colisionar con un tile.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layer_modulate:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Color<class_Color>` **get_layer_modulate**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_layer_modulate>`
|
|
|
|
Devuelve el modulate de una capa del TileMap.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layer_name:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`String<class_String>` **get_layer_name**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_layer_name>`
|
|
|
|
Devuelve el nombre de una capa del TileMap.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layer_navigation_map:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`RID<class_RID>` **get_layer_navigation_map**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_layer_navigation_map>`
|
|
|
|
Devuelve el :ref:`RID<class_RID>` del mapa de navegación :ref:`NavigationServer2D<class_NavigationServer2D>` asignado a la capa ``layer`` del TileMap especificado.
|
|
|
|
Por defecto, el TileMap utiliza el mapa de navegación :ref:`World2D<class_World2D>` por defecto para la primera capa del TileMap. Para cada capa adicional del TileMap, se crea un nuevo mapa de navegación para la capa adicional.
|
|
|
|
Para hacer que :ref:`NavigationAgent2D<class_NavigationAgent2D>` cambie entre los mapas de navegación de las capas del TileMap, utiliza :ref:`NavigationAgent2D.set_navigation_map()<class_NavigationAgent2D_method_set_navigation_map>` con el mapa de navegación recibido de :ref:`get_layer_navigation_map()<class_TileMap_method_get_layer_navigation_map>`.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layer_y_sort_origin:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_layer_y_sort_origin**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_layer_y_sort_origin>`
|
|
|
|
Devuelve el origen de ordenamiento Y de una capa del TileMap.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layer_z_index:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_layer_z_index**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_layer_z_index>`
|
|
|
|
Devuelve el valor del índice Z de una capa del TileMap.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_layers_count:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`int<class_int>` **get_layers_count**\ (\ ) |const| :ref:`🔗<class_TileMap_method_get_layers_count>`
|
|
|
|
Devuelve el número de capas en el TileMap.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_navigation_map:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`RID<class_RID>` **get_navigation_map**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_navigation_map>`
|
|
|
|
**Obsoleto:** Use :ref:`get_layer_navigation_map()<class_TileMap_method_get_layer_navigation_map>` instead.
|
|
|
|
Devuelve el :ref:`RID<class_RID>` del mapa de navegación :ref:`NavigationServer2D<class_NavigationServer2D>` asignado a la capa ``layer`` del TileMap especificado.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_neighbor_cell:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2i<class_Vector2i>` **get_neighbor_cell**\ (\ coords\: :ref:`Vector2i<class_Vector2i>`, neighbor\: :ref:`CellNeighbor<enum_TileSet_CellNeighbor>`\ ) |const| :ref:`🔗<class_TileMap_method_get_neighbor_cell>`
|
|
|
|
Devuelve la celda vecina a la que se encuentra en las coordenadas ``coords``, identificada por la dirección ``neighbor``. Este método tiene en cuenta los diferentes diseños que puede tener un TileMap.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_pattern:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`TileMapPattern<class_TileMapPattern>` **get_pattern**\ (\ layer\: :ref:`int<class_int>`, coords_array\: :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\]\ ) :ref:`🔗<class_TileMap_method_get_pattern>`
|
|
|
|
Crea un nuevo :ref:`TileMapPattern<class_TileMapPattern>` a partir de la capa y el conjunto de celdas indicados.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_surrounding_cells:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] **get_surrounding_cells**\ (\ coords\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_TileMap_method_get_surrounding_cells>`
|
|
|
|
Devuelve la lista de todas las celdas vecinas a la que se encuentra en ``coords``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_used_cells:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] **get_used_cells**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_get_used_cells>`
|
|
|
|
Devuelve un array :ref:`Vector2i<class_Vector2i>` con las posiciones de todas las celdas que contienen un tile en la capa dada. Se considera que una celda está vacía si su identificador de fuente es igual a -1, sus identificadores de coordenadas del atlas son ``Vector2(-1, -1)`` y su identificador alternativo es -1.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_used_cells_by_id:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] **get_used_cells_by_id**\ (\ layer\: :ref:`int<class_int>`, source_id\: :ref:`int<class_int>` = -1, atlas_coords\: :ref:`Vector2i<class_Vector2i>` = Vector2i(-1, -1), alternative_tile\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_TileMap_method_get_used_cells_by_id>`
|
|
|
|
Devuelve un array de :ref:`Vector2i<class_Vector2i>` con las posiciones de todas las celdas que contienen un tile en la capa dada. Los tiles pueden filtrarse según su fuente (``source_id``), sus coordenadas de atlas (``atlas_coords``) o su ID alternativo (``alternative_tile``).
|
|
|
|
Si un parámetro tiene su valor establecido en el valor predeterminado, este parámetro no se utiliza para filtrar una celda. Por lo tanto, si todos los parámetros tienen su respectivo valor predeterminado, este método devuelve el mismo resultado que :ref:`get_used_cells()<class_TileMap_method_get_used_cells>`.
|
|
|
|
Se considera que una celda está vacía si su identificador de fuente es igual a -1, su identificador de coordenadas de atlas es ``Vector2(-1, -1)`` y su identificador alternativo es -1.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_get_used_rect:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Rect2i<class_Rect2i>` **get_used_rect**\ (\ ) |const| :ref:`🔗<class_TileMap_method_get_used_rect>`
|
|
|
|
Devuelve un rectángulo que encierra los tiles usados (no vacíos) del mapa, incluyendo todas las capas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_is_cell_flipped_h:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_cell_flipped_h**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_is_cell_flipped_h>`
|
|
|
|
Devuelve ``true`` si la celda en la capa ``layer`` en las coordenadas ``coords`` se invierte horizontalmente. El resultado solo es válido para fuentes de atlas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_is_cell_flipped_v:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_cell_flipped_v**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_is_cell_flipped_v>`
|
|
|
|
Devuelve ``true`` si la celda en la capa ``layer`` en las coordenadas ``coords`` se invierte verticalmente. El resultado solo es válido para fuentes de atlas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_is_cell_transposed:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_cell_transposed**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, use_proxies\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_TileMap_method_is_cell_transposed>`
|
|
|
|
Devuelve ``true`` si la celda en la capa ``layer`` en las coordenadas ``coords`` está transpuesta. El resultado solo es válido para fuentes de atlas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_is_layer_enabled:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_layer_enabled**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_is_layer_enabled>`
|
|
|
|
Devuelve si una capa está habilitada.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_is_layer_navigation_enabled:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_layer_navigation_enabled**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_is_layer_navigation_enabled>`
|
|
|
|
Devuelve si la generación de regiones de navegación incorporada de una capa está habilitada.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_is_layer_y_sort_enabled:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_layer_y_sort_enabled**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_TileMap_method_is_layer_y_sort_enabled>`
|
|
|
|
Devuelve si una capa ordena sus tiles en el eje Y.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_local_to_map:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2i<class_Vector2i>` **local_to_map**\ (\ local_position\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_TileMap_method_local_to_map>`
|
|
|
|
Devuelve las coordenadas del mapa de la celda que contiene la ``local_position`` dada. Si ``local_position`` está en coordenadas globales, considera usar :ref:`Node2D.to_local()<class_Node2D_method_to_local>` antes de pasarla a este método. Véase también :ref:`map_to_local()<class_TileMap_method_map_to_local>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_map_pattern:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2i<class_Vector2i>` **map_pattern**\ (\ position_in_tilemap\: :ref:`Vector2i<class_Vector2i>`, coords_in_pattern\: :ref:`Vector2i<class_Vector2i>`, pattern\: :ref:`TileMapPattern<class_TileMapPattern>`\ ) :ref:`🔗<class_TileMap_method_map_pattern>`
|
|
|
|
Devuelve para la coordenada dada ``coords_in_pattern`` en un :ref:`TileMapPattern<class_TileMapPattern>` las coordenadas de celda correspondientes si el patrón se pegó en las coordenadas ``position_in_tilemap`` (ver :ref:`set_pattern()<class_TileMap_method_set_pattern>`). Esta asignación es necesaria ya que en las formas de tile de medio desplazamiento, la asignación podría no funcionar calculando ``position_in_tile_map + coords_in_pattern``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_map_to_local:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2<class_Vector2>` **map_to_local**\ (\ map_position\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_TileMap_method_map_to_local>`
|
|
|
|
Devuelve la posición centrada de una celda en el espacio de coordenadas local del TileMap. Para convertir el valor devuelto en coordenadas globales, usa :ref:`Node2D.to_global()<class_Node2D_method_to_global>`. Véase también :ref:`local_to_map()<class_TileMap_method_local_to_map>`.
|
|
|
|
\ **Nota:** Esto puede no corresponder a la posición visual del tile, es decir, ignora la propiedad :ref:`TileData.texture_origin<class_TileData_property_texture_origin>` de los tiles individuales.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_move_layer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **move_layer**\ (\ layer\: :ref:`int<class_int>`, to_position\: :ref:`int<class_int>`\ ) :ref:`🔗<class_TileMap_method_move_layer>`
|
|
|
|
Mueve la capa en el índice ``layer`` a la posición dada ``to_position`` en el array.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_notify_runtime_tile_data_update:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **notify_runtime_tile_data_update**\ (\ layer\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_TileMap_method_notify_runtime_tile_data_update>`
|
|
|
|
Notifica al nodo TileMap que las llamadas a :ref:`_use_tile_data_runtime_update()<class_TileMap_private_method__use_tile_data_runtime_update>` o :ref:`_tile_data_runtime_update()<class_TileMap_private_method__tile_data_runtime_update>` conducirán a resultados diferentes. Esto, por lo tanto, activará una actualización de TileMap.
|
|
|
|
Si se proporciona ``layer``, solo notifica los cambios para la capa dada. Proporcionar el argumento ``layer`` (cuando corresponda) suele ser preferible por razones de rendimiento.
|
|
|
|
\ **Advertencia:** La actualización del TileMap es computacionalmente costosa y puede afectar el rendimiento. Intenta limitar el número de llamadas a esta función para evitar actualizaciones innecesarias.
|
|
|
|
\ **Nota:** Esto no activa una actualización directa del TileMap, la actualización se realizará al final del fotograma como de costumbre (a menos que llames a :ref:`update_internals()<class_TileMap_method_update_internals>`).
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_remove_layer:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **remove_layer**\ (\ layer\: :ref:`int<class_int>`\ ) :ref:`🔗<class_TileMap_method_remove_layer>`
|
|
|
|
Elimina la capa en el índice ``layer``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_cell:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_cell**\ (\ layer\: :ref:`int<class_int>`, coords\: :ref:`Vector2i<class_Vector2i>`, source_id\: :ref:`int<class_int>` = -1, atlas_coords\: :ref:`Vector2i<class_Vector2i>` = Vector2i(-1, -1), alternative_tile\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_TileMap_method_set_cell>`
|
|
|
|
Establece los identificadores de tile para la celda en la capa ``layer`` en las coordenadas ``coords``. Cada tile del :ref:`TileSet<class_TileSet>` se identifica mediante tres partes:
|
|
|
|
- El identificador de origen ``source_id`` identifica un identificador :ref:`TileSetSource<class_TileSetSource>`. Véase :ref:`TileSet.set_source_id()<class_TileSet_method_set_source_id>`,
|
|
|
|
- El identificador de las coordenadas del atlas ``atlas_coords`` identifica las coordenadas de un tile en el atlas (si el origen es un :ref:`TileSetAtlasSource<class_TileSetAtlasSource>`). Para :ref:`TileSetScenesCollectionSource<class_TileSetScenesCollectionSource>` siempre debe ser ``Vector2i(0, 0)``,
|
|
|
|
- El identificador de tile alternativo ``alternative_tile`` identifica un tile alternativo en el atlas (si el origen es un :ref:`TileSetAtlasSource<class_TileSetAtlasSource>`), y la escena para un :ref:`TileSetScenesCollectionSource<class_TileSetScenesCollectionSource>`.
|
|
|
|
Si ``source_id`` se establece en ``-1``, ``atlas_coords`` en ``Vector2i(-1, -1)`` o ``alternative_tile`` en ``-1``, la celda se borrará. Una celda borrada obtiene **todos** sus identificadores automáticamente establecidos en sus respectivos valores no válidos, a saber, ``-1``, ``Vector2i(-1, -1)`` y ``-1``.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_cells_terrain_connect:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_cells_terrain_connect**\ (\ layer\: :ref:`int<class_int>`, cells\: :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\], terrain_set\: :ref:`int<class_int>`, terrain\: :ref:`int<class_int>`, ignore_empty_terrains\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_TileMap_method_set_cells_terrain_connect>`
|
|
|
|
Actualiza todas las celdas en el array de coordenadas ``cells`` para que utilicen el ``terrain`` dado para el ``terrain_set`` dado. Si una celda actualizada tiene el mismo terreno que una de sus celdas vecinas, esta función intenta unir las dos. Esta función podría actualizar los tiles vecinos si es necesario para crear transiciones de terreno correctas.
|
|
|
|
Si ``ignore_empty_terrains`` es ``true``, los terrenos vacíos se ignorarán al intentar encontrar el tile que mejor se adapte a las restricciones de terreno dadas.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
\ **Nota:** Para que funcione correctamente, este método requiere que el TileSet de TileMap tenga terrenos configurados con todas las combinaciones de terreno necesarias. De lo contrario, puede producir resultados inesperados.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_cells_terrain_path:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_cells_terrain_path**\ (\ layer\: :ref:`int<class_int>`, path\: :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\], terrain_set\: :ref:`int<class_int>`, terrain\: :ref:`int<class_int>`, ignore_empty_terrains\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_TileMap_method_set_cells_terrain_path>`
|
|
|
|
Actualiza todas las celdas en el array de coordenadas ``path`` para que utilicen el ``terrain`` dado para el ``terrain_set`` dado. La función también conectará dos celdas sucesivas en la ruta con el mismo terreno. Esta función podría actualizar los tiles vecinos si es necesario para crear transiciones de terreno correctas.
|
|
|
|
Si ``ignore_empty_terrains`` es ``true``, los terrenos vacíos se ignorarán al intentar encontrar el tile que mejor se adapte a las restricciones de terreno dadas.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
\ **Nota:** Para que funcione correctamente, este método requiere que el TileSet de TileMap tenga terrenos configurados con todas las combinaciones de terreno necesarias. De lo contrario, puede producir resultados inesperados.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_enabled:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_enabled**\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_TileMap_method_set_layer_enabled>`
|
|
|
|
Habilita o deshabilita la capa ``layer``. Una capa deshabilitada no se procesa en absoluto (ni renderizado, ni física, etc.).
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_modulate:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_modulate**\ (\ layer\: :ref:`int<class_int>`, modulate\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_TileMap_method_set_layer_modulate>`
|
|
|
|
Establece el color de una capa. Se multiplicará por el color del tile y el modulate del TileMap.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_name:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_name**\ (\ layer\: :ref:`int<class_int>`, name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_TileMap_method_set_layer_name>`
|
|
|
|
Establece el nombre de una capa. Esto es principalmente útil en el editor.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_navigation_enabled:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_navigation_enabled**\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_TileMap_method_set_layer_navigation_enabled>`
|
|
|
|
Habilita o deshabilita la generación de regiones de navegación incorporada de una capa. Desactiva esto si necesitas procesar regiones de navegación desde un TileMap usando un nodo :ref:`NavigationRegion2D<class_NavigationRegion2D>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_navigation_map:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_navigation_map**\ (\ layer\: :ref:`int<class_int>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_TileMap_method_set_layer_navigation_map>`
|
|
|
|
Asigna ``map`` como un mapa de navegación :ref:`NavigationServer2D<class_NavigationServer2D>` para la capa ``layer`` del TileMap especificado.
|
|
|
|
Por defecto, el TileMap utiliza el mapa de navegación :ref:`World2D<class_World2D>` por defecto para la primera capa del TileMap. Para cada capa adicional del TileMap, se crea un nuevo mapa de navegación para la capa adicional.
|
|
|
|
Para hacer que :ref:`NavigationAgent2D<class_NavigationAgent2D>` cambie entre los mapas de navegación de las capas del TileMap, utiliza :ref:`NavigationAgent2D.set_navigation_map()<class_NavigationAgent2D_method_set_navigation_map>` con el mapa de navegación recibido de :ref:`get_layer_navigation_map()<class_TileMap_method_get_layer_navigation_map>`.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_y_sort_enabled:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_y_sort_enabled**\ (\ layer\: :ref:`int<class_int>`, y_sort_enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_TileMap_method_set_layer_y_sort_enabled>`
|
|
|
|
Habilita o deshabilita el ordenamiento Y de una capa. Si una capa está ordenada en Y, la capa se comportará como un nodo CanvasItem donde cada uno de sus tiles se ordena en Y.
|
|
|
|
Las capas ordenadas en Y generalmente deben tener diferentes valores de índice Z que las capas no ordenadas en Y, de lo contrario, cada una de esas capas se ordenará en Y como un todo con la ordenada en Y. Este es generalmente un comportamiento no deseado.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_y_sort_origin:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_y_sort_origin**\ (\ layer\: :ref:`int<class_int>`, y_sort_origin\: :ref:`int<class_int>`\ ) :ref:`🔗<class_TileMap_method_set_layer_y_sort_origin>`
|
|
|
|
Establece el valor de origen de ordenamiento Y de una capa. Este valor de origen de ordenamiento Y se agrega al valor de origen de ordenamiento Y de cada tile.
|
|
|
|
Esto permite, por ejemplo, simular un nivel de altura diferente en cada capa. Esto puede ser útil para juegos con vista desde arriba.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_layer_z_index:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_layer_z_index**\ (\ layer\: :ref:`int<class_int>`, z_index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_TileMap_method_set_layer_z_index>`
|
|
|
|
Establece el valor del índice Z de una capa. Este índice Z se agrega al valor del índice Z de cada tile.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_navigation_map:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_navigation_map**\ (\ layer\: :ref:`int<class_int>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_TileMap_method_set_navigation_map>`
|
|
|
|
**Obsoleto:** Use :ref:`set_layer_navigation_map()<class_TileMap_method_set_layer_navigation_map>` instead.
|
|
|
|
Asigna ``map`` como un mapa de navegación :ref:`NavigationServer2D<class_NavigationServer2D>` para la capa ``layer`` del TileMap especificado.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_set_pattern:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **set_pattern**\ (\ layer\: :ref:`int<class_int>`, position\: :ref:`Vector2i<class_Vector2i>`, pattern\: :ref:`TileMapPattern<class_TileMapPattern>`\ ) :ref:`🔗<class_TileMap_method_set_pattern>`
|
|
|
|
Pega el :ref:`TileMapPattern<class_TileMapPattern>` dado en la ``position`` y ``layer`` dadas en el mapa de tiles.
|
|
|
|
Si ``layer`` es negativo, se accede a las capas desde la última.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_TileMap_method_update_internals:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **update_internals**\ (\ ) :ref:`🔗<class_TileMap_method_update_internals>`
|
|
|
|
Activa una actualización directa del TileMap. Por lo general, no es necesario llamar a esta función, ya que el nodo TileMap se actualiza automáticamente cuando se modifica una de sus propiedades o celdas.
|
|
|
|
Sin embargo, por razones de rendimiento, esas actualizaciones se procesan por lotes y se retrasan hasta el final del fotograma. Llamar a esta función forzará al TileMap a actualizarse de inmediato.
|
|
|
|
\ **Advertencia:** La actualización del TileMap es computacionalmente costosa y puede afectar el rendimiento. Intenta limitar el número de actualizaciones y cuántos tiles impactan.
|
|
|
|
.. |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.)`
|