@ringozz/godot 0.1.0

package/gen/classes/TileMapLayer.ts

@@ -0,0 +1,303 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { GodotArray, PackedByteArray, RID, Signal } from '../heap-types/index.ts';
+import type { Rect2i, Vector2, Vector2i } from '../value-types/index.ts';
+import type { TileData } from './TileData.ts';
+import type { TileMapPattern } from './TileMapPattern.ts';
+import type { CellNeighbor, TileSet } from './TileSet.ts';
+
+/**
+ * Node for 2D tile-based maps. A {@link TileMapLayer} uses a {@link TileSet} which contain a list of tiles which are used to create grid-based maps. Unlike the {@link TileMap} node, which is deprecated, {@link TileMapLayer} has only one layer of tiles. You can use several {@link TileMapLayer} to achieve the same result as a {@link TileMap} node.
+ * For performance reasons, all TileMap updates are batched at the end of a frame. Notably, this means that scene tiles from a {@link TileSetScenesCollectionSource} are initialized after their parent. This is only queued when inside the scene tree.
+ * To force an update earlier on, call {@link updateInternals}.
+ * **Note:** For performance and compatibility reasons, the coordinates serialized by {@link TileMapLayer} are limited to 16-bit signed integers, i.e. the range for X and Y coordinates is from `-32768` to `32767`. When saving tile data, tiles outside this range are wrapped.
+ */
+export class TileMapLayer extends Node2D {
+    constructor(name = 795) { super(name); }
+
+    /**
+     * Sets the tile identifiers for the cell at coordinates `coords`. Each tile of the {@link TileSet} is identified using three parts:
+     * - The source identifier `sourceId` identifies a {@link TileSetSource} identifier. See {@link TileSet.setSourceId},
+     * - The atlas coordinate identifier `atlasCoords` 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 `alternativeTile` identifies a tile alternative in the atlas (if the source is a {@link TileSetAtlasSource}), and the scene for a {@link TileSetScenesCollectionSource}.
+     * If `sourceId` is set to `-1`, `atlasCoords` to `Vector2i(-1, -1)`, or `alternativeTile` 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`.
+     */
+    setCell(coords: Vector2i, sourceId?: number /* = -1 */, atlasCoords?: Vector2i /* = Vector2i(-1, -1) */, alternativeTile?: number /* = 0 */): void { _C(this, 10820, coords, sourceId, atlasCoords, alternativeTile); }
+
+    /**
+     * Erases the cell at coordinates `coords`.
+     */
+    eraseCell(coords: Vector2i): void { _C(this, 3158, coords); }
+
+    /**
+     * Clears cells containing tiles that do not exist in the {@link tileSet}.
+     */
+    fixInvalidTiles(): void { _C(this, 3317); }
+
+    /**
+     * Clears all cells.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns the tile source ID of the cell at coordinates `coords`. Returns `-1` if the cell does not exist.
+     */
+    getCellSourceId(coords: Vector2i): number { return _C(this, 4116, coords) as number; }
+
+    /**
+     * Returns the tile atlas coordinates ID of the cell at coordinates `coords`. Returns `Vector2i(-1, -1)` if the cell does not exist.
+     */
+    getCellAtlasCoords(coords: Vector2i): Vector2i { return _C(this, 4107, coords) as Vector2i; }
+
+    /**
+     * Returns the tile alternative ID of the cell at coordinates `coords`.
+     */
+    getCellAlternativeTile(coords: Vector2i): number { return _C(this, 4106, coords) as number; }
+
+    /**
+     * Returns the {@link TileData} object associated with the given cell, or `null` if the cell does not exist or is not a {@link TileSetAtlasSource}.
+     *
+     * ```text
+     *
+     * func get_clicked_tile_power():
+     * 	var clicked_cell = tile_map_layer.local_to_map(tile_map_layer.get_local_mouse_position())
+     * 	var data = tile_map_layer.get_cell_tile_data(clicked_cell)
+     * 	if data:
+     * 		return data.get_custom_data("power")
+     * 	else:
+     * 		return 0
+     *
+     * ```
+     */
+    getCellTileData(coords: Vector2i): TileData | null { return _C(this, 4117, coords) as TileData | null; }
+
+    /**
+     * Returns `true` if the cell at coordinates `coords` is flipped horizontally. The result is valid only for atlas sources.
+     */
+    isCellFlippedH(coords: Vector2i): boolean { return _C(this, 7824, coords) as boolean; }
+
+    /**
+     * Returns `true` if the cell at coordinates `coords` is flipped vertically. The result is valid only for atlas sources.
+     */
+    isCellFlippedV(coords: Vector2i): boolean { return _C(this, 7825, coords) as boolean; }
+
+    /**
+     * Returns `true` if the cell at coordinates `coords` is transposed. The result is valid only for atlas sources.
+     */
+    isCellTransposed(coords: Vector2i): boolean { return _C(this, 7826, coords) as boolean; }
+
+    /**
+     * 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`.
+     */
+    getUsedCells(): GodotArray<Vector2i> { return _C(this, 6988) as GodotArray<Vector2i>; }
+
+    /**
+     * Returns a {@link Vector2i} array with the positions of all cells containing a tile. Tiles may be filtered according to their source (`sourceId`), their atlas coordinates (`atlasCoords`), or alternative id (`alternativeTile`).
+     * 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 getUsedCells}.
+     * 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`.
+     */
+    getUsedCellsById(sourceId?: number /* = -1 */, atlasCoords?: Vector2i /* = Vector2i(-1, -1) */, alternativeTile?: number /* = -1 */): GodotArray<Vector2i> { return _C(this, 6989, sourceId, atlasCoords, alternativeTile) as GodotArray<Vector2i>; }
+
+    /**
+     * Returns a rectangle enclosing the used (non-empty) tiles of the map.
+     */
+    getUsedRect(): Rect2i { return _C(this, 6996) as Rect2i; }
+
+    /**
+     * Creates and returns a new {@link TileMapPattern} from the given array of cells. See also {@link setPattern}.
+     */
+    getPattern(coordsArray: GodotArray<Vector2i>): TileMapPattern { return _C(this, 5867, coordsArray) as TileMapPattern; }
+
+    /**
+     * Pastes the {@link TileMapPattern} at the given `position` in the tile map. See also {@link getPattern}.
+     */
+    setPattern(position: Vector2i, pattern: TileMapPattern): void { _C(this, 12299, position, pattern); }
+
+    /**
+     * Update all the cells in the `cells` coordinates array so that they use the given `terrain` for the given `terrainSet`. 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 `ignoreEmptyTerrains` 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.
+     */
+    setCellsTerrainConnect(cells: GodotArray<Vector2i>, terrainSet: number, terrain: number, ignoreEmptyTerrains?: boolean /* = true */): void { _C(this, 10831, cells, terrainSet, terrain, ignoreEmptyTerrains); }
+
+    /**
+     * Update all the cells in the `path` coordinates array so that they use the given `terrain` for the given `terrainSet`. 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 `ignoreEmptyTerrains` 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.
+     */
+    setCellsTerrainPath(path: GodotArray<Vector2i>, terrainSet: number, terrain: number, ignoreEmptyTerrains?: boolean /* = true */): void { _C(this, 10832, path, terrainSet, terrain, ignoreEmptyTerrains); }
+
+    /**
+     * Returns whether the provided `body` {@link RID} belongs to one of this {@link TileMapLayer}'s cells.
+     */
+    hasBodyRid(body: RID): boolean { return _C(this, 7368, body) as boolean; }
+
+    /**
+     * Returns the coordinates of the physics quadrant (see {@link physicsQuadrantSize}) for given physics body {@link RID}. Such an {@link RID} can be retrieved from {@link KinematicCollision2D.getColliderRid}, when colliding with a tile.
+     * **Note:** Higher values of {@link physicsQuadrantSize} will make this function less precise. To get the exact cell coordinates, you need to set {@link physicsQuadrantSize} to `1`, which disables physics chunking.
+     */
+    getCoordsForBodyRid(body: RID): Vector2i { return _C(this, 4324, body) as Vector2i; }
+
+    /**
+     * 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.
+     */
+    updateInternals(): void { _C(this, 14517); }
+
+    /**
+     * Notifies the {@link TileMapLayer} node that calls to {@link _useTileDataRuntimeUpdate} or {@link _tileDataRuntimeUpdate} 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 updateInternals}).
+     */
+    notifyRuntimeTileDataUpdate(): void { _C(this, 9112); }
+
+    /**
+     * Returns for the given coordinates `coordsInPattern` in a {@link TileMapPattern} the corresponding cell coordinates if the pattern was pasted at the `positionInTilemap` coordinates (see {@link setPattern}). This mapping is required as in half-offset tile shapes, the mapping might not work by calculating `position_in_tile_map + coords_in_pattern`.
+     */
+    mapPattern(positionInTilemap: Vector2i, coordsInPattern: Vector2i, pattern: TileMapPattern): Vector2i { return _C(this, 8771, positionInTilemap, coordsInPattern, pattern) as Vector2i; }
+
+    /**
+     * 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.
+     */
+    getSurroundingCells(coords: Vector2i): GodotArray<Vector2i> { return _C(this, 6637, coords) as GodotArray<Vector2i>; }
+
+    /**
+     * 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.
+     */
+    getNeighborCell(coords: Vector2i, neighbor: CellNeighbor): Vector2i { return _C(this, 5620, coords, neighbor) as 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.toGlobal}. See also {@link localToMap}.
+     * **Note:** This may not correspond to the visual position of the tile, i.e. it ignores the {@link TileData.textureOrigin} property of individual tiles.
+     */
+    mapToLocal(mapPosition: Vector2i): Vector2 { return _C(this, 8782, mapPosition) as Vector2; }
+
+    /**
+     * Returns the map coordinates of the cell containing the given `localPosition`. If `localPosition` is in global coordinates, consider using {@link Node2D.toLocal} before passing it to this method. See also {@link mapToLocal}.
+     */
+    localToMap(localPosition: Vector2): Vector2i { return _C(this, 8694, localPosition) as Vector2i; }
+
+    /**
+     * Sets a custom `map` as a {@link NavigationServer2D} navigation map. If not set, uses the default {@link World2D} navigation map instead.
+     */
+    setNavigationMap(map: RID): void { _C(this, 12120, map); }
+
+    /**
+     * 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 setNavigationMap}.
+     */
+    getNavigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * The raw tile map data as a byte array.
+     */
+    get tileMapData(): PackedByteArray { return _C(this, 6794) as PackedByteArray; }
+    set tileMapData(v: PackedByteArray) { _C(this, 13072, v); }
+
+    /**
+     * If `false`, disables this {@link TileMapLayer} completely (rendering, collision, navigation, scene tiles, etc.)
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * The {@link TileSet} used by this layer. The textures, collisions, and additional behavior of all available tiles are stored here.
+     */
+    get tileSet(): TileSet { return _C(this, 6796) as TileSet; }
+    set tileSet(v: TileSet) { _C(this, 13075, v); }
+
+    /**
+     * Enable or disable light occlusion.
+     */
+    get occlusionEnabled(): boolean { return _C(this, 8141) as boolean; }
+    set occlusionEnabled(v: boolean) { _C(this, 12164, v); }
+
+    /**
+     * 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.
+     */
+    get ySortOrigin(): number { return _C(this, 7177) as number; }
+    set ySortOrigin(v: number) { _C(this, 13400, v); }
+
+    /**
+     * If {@link CanvasItem.ySortEnabled} is enabled, setting this to `true` will reverse the order the tiles are drawn on the X-axis.
+     */
+    get xDrawOrderReversed(): boolean { return _C(this, 8456) as boolean; }
+    set xDrawOrderReversed(v: boolean) { _C(this, 13393, v); }
+
+    /**
+     * 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 renderingQuadrantSize} 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.
+     */
+    get renderingQuadrantSize(): number { return _C(this, 6142) as number; }
+    set renderingQuadrantSize(v: number) { _C(this, 12524, v); }
+
+    /**
+     * Enable or disable collisions.
+     */
+    get collisionEnabled(): boolean { return _C(this, 7843) as boolean; }
+    set collisionEnabled(v: boolean) { _C(this, 10890, v); }
+
+    /**
+     * 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).
+     */
+    get useKinematicBodies(): boolean { return _C(this, 8408) as boolean; }
+    set useKinematicBodies(v: boolean) { _C(this, 13223, v); }
+
+    /**
+     * 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.
+     */
+    get collisionVisibilityMode(): DebugVisibilityMode { return _C(this, 4218) as DebugVisibilityMode; }
+    set collisionVisibilityMode(v: DebugVisibilityMode) { _C(this, 10904, v); }
+
+    /**
+     * 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 physicsQuadrantSize} 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 getCoordsForBodyRid}. Higher values will make that function less precise. To get the exact cell coordinates, you need to set {@link physicsQuadrantSize} to `1`, which disables physics chunking.
+     */
+    get physicsQuadrantSize(): number { return _C(this, 5903) as number; }
+    set physicsQuadrantSize(v: number) { _C(this, 12324, v); }
+
+    /**
+     * If `true`, navigation regions are enabled.
+     */
+    get navigationEnabled(): boolean { return _C(this, 8128) as boolean; }
+    set navigationEnabled(v: boolean) { _C(this, 12115, v); }
+
+    /**
+     * 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.
+     */
+    get navigationVisibilityMode(): DebugVisibilityMode { return _C(this, 5615) as DebugVisibilityMode; }
+    set navigationVisibilityMode(v: DebugVisibilityMode) { _C(this, 12123, v); }
+
+    /**
+     * 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.callDeferred}).
+     */
+    get changed(): Signal<() => void> { return _G(this, 2190) as Signal<() => void>; }
+    set changed(v: (() => void) | null) { _G(this, 2190, v); }
+
+    static readonly name = _R(795, TileMapLayer);
+}
+
+export const 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.debugCollisionsHint} or {@link SceneTree.debugNavigationHint}).
+     */
+    DEBUG_VISIBILITY_MODE_DEFAULT: 0,
+    /**
+     * Always hide the collisions or navigation debug shapes.
+     */
+    DEBUG_VISIBILITY_MODE_FORCE_HIDE: 2,
+    /**
+     * Always show the collisions or navigation debug shapes.
+     */
+    DEBUG_VISIBILITY_MODE_FORCE_SHOW: 1,
+} as const;
+
+export type DebugVisibilityMode = (typeof DebugVisibilityMode)[keyof typeof DebugVisibilityMode];
+

package/gen/classes/TileMapPattern.ts

@@ -0,0 +1,67 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Vector2i } from '../value-types/index.ts';
+
+/**
+ * This resource holds a set of cells to help bulk manipulations of {@link TileMap}.
+ * A pattern always starts at the `(0, 0)` coordinates and cannot have cells with negative coordinates.
+ */
+export class TileMapPattern extends Resource {
+    constructor(name = 796) { super(name); }
+
+    /**
+     * Sets the tile identifiers for the cell at coordinates `coords`. See {@link TileMap.setCell}.
+     */
+    setCell(coords: Vector2i, sourceId?: number /* = -1 */, atlasCoords?: Vector2i /* = Vector2i(-1, -1) */, alternativeTile?: number /* = -1 */): void { _C(this, 10820, coords, sourceId, atlasCoords, alternativeTile); }
+
+    /**
+     * Returns whether the pattern has a tile at the given coordinates.
+     */
+    hasCell(coords: Vector2i): boolean { return _C(this, 7373, coords) as boolean; }
+
+    /**
+     * Remove the cell at the given coordinates.
+     */
+    removeCell(coords: Vector2i, updateSize: boolean): void { _C(this, 9895, coords, updateSize); }
+
+    /**
+     * Returns the tile source ID of the cell at `coords`.
+     */
+    getCellSourceId(coords: Vector2i): number { return _C(this, 4116, coords) as number; }
+
+    /**
+     * Returns the tile atlas coordinates ID of the cell at `coords`.
+     */
+    getCellAtlasCoords(coords: Vector2i): Vector2i { return _C(this, 4107, coords) as Vector2i; }
+
+    /**
+     * Returns the tile alternative ID of the cell at `coords`.
+     */
+    getCellAlternativeTile(coords: Vector2i): number { return _C(this, 4106, coords) as number; }
+
+    /**
+     * Returns the list of used cell coordinates in the pattern.
+     */
+    getUsedCells(): GodotArray<Vector2i> { return _C(this, 6988) as GodotArray<Vector2i>; }
+
+    /**
+     * Returns the size, in cells, of the pattern.
+     */
+    getSize(): Vector2i { return _C(this, 6399) as Vector2i; }
+
+    /**
+     * Sets the size of the pattern.
+     */
+    setSize(size: Vector2i): void { _C(this, 12752, size); }
+
+    /**
+     * Returns whether the pattern is empty or not.
+     */
+    isEmpty(): boolean { return _C(this, 7931) as boolean; }
+
+    static readonly name = _R(796, TileMapPattern);
+}