typescript-to-gdscript 0.1.0

package/typings/classes/TileMap.d.ts

@@ -0,0 +1,303 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node for 2D tile-based maps. */
+declare class TileMap extends Node2D {
+  /**
+   * If enabled, the TileMap will see its collisions synced to the physics tick and change its collision type from static to kinematic. This is required to create TileMap-based moving platform.
+   * **Note:** Enabling {@link collision_animatable} may have a small performance impact, only do it if the TileMap is moving and has colliding tiles.
+   */
+  collision_animatable: boolean;
+  /**
+   * Show or hide the TileMap's collision shapes. If set to {@link VISIBILITY_MODE_DEFAULT}, this depends on the show collision debug settings.
+   */
+  collision_visibility_mode: int;
+  /**
+   * Show or hide the TileMap's navigation meshes. If set to {@link VISIBILITY_MODE_DEFAULT}, this depends on the show navigation debug settings.
+   */
+  navigation_visibility_mode: int;
+  /**
+   * The TileMap's quadrant size. A quadrant is a group of tiles to be drawn together on a single canvas item, for optimization purposes. {@link rendering_quadrant_size} defines the length of a square's side, in the map's coordinate system, that forms the quadrant. Thus, the default quadrant size groups together `16 * 16 = 256` tiles.
+   * The quadrant size does not apply on Y-sorted layers, as tiles are grouped by Y position instead in that case.
+   * **Note:** As quadrants are created according to the map's coordinate system, the quadrant's "square shape" might not look like square in the TileMap's local coordinate system.
+   */
+  rendering_quadrant_size: int;
+  /**
+   * The {@link TileSet} used by this {@link TileMap}. The textures, collisions, and additional behavior of all available tiles are stored here.
+   */
+  tile_set: TileSet | null;
+  set_collision_animatable(value: boolean): void;
+  is_collision_animatable(): boolean;
+  set_collision_visibility_mode(value: int): void;
+  get_collision_visibility_mode(): int;
+  set_navigation_visibility_mode(value: int): void;
+  get_navigation_visibility_mode(): int;
+  set_rendering_quadrant_size(value: int): void;
+  get_rendering_quadrant_size(): int;
+  set_tileset(value: TileSet | null): void;
+  get_tileset(): TileSet | null;
+
+  /**
+   * Called with a TileData object about to be used internally by the TileMap, allowing its modification at runtime.
+   * This method is only called if {@link _use_tile_data_runtime_update} is implemented and returns `true` for the given tile `coords` and `layer`.
+   * **Warning:** The `tile_data` object's sub-resources are the same as the one in the TileSet. Modifying them might impact the whole TileSet. Instead, make sure to duplicate those resources.
+   * **Note:** If the properties of `tile_data` object should change over time, use {@link notify_runtime_tile_data_update} to notify the TileMap it needs an update.
+   */
+  _tile_data_runtime_update(layer: int, coords: Vector2i | Vector2, tile_data: TileData): void;
+  /**
+   * Should return `true` if the tile at coordinates `coords` on layer `layer` requires a runtime update.
+   * **Warning:** Make sure this function only return `true` when needed. Any tile processed at runtime without a need for it will imply a significant performance penalty.
+   * **Note:** If the result of this function should changed, use {@link notify_runtime_tile_data_update} to notify the TileMap it needs an update.
+   */
+  _use_tile_data_runtime_update(layer: int, coords: Vector2i | Vector2): boolean;
+  /**
+   * Adds a layer at the given position `to_position` in the array. If `to_position` is negative, the position is counted from the end, with `-1` adding the layer at the end of the array.
+   */
+  add_layer(to_position: int): void;
+  /** Clears all cells. */
+  clear(): void;
+  /**
+   * Clears all cells on the given layer.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  clear_layer(layer: int): void;
+  /**
+   * Erases the cell on layer `layer` at coordinates `coords`.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  erase_cell(layer: int, coords: Vector2i | Vector2): void;
+  /** Clears cells that do not exist in the tileset. */
+  fix_invalid_tiles(): void;
+  /** Forces the TileMap and the layer `layer` to update. */
+  force_update(layer?: int): void;
+  /**
+   * Returns the tile alternative ID of the cell on layer `layer` at `coords`.
+   * If `use_proxies` is `false`, ignores the {@link TileSet}'s tile proxies, returning the raw alternative identifier. See {@link TileSet.map_tile_proxy}.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_cell_alternative_tile(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): int;
+  /**
+   * Returns the tile atlas coordinates ID of the cell on layer `layer` at coordinates `coords`. Returns `Vector2i(-1, -1)` if the cell does not exist.
+   * If `use_proxies` is `false`, ignores the {@link TileSet}'s tile proxies, returning the raw atlas coordinate identifier. See {@link TileSet.map_tile_proxy}.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_cell_atlas_coords(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): Vector2i;
+  /**
+   * Returns the tile source ID of the cell on layer `layer` at coordinates `coords`. Returns `-1` if the cell does not exist.
+   * If `use_proxies` is `false`, ignores the {@link TileSet}'s tile proxies, returning the raw source identifier. See {@link TileSet.map_tile_proxy}.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_cell_source_id(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): int;
+  /**
+   * Returns the {@link TileData} object associated with the given cell, or `null` if the cell does not exist or is not a {@link TileSetAtlasSource}.
+   * If `layer` is negative, the layers are accessed from the last one.
+   * If `use_proxies` is `false`, ignores the {@link TileSet}'s tile proxies. See {@link TileSet.map_tile_proxy}.
+   */
+  get_cell_tile_data(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): TileData | null;
+  /**
+   * Returns the coordinates of the tile for given physics body RID. Such RID can be retrieved from {@link KinematicCollision2D.get_collider_rid}, when colliding with a tile.
+   */
+  get_coords_for_body_rid(body: RID): Vector2i;
+  /**
+   * Returns the tilemap layer of the tile for given physics body RID. Such RID can be retrieved from {@link KinematicCollision2D.get_collider_rid}, when colliding with a tile.
+   */
+  get_layer_for_body_rid(body: RID): int;
+  /**
+   * Returns a TileMap layer's modulate.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_layer_modulate(layer: int): Color;
+  /**
+   * Returns a TileMap layer's name.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_layer_name(layer: int): string;
+  /**
+   * Returns the {@link RID} of the {@link NavigationServer2D} navigation map assigned to the specified TileMap layer `layer`.
+   * By default the TileMap uses the default {@link World2D} navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
+   * In order to make {@link NavigationAgent2D} switch between TileMap layer navigation maps use {@link NavigationAgent2D.set_navigation_map} with the navigation map received from {@link get_layer_navigation_map}.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_layer_navigation_map(layer: int): RID;
+  /**
+   * Returns a TileMap layer's Y sort origin.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_layer_y_sort_origin(layer: int): int;
+  /**
+   * Returns a TileMap layer's Z-index value.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_layer_z_index(layer: int): int;
+  /** Returns the number of layers in the TileMap. */
+  get_layers_count(): int;
+  /**
+   * Returns the {@link RID} of the {@link NavigationServer2D} navigation map assigned to the specified TileMap layer `layer`.
+   */
+  get_navigation_map(layer: int): RID;
+  /**
+   * Returns the neighboring cell to the one at coordinates `coords`, identified by the `neighbor` direction. This method takes into account the different layouts a TileMap can take.
+   */
+  get_neighbor_cell(coords: Vector2i | Vector2, neighbor: int): Vector2i;
+  /**
+   * Creates a new {@link TileMapPattern} from the given layer and set of cells.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_pattern(layer: int, coords_array: Array<Vector2i>): TileMapPattern;
+  /** Returns the list of all neighbourings cells to the one at `coords`. */
+  get_surrounding_cells(coords: Vector2i | Vector2): Array<Vector2i>;
+  /**
+   * Returns a {@link Vector2i} array with the positions of all cells containing a tile in the given layer. A cell is considered empty if its source identifier equals -1, its atlas coordinates identifiers is `Vector2(-1, -1)` and its alternative identifier is -1.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_used_cells(layer: int): Array<Vector2i>;
+  /**
+   * Returns a {@link Vector2i} array with the positions of all cells containing a tile in the given layer. Tiles may be filtered according to their source (`source_id`), their atlas coordinates (`atlas_coords`) or alternative id (`alternative_tile`).
+   * If a parameter has its value set to the default one, this parameter is not used to filter a cell. Thus, if all parameters have their respective default value, this method returns the same result as {@link get_used_cells}.
+   * A cell is considered empty if its source identifier equals -1, its atlas coordinates identifiers is `Vector2(-1, -1)` and its alternative identifier is -1.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  get_used_cells_by_id(layer: int, source_id?: int, atlas_coords?: Vector2i | Vector2, alternative_tile?: int): Array<Vector2i>;
+  /** Returns a rectangle enclosing the used (non-empty) tiles of the map, including all layers. */
+  get_used_rect(): Rect2i;
+  /**
+   * Returns `true` if the cell on layer `layer` at coordinates `coords` is flipped horizontally. The result is valid only for atlas sources.
+   */
+  is_cell_flipped_h(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): boolean;
+  /**
+   * Returns `true` if the cell on layer `layer` at coordinates `coords` is flipped vertically. The result is valid only for atlas sources.
+   */
+  is_cell_flipped_v(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): boolean;
+  /**
+   * Returns `true` if the cell on layer `layer` at coordinates `coords` is transposed. The result is valid only for atlas sources.
+   */
+  is_cell_transposed(layer: int, coords: Vector2i | Vector2, use_proxies?: boolean): boolean;
+  /**
+   * Returns if a layer is enabled.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  is_layer_enabled(layer: int): boolean;
+  /** Returns if a layer's built-in navigation regions generation is enabled. */
+  is_layer_navigation_enabled(layer: int): boolean;
+  /**
+   * Returns if a layer Y-sorts its tiles.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  is_layer_y_sort_enabled(layer: int): boolean;
+  /**
+   * Returns the map coordinates of the cell containing the given `local_position`. If `local_position` is in global coordinates, consider using {@link Node2D.to_local} before passing it to this method. See also {@link map_to_local}.
+   */
+  local_to_map(local_position: Vector2 | Vector2i): Vector2i;
+  /**
+   * Returns for the given coordinate `coords_in_pattern` in a {@link TileMapPattern} the corresponding cell coordinates if the pattern was pasted at the `position_in_tilemap` coordinates (see {@link set_pattern}). This mapping is required as in half-offset tile shapes, the mapping might not work by calculating `position_in_tile_map + coords_in_pattern`.
+   */
+  map_pattern(position_in_tilemap: Vector2i | Vector2, coords_in_pattern: Vector2i | Vector2, pattern: TileMapPattern): Vector2i;
+  /**
+   * Returns the centered position of a cell in the TileMap's local coordinate space. To convert the returned value into global coordinates, use {@link Node2D.to_global}. See also {@link local_to_map}.
+   * **Note:** This may not correspond to the visual position of the tile, i.e. it ignores the {@link TileData.texture_origin} property of individual tiles.
+   */
+  map_to_local(map_position: Vector2i | Vector2): Vector2;
+  /** Moves the layer at index `layer` to the given position `to_position` in the array. */
+  move_layer(layer: int, to_position: int): void;
+  /**
+   * Notifies the TileMap node that calls to {@link _use_tile_data_runtime_update} or {@link _tile_data_runtime_update} will lead to different results. This will thus trigger a TileMap update.
+   * If `layer` is provided, only notifies changes for the given layer. Providing the `layer` argument (when applicable) is usually preferred for performance reasons.
+   * **Warning:** Updating the TileMap is computationally expensive and may impact performance. Try to limit the number of calls to this function to avoid unnecessary update.
+   * **Note:** This does not trigger a direct update of the TileMap, the update will be done at the end of the frame as usual (unless you call {@link update_internals}).
+   */
+  notify_runtime_tile_data_update(layer?: int): void;
+  /** Removes the layer at index `layer`. */
+  remove_layer(layer: int): void;
+  /**
+   * Sets the tile identifiers for the cell on layer `layer` at coordinates `coords`. Each tile of the {@link TileSet} is identified using three parts:
+   * - The source identifier `source_id` identifies a {@link TileSetSource} identifier. See {@link TileSet.set_source_id},
+   * - The atlas coordinates identifier `atlas_coords` identifies a tile coordinates in the atlas (if the source is a {@link TileSetAtlasSource}). For {@link TileSetScenesCollectionSource} it should always be `Vector2i(0, 0)`),
+   * - The alternative tile identifier `alternative_tile` identifies a tile alternative in the atlas (if the source is a {@link TileSetAtlasSource}), and the scene for a {@link TileSetScenesCollectionSource}.
+   * If `source_id` is set to `-1`, `atlas_coords` to `Vector2i(-1, -1)` or `alternative_tile` to `-1`, the cell will be erased. An erased cell gets **all** its identifiers automatically set to their respective invalid values, namely `-1`, `Vector2i(-1, -1)` and `-1`.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_cell(layer: int, coords: Vector2i | Vector2, source_id?: int, atlas_coords?: Vector2i | Vector2, alternative_tile?: int): void;
+  /**
+   * Update all the cells in the `cells` coordinates array so that they use the given `terrain` for the given `terrain_set`. If an updated cell has the same terrain as one of its neighboring cells, this function tries to join the two. This function might update neighboring tiles if needed to create correct terrain transitions.
+   * If `ignore_empty_terrains` is `true`, empty terrains will be ignored when trying to find the best fitting tile for the given terrain constraints.
+   * If `layer` is negative, the layers are accessed from the last one.
+   * **Note:** To work correctly, this method requires the TileMap's TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results.
+   */
+  set_cells_terrain_connect(layer: int, cells: Array<Vector2i>, terrain_set: int, terrain: int, ignore_empty_terrains?: boolean): void;
+  /**
+   * Update all the cells in the `path` coordinates array so that they use the given `terrain` for the given `terrain_set`. The function will also connect two successive cell in the path with the same terrain. This function might update neighboring tiles if needed to create correct terrain transitions.
+   * If `ignore_empty_terrains` is `true`, empty terrains will be ignored when trying to find the best fitting tile for the given terrain constraints.
+   * If `layer` is negative, the layers are accessed from the last one.
+   * **Note:** To work correctly, this method requires the TileMap's TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results.
+   */
+  set_cells_terrain_path(layer: int, path: Array<Vector2i>, terrain_set: int, terrain: int, ignore_empty_terrains?: boolean): void;
+  /**
+   * Enables or disables the layer `layer`. A disabled layer is not processed at all (no rendering, no physics, etc.).
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_enabled(layer: int, enabled: boolean): void;
+  /**
+   * Sets a layer's color. It will be multiplied by tile's color and TileMap's modulate.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_modulate(layer: int, modulate: Color): void;
+  /**
+   * Sets a layer's name. This is mostly useful in the editor.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_name(layer: int, name: string | NodePath): void;
+  /**
+   * Enables or disables a layer's built-in navigation regions generation. Disable this if you need to bake navigation regions from a TileMap using a {@link NavigationRegion2D} node.
+   */
+  set_layer_navigation_enabled(layer: int, enabled: boolean): void;
+  /**
+   * Assigns `map` as a {@link NavigationServer2D} navigation map for the specified TileMap layer `layer`.
+   * By default the TileMap uses the default {@link World2D} navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
+   * In order to make {@link NavigationAgent2D} switch between TileMap layer navigation maps use {@link NavigationAgent2D.set_navigation_map} with the navigation map received from {@link get_layer_navigation_map}.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_navigation_map(layer: int, map: RID): void;
+  /**
+   * Enables or disables a layer's Y-sorting. If a layer is Y-sorted, the layer will behave as a CanvasItem node where each of its tile gets Y-sorted.
+   * Y-sorted layers should usually be on different Z-index values than not Y-sorted layers, otherwise, each of those layer will be Y-sorted as whole with the Y-sorted one. This is usually an undesired behavior.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_y_sort_enabled(layer: int, y_sort_enabled: boolean): void;
+  /**
+   * Sets a layer's Y-sort origin value. This Y-sort origin value is added to each tile's Y-sort origin value.
+   * This allows, for example, to fake a different height level on each layer. This can be useful for top-down view games.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_y_sort_origin(layer: int, y_sort_origin: int): void;
+  /**
+   * Sets a layers Z-index value. This Z-index is added to each tile's Z-index value.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_layer_z_index(layer: int, z_index: int): void;
+  /**
+   * Assigns `map` as a {@link NavigationServer2D} navigation map for the specified TileMap layer `layer`.
+   */
+  set_navigation_map(layer: int, map: RID): void;
+  /**
+   * Paste the given {@link TileMapPattern} at the given `position` and `layer` in the tile map.
+   * If `layer` is negative, the layers are accessed from the last one.
+   */
+  set_pattern(layer: int, position: Vector2i | Vector2, pattern: TileMapPattern): void;
+  /**
+   * Triggers a direct update of the TileMap. Usually, calling this function is not needed, as TileMap node updates automatically when one of its properties or cells is modified.
+   * However, for performance reasons, those updates are batched and delayed to the end of the frame. Calling this function will force the TileMap to update right away instead.
+   * **Warning:** Updating the TileMap is computationally expensive and may impact performance. Try to limit the number of updates and how many tiles they impact.
+   */
+  update_internals(): void;
+
+  /** Emitted when the {@link TileSet} of this TileMap changes. */
+  changed: Signal<[]>;
+
+  // enum VisibilityMode
+  /** Use the debug settings to determine visibility. */
+  static readonly VISIBILITY_MODE_DEFAULT: int;
+  /** Always hide. */
+  static readonly VISIBILITY_MODE_FORCE_HIDE: int;
+  /** Always show. */
+  static readonly VISIBILITY_MODE_FORCE_SHOW: int;
+}

package/typings/classes/TileMapLayer.d.ts

@@ -0,0 +1,244 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node for 2D tile-based maps. */
+declare class TileMapLayer extends Node2D {
+  /** Enable or disable collisions. */
+  collision_enabled: boolean;
+  /**
+   * Show or hide the {@link TileMapLayer}'s collision shapes. If set to {@link DEBUG_VISIBILITY_MODE_DEFAULT}, this depends on the show collision debug settings.
+   */
+  collision_visibility_mode: int;
+  /**
+   * If `false`, disables this {@link TileMapLayer} completely (rendering, collision, navigation, scene tiles, etc.)
+   */
+  enabled: boolean;
+  /** If `true`, navigation regions are enabled. */
+  navigation_enabled: boolean;
+  /**
+   * Show or hide the {@link TileMapLayer}'s navigation meshes. If set to {@link DEBUG_VISIBILITY_MODE_DEFAULT}, this depends on the show navigation debug settings.
+   */
+  navigation_visibility_mode: int;
+  /** Enable or disable light occlusion. */
+  occlusion_enabled: boolean;
+  /**
+   * The {@link TileMapLayer}'s physics quadrant size. Within a physics quadrant, cells with similar physics properties are grouped together and their collision shapes get merged. {@link physics_quadrant_size} defines the length of a square's side, in the map's coordinate system, that forms the quadrant. Thus, the default quadrant size groups together `16 * 16 = 256` tiles.
+   * **Note:** As quadrants are created according to the map's coordinate system, the quadrant's "square shape" might not look like square in the {@link TileMapLayer}'s local coordinate system.
+   * **Note:** This impacts the value returned by {@link get_coords_for_body_rid}. Higher values will make that function less precise. To get the exact cell coordinates, you need to set {@link physics_quadrant_size} to `1`, which disables physics chunking.
+   */
+  physics_quadrant_size: int;
+  /**
+   * The {@link TileMapLayer}'s rendering quadrant size. A quadrant is a group of tiles to be drawn together on a single canvas item, for optimization purposes. {@link rendering_quadrant_size} defines the length of a square's side, in the map's coordinate system, that forms the quadrant. Thus, the default quadrant size groups together `16 * 16 = 256` tiles.
+   * The quadrant size does not apply on a Y-sorted {@link TileMapLayer}, as tiles are grouped by Y position instead in that case.
+   * **Note:** As quadrants are created according to the map's coordinate system, the quadrant's "square shape" might not look like square in the {@link TileMapLayer}'s local coordinate system.
+   */
+  rendering_quadrant_size: int;
+  /** The raw tile map data as a byte array. */
+  tile_map_data: PackedByteArray;
+  /**
+   * The {@link TileSet} used by this layer. The textures, collisions, and additional behavior of all available tiles are stored here.
+   */
+  tile_set: TileSet | null;
+  /**
+   * If `true`, this {@link TileMapLayer} collision shapes will be instantiated as kinematic bodies. This can be needed for moving {@link TileMapLayer} nodes (i.e. moving platforms).
+   */
+  use_kinematic_bodies: boolean;
+  /**
+   * If {@link CanvasItem.y_sort_enabled} is enabled, setting this to `true` will reverse the order the tiles are drawn on the X-axis.
+   */
+  x_draw_order_reversed: boolean;
+  /**
+   * This Y-sort origin value is added to each tile's Y-sort origin value. This allows, for example, to fake a different height level. This can be useful for top-down view games.
+   */
+  y_sort_origin: int;
+  set_collision_enabled(value: boolean): void;
+  is_collision_enabled(): boolean;
+  set_collision_visibility_mode(value: int): void;
+  get_collision_visibility_mode(): int;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_navigation_enabled(value: boolean): void;
+  is_navigation_enabled(): boolean;
+  set_navigation_visibility_mode(value: int): void;
+  get_navigation_visibility_mode(): int;
+  set_occlusion_enabled(value: boolean): void;
+  is_occlusion_enabled(): boolean;
+  set_physics_quadrant_size(value: int): void;
+  get_physics_quadrant_size(): int;
+  set_rendering_quadrant_size(value: int): void;
+  get_rendering_quadrant_size(): int;
+  set_tile_map_data_from_array(value: PackedByteArray | Array<unknown>): void;
+  get_tile_map_data_as_array(): PackedByteArray;
+  set_tile_set(value: TileSet | null): void;
+  get_tile_set(): TileSet | null;
+  set_use_kinematic_bodies(value: boolean): void;
+  is_using_kinematic_bodies(): boolean;
+  set_x_draw_order_reversed(value: boolean): void;
+  is_x_draw_order_reversed(): boolean;
+  set_y_sort_origin(value: int): void;
+  get_y_sort_origin(): int;
+
+  /**
+   * Called with a {@link TileData} object about to be used internally by the {@link TileMapLayer}, allowing its modification at runtime.
+   * This method is only called if {@link _use_tile_data_runtime_update} is implemented and returns `true` for the given tile `coords`.
+   * **Warning:** The `tile_data` object's sub-resources are the same as the one in the TileSet. Modifying them might impact the whole TileSet. Instead, make sure to duplicate those resources.
+   * **Note:** If the properties of `tile_data` object should change over time, use {@link notify_runtime_tile_data_update} to notify the {@link TileMapLayer} it needs an update.
+   */
+  _tile_data_runtime_update(coords: Vector2i | Vector2, tile_data: TileData): void;
+  /**
+   * Called when this {@link TileMapLayer}'s cells need an internal update. This update may be caused from individual cells being modified or by a change in the {@link tile_set} (causing all cells to be queued for an update). The first call to this function is always for initializing all the {@link TileMapLayer}'s cells. `coords` contains the coordinates of all modified cells, roughly in the order they were modified. `forced_cleanup` is `true` when the {@link TileMapLayer}'s internals should be fully cleaned up. This is the case when:
+   * - The layer is disabled;
+   * - The layer is not visible;
+   * - {@link tile_set} is set to `null`;
+   * - The node is removed from the tree;
+   * - The node is freed.
+   * Note that any internal update happening while one of these conditions is verified is considered to be a "cleanup". See also {@link update_internals}.
+   * **Warning:** Implementing this method may degrade the {@link TileMapLayer}'s performance.
+   */
+  _update_cells(coords: Array<Vector2i>, forced_cleanup: boolean): void;
+  /**
+   * Should return `true` if the tile at coordinates `coords` requires a runtime update.
+   * **Warning:** Make sure this function only returns `true` when needed. Any tile processed at runtime without a need for it will imply a significant performance penalty.
+   * **Note:** If the result of this function should change, use {@link notify_runtime_tile_data_update} to notify the {@link TileMapLayer} it needs an update.
+   */
+  _use_tile_data_runtime_update(coords: Vector2i | Vector2): boolean;
+  /** Clears all cells. */
+  clear(): void;
+  /** Erases the cell at coordinates `coords`. */
+  erase_cell(coords: Vector2i | Vector2): void;
+  /** Clears cells containing tiles that do not exist in the {@link tile_set}. */
+  fix_invalid_tiles(): void;
+  /** Returns the tile alternative ID of the cell at coordinates `coords`. */
+  get_cell_alternative_tile(coords: Vector2i | Vector2): int;
+  /**
+   * Returns the tile atlas coordinates ID of the cell at coordinates `coords`. Returns `Vector2i(-1, -1)` if the cell does not exist.
+   */
+  get_cell_atlas_coords(coords: Vector2i | Vector2): Vector2i;
+  /**
+   * Returns the tile source ID of the cell at coordinates `coords`. Returns `-1` if the cell does not exist.
+   */
+  get_cell_source_id(coords: Vector2i | Vector2): int;
+  /**
+   * Returns the {@link TileData} object associated with the given cell, or `null` if the cell does not exist or is not a {@link TileSetAtlasSource}.
+   */
+  get_cell_tile_data(coords: Vector2i | Vector2): TileData | null;
+  /**
+   * Returns the coordinates of the physics quadrant (see {@link physics_quadrant_size}) for given physics body {@link RID}. Such an {@link RID} can be retrieved from {@link KinematicCollision2D.get_collider_rid}, when colliding with a tile.
+   * **Note:** Higher values of {@link physics_quadrant_size} will make this function less precise. To get the exact cell coordinates, you need to set {@link physics_quadrant_size} to `1`, which disables physics chunking.
+   */
+  get_coords_for_body_rid(body: RID): Vector2i;
+  /**
+   * Returns the {@link RID} of the {@link NavigationServer2D} navigation used by this {@link TileMapLayer}.
+   * By default this returns the default {@link World2D} navigation map, unless a custom map was provided using {@link set_navigation_map}.
+   */
+  get_navigation_map(): RID;
+  /**
+   * Returns the neighboring cell to the one at coordinates `coords`, identified by the `neighbor` direction. This method takes into account the different layouts a TileMap can take.
+   */
+  get_neighbor_cell(coords: Vector2i | Vector2, neighbor: int): Vector2i;
+  /**
+   * Creates and returns a new {@link TileMapPattern} from the given array of cells. See also {@link set_pattern}.
+   */
+  get_pattern(coords_array: Array<Vector2i>): TileMapPattern;
+  /**
+   * Returns the list of all neighboring cells to the one at `coords`. Any neighboring cell is one that is touching edges, so for a square cell 4 cells would be returned, for a hexagon 6 cells are returned.
+   */
+  get_surrounding_cells(coords: Vector2i | Vector2): Array<Vector2i>;
+  /**
+   * Returns a {@link Vector2i} array with the positions of all cells containing a tile. A cell is considered empty if its source identifier equals `-1`, its atlas coordinate identifier is `Vector2(-1, -1)` and its alternative identifier is `-1`.
+   */
+  get_used_cells(): Array<Vector2i>;
+  /**
+   * Returns a {@link Vector2i} array with the positions of all cells containing a tile. Tiles may be filtered according to their source (`source_id`), their atlas coordinates (`atlas_coords`), or alternative id (`alternative_tile`).
+   * If a parameter has its value set to the default one, this parameter is not used to filter a cell. Thus, if all parameters have their respective default values, this method returns the same result as {@link get_used_cells}.
+   * A cell is considered empty if its source identifier equals `-1`, its atlas coordinate identifier is `Vector2(-1, -1)` and its alternative identifier is `-1`.
+   */
+  get_used_cells_by_id(source_id?: int, atlas_coords?: Vector2i | Vector2, alternative_tile?: int): Array<Vector2i>;
+  /** Returns a rectangle enclosing the used (non-empty) tiles of the map. */
+  get_used_rect(): Rect2i;
+  /**
+   * Returns whether the provided `body` {@link RID} belongs to one of this {@link TileMapLayer}'s cells.
+   */
+  has_body_rid(body: RID): boolean;
+  /**
+   * Returns `true` if the cell at coordinates `coords` is flipped horizontally. The result is valid only for atlas sources.
+   */
+  is_cell_flipped_h(coords: Vector2i | Vector2): boolean;
+  /**
+   * Returns `true` if the cell at coordinates `coords` is flipped vertically. The result is valid only for atlas sources.
+   */
+  is_cell_flipped_v(coords: Vector2i | Vector2): boolean;
+  /**
+   * Returns `true` if the cell at coordinates `coords` is transposed. The result is valid only for atlas sources.
+   */
+  is_cell_transposed(coords: Vector2i | Vector2): boolean;
+  /**
+   * Returns the map coordinates of the cell containing the given `local_position`. If `local_position` is in global coordinates, consider using {@link Node2D.to_local} before passing it to this method. See also {@link map_to_local}.
+   */
+  local_to_map(local_position: Vector2 | Vector2i): Vector2i;
+  /**
+   * Returns for the given coordinates `coords_in_pattern` in a {@link TileMapPattern} the corresponding cell coordinates if the pattern was pasted at the `position_in_tilemap` coordinates (see {@link set_pattern}). This mapping is required as in half-offset tile shapes, the mapping might not work by calculating `position_in_tile_map + coords_in_pattern`.
+   */
+  map_pattern(position_in_tilemap: Vector2i | Vector2, coords_in_pattern: Vector2i | Vector2, pattern: TileMapPattern): Vector2i;
+  /**
+   * Returns the centered position of a cell in the {@link TileMapLayer}'s local coordinate space. To convert the returned value into global coordinates, use {@link Node2D.to_global}. See also {@link local_to_map}.
+   * **Note:** This may not correspond to the visual position of the tile, i.e. it ignores the {@link TileData.texture_origin} property of individual tiles.
+   */
+  map_to_local(map_position: Vector2i | Vector2): Vector2;
+  /**
+   * Notifies the {@link TileMapLayer} node that calls to {@link _use_tile_data_runtime_update} or {@link _tile_data_runtime_update} will lead to different results. This will thus trigger a {@link TileMapLayer} update.
+   * **Warning:** Updating the {@link TileMapLayer} is computationally expensive and may impact performance. Try to limit the number of calls to this function to avoid unnecessary update.
+   * **Note:** This does not trigger a direct update of the {@link TileMapLayer}, the update will be done at the end of the frame as usual (unless you call {@link update_internals}).
+   */
+  notify_runtime_tile_data_update(): void;
+  /**
+   * Sets the tile identifiers for the cell at coordinates `coords`. Each tile of the {@link TileSet} is identified using three parts:
+   * - The source identifier `source_id` identifies a {@link TileSetSource} identifier. See {@link TileSet.set_source_id},
+   * - The atlas coordinate identifier `atlas_coords` identifies a tile coordinates in the atlas (if the source is a {@link TileSetAtlasSource}). For {@link TileSetScenesCollectionSource} it should always be `Vector2i(0, 0)`,
+   * - The alternative tile identifier `alternative_tile` identifies a tile alternative in the atlas (if the source is a {@link TileSetAtlasSource}), and the scene for a {@link TileSetScenesCollectionSource}.
+   * If `source_id` is set to `-1`, `atlas_coords` to `Vector2i(-1, -1)`, or `alternative_tile` to `-1`, the cell will be erased. An erased cell gets **all** its identifiers automatically set to their respective invalid values, namely `-1`, `Vector2i(-1, -1)` and `-1`.
+   */
+  set_cell(coords: Vector2i | Vector2, source_id?: int, atlas_coords?: Vector2i | Vector2, alternative_tile?: int): void;
+  /**
+   * Update all the cells in the `cells` coordinates array so that they use the given `terrain` for the given `terrain_set`. If an updated cell has the same terrain as one of its neighboring cells, this function tries to join the two. This function might update neighboring tiles if needed to create correct terrain transitions.
+   * If `ignore_empty_terrains` is `true`, empty terrains will be ignored when trying to find the best fitting tile for the given terrain constraints.
+   * **Note:** To work correctly, this method requires the {@link TileMapLayer}'s TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results.
+   */
+  set_cells_terrain_connect(cells: Array<Vector2i>, terrain_set: int, terrain: int, ignore_empty_terrains?: boolean): void;
+  /**
+   * Update all the cells in the `path` coordinates array so that they use the given `terrain` for the given `terrain_set`. The function will also connect two successive cell in the path with the same terrain. This function might update neighboring tiles if needed to create correct terrain transitions.
+   * If `ignore_empty_terrains` is `true`, empty terrains will be ignored when trying to find the best fitting tile for the given terrain constraints.
+   * **Note:** To work correctly, this method requires the {@link TileMapLayer}'s TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results.
+   */
+  set_cells_terrain_path(path: Array<Vector2i>, terrain_set: int, terrain: int, ignore_empty_terrains?: boolean): void;
+  /**
+   * Sets a custom `map` as a {@link NavigationServer2D} navigation map. If not set, uses the default {@link World2D} navigation map instead.
+   */
+  set_navigation_map(map: RID): void;
+  /**
+   * Pastes the {@link TileMapPattern} at the given `position` in the tile map. See also {@link get_pattern}.
+   */
+  set_pattern(position: Vector2i | Vector2, pattern: TileMapPattern): void;
+  /**
+   * Triggers a direct update of the {@link TileMapLayer}. Usually, calling this function is not needed, as {@link TileMapLayer} node updates automatically when one of its properties or cells is modified.
+   * However, for performance reasons, those updates are batched and delayed to the end of the frame. Calling this function will force the {@link TileMapLayer} to update right away instead.
+   * **Warning:** Updating the {@link TileMapLayer} is computationally expensive and may impact performance. Try to limit the number of updates and how many tiles they impact.
+   */
+  update_internals(): void;
+
+  /**
+   * Emitted when this {@link TileMapLayer}'s properties changes. This includes modified cells, properties, or changes made to its assigned {@link TileSet}.
+   * **Note:** This signal may be emitted very often when batch-modifying a {@link TileMapLayer}. Avoid executing complex processing in a connected function, and consider delaying it to the end of the frame instead (i.e. calling {@link Object.call_deferred}).
+   */
+  changed: Signal<[]>;
+
+  // enum DebugVisibilityMode
+  /**
+   * Hide the collisions or navigation debug shapes in the editor, and use the debug settings to determine their visibility in game (i.e. {@link SceneTree.debug_collisions_hint} or {@link SceneTree.debug_navigation_hint}).
+   */
+  static readonly DEBUG_VISIBILITY_MODE_DEFAULT: int;
+  /** Always hide the collisions or navigation debug shapes. */
+  static readonly DEBUG_VISIBILITY_MODE_FORCE_HIDE: int;
+  /** Always show the collisions or navigation debug shapes. */
+  static readonly DEBUG_VISIBILITY_MODE_FORCE_SHOW: int;
+}

package/typings/classes/TileMapPattern.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Holds a pattern to be copied from or pasted into {@link TileMap}s. */
+declare class TileMapPattern extends Resource {
+  /** Returns the tile alternative ID of the cell at `coords`. */
+  get_cell_alternative_tile(coords: Vector2i | Vector2): int;
+  /** Returns the tile atlas coordinates ID of the cell at `coords`. */
+  get_cell_atlas_coords(coords: Vector2i | Vector2): Vector2i;
+  /** Returns the tile source ID of the cell at `coords`. */
+  get_cell_source_id(coords: Vector2i | Vector2): int;
+  /** Returns the size, in cells, of the pattern. */
+  get_size(): Vector2i;
+  /** Returns the list of used cell coordinates in the pattern. */
+  get_used_cells(): Array<Vector2i>;
+  /** Returns whether the pattern has a tile at the given coordinates. */
+  has_cell(coords: Vector2i | Vector2): boolean;
+  /** Returns whether the pattern is empty or not. */
+  is_empty(): boolean;
+  /** Remove the cell at the given coordinates. */
+  remove_cell(coords: Vector2i | Vector2, update_size: boolean): void;
+  /** Sets the tile identifiers for the cell at coordinates `coords`. See {@link TileMap.set_cell}. */
+  set_cell(coords: Vector2i | Vector2, source_id?: int, atlas_coords?: Vector2i | Vector2, alternative_tile?: int): void;
+  /** Sets the size of the pattern. */
+  set_size(size: Vector2i | Vector2): void;
+}