@ringozz/godot 0.1.0

package/gen/classes/TileSet.ts

@@ -0,0 +1,619 @@
+// 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 { Color, Vector2i } from '../value-types/index.ts';
+import type { PhysicsMaterial } from './PhysicsMaterial.ts';
+import type { TileMapPattern } from './TileMapPattern.ts';
+import type { TileSetSource } from './TileSetSource.ts';
+
+/**
+ * A TileSet is a library of tiles for a {@link TileMapLayer}. A TileSet handles a list of {@link TileSetSource}, each of them storing a set of tiles.
+ * Tiles can either be from a {@link TileSetAtlasSource}, which renders tiles out of a texture with support for physics, navigation, etc., or from a {@link TileSetScenesCollectionSource}, which exposes scene-based tiles.
+ * Tiles are referenced by using three IDs: their source ID, their atlas coordinates ID, and their alternative tile ID.
+ * A TileSet can be configured so that its tiles expose more or fewer properties. To do so, the TileSet resources use property layers, which you can add or remove depending on your needs.
+ * For example, adding a physics layer allows giving collision shapes to your tiles. Each layer has dedicated properties (physics layer and mask), so you may add several TileSet physics layers for each type of collision you need.
+ * See the functions to add new layers for more information.
+ */
+export class TileSet extends Resource {
+    constructor(name = 797) { super(name); }
+
+    /**
+     * Returns a new unused source ID. This generated ID is the same that a call to {@link addSource} would return.
+     */
+    getNextSourceId(): number { return _C(this, 5632) as number; }
+
+    /**
+     * Adds a {@link TileSetSource} to the TileSet. If `atlasSourceIdOverride` is not -1, also set its source ID. Otherwise, a unique identifier is automatically generated.
+     * The function returns the added source ID or -1 if the source could not be added.
+     * **Warning:** A source cannot belong to two TileSets at the same time. If the added source was attached to another {@link TileSet}, it will be removed from that one.
+     */
+    addSource(source: TileSetSource, atlasSourceIdOverride?: number /* = -1 */): number { return _C(this, 1290, source, atlasSourceIdOverride) as number; }
+
+    /**
+     * Removes the source with the given source ID.
+     */
+    removeSource(sourceId: number): void { _C(this, 9959, sourceId); }
+
+    /**
+     * Changes a source's ID.
+     */
+    setSourceId(sourceId: number, newSourceId: number): void { _C(this, 12817, sourceId, newSourceId); }
+
+    /**
+     * Returns the number of {@link TileSetSource} in this TileSet.
+     */
+    getSourceCount(): number { return _C(this, 6457) as number; }
+
+    /**
+     * Returns the source ID for source with index `index`.
+     */
+    getSourceId(index: number): number { return _C(this, 6461, index) as number; }
+
+    /**
+     * Returns if this TileSet has a source for the given source ID.
+     */
+    hasSource(sourceId: number): boolean { return _C(this, 7449, sourceId) as boolean; }
+
+    /**
+     * Returns the {@link TileSetSource} with ID `sourceId`.
+     */
+    getSource(sourceId: number): TileSetSource { return _C(this, 6455, sourceId) as TileSetSource; }
+
+    /**
+     * Returns the occlusion layers count.
+     */
+    getOcclusionLayersCount(): number { return _C(this, 5695) as number; }
+
+    /**
+     * Adds an occlusion layer to the TileSet at the given position `toPosition` in the array. If `toPosition` is -1, adds it at the end of the array.
+     * Occlusion layers allow assigning occlusion polygons to atlas tiles.
+     */
+    addOcclusionLayer(toPosition?: number /* = -1 */): void { _C(this, 1261, toPosition); }
+
+    /**
+     * Moves the occlusion layer at index `layerIndex` to the given position `toPosition` in the array. Also updates the atlas tiles accordingly.
+     */
+    moveOcclusionLayer(layerIndex: number, toPosition: number): void { _C(this, 8991, layerIndex, toPosition); }
+
+    /**
+     * Removes the occlusion layer at index `layerIndex`. Also updates the atlas tiles accordingly.
+     */
+    removeOcclusionLayer(layerIndex: number): void { _C(this, 9939, layerIndex); }
+
+    /**
+     * Sets the occlusion layer (as in the rendering server) for occluders in the given TileSet occlusion layer.
+     */
+    setOcclusionLayerLightMask(layerIndex: number, lightMask: number): void { _C(this, 12165, layerIndex, lightMask); }
+
+    /**
+     * Returns the light mask of the occlusion layer.
+     */
+    getOcclusionLayerLightMask(layerIndex: number): number { return _C(this, 5693, layerIndex) as number; }
+
+    /**
+     * Enables or disables SDF collision for occluders in the given TileSet occlusion layer.
+     */
+    setOcclusionLayerSdfCollision(layerIndex: number, sdfCollision: boolean): void { _C(this, 12166, layerIndex, sdfCollision); }
+
+    /**
+     * Returns if the occluders from this layer use `sdf_collision`.
+     */
+    getOcclusionLayerSdfCollision(layerIndex: number): boolean { return _C(this, 5694, layerIndex) as boolean; }
+
+    /**
+     * Returns the physics layers count.
+     */
+    getPhysicsLayersCount(): number { return _C(this, 5895) as number; }
+
+    /**
+     * Adds a physics layer to the TileSet at the given position `toPosition` in the array. If `toPosition` is -1, adds it at the end of the array.
+     * Physics layers allow assigning collision polygons to atlas tiles.
+     */
+    addPhysicsLayer(toPosition?: number /* = -1 */): void { _C(this, 1270, toPosition); }
+
+    /**
+     * Moves the physics layer at index `layerIndex` to the given position `toPosition` in the array. Also updates the atlas tiles accordingly.
+     */
+    movePhysicsLayer(layerIndex: number, toPosition: number): void { _C(this, 8992, layerIndex, toPosition); }
+
+    /**
+     * Removes the physics layer at index `layerIndex`. Also updates the atlas tiles accordingly.
+     */
+    removePhysicsLayer(layerIndex: number): void { _C(this, 9947, layerIndex); }
+
+    /**
+     * Sets the collision layer (as in the physics server) for bodies in the given TileSet physics layer.
+     */
+    setPhysicsLayerCollisionLayer(layerIndex: number, layer: number /* uint32 */): void { _C(this, 12312, layerIndex, layer); }
+
+    /**
+     * Returns the collision layer (as in the physics server) bodies on the given TileSet's physics layer are in.
+     */
+    getPhysicsLayerCollisionLayer(layerIndex: number): number { return _C(this, 5891, layerIndex) as number; }
+
+    /**
+     * Sets the collision mask for bodies in the given TileSet physics layer.
+     */
+    setPhysicsLayerCollisionMask(layerIndex: number, mask: number /* uint32 */): void { _C(this, 12313, layerIndex, mask); }
+
+    /**
+     * Returns the collision mask of bodies on the given TileSet's physics layer.
+     */
+    getPhysicsLayerCollisionMask(layerIndex: number): number { return _C(this, 5892, layerIndex) as number; }
+
+    /**
+     * Sets the collision priority for bodies in the given TileSet physics layer.
+     */
+    setPhysicsLayerCollisionPriority(layerIndex: number, priority: number): void { _C(this, 12314, layerIndex, priority); }
+
+    /**
+     * Returns the collision priority of bodies on the given TileSet's physics layer.
+     */
+    getPhysicsLayerCollisionPriority(layerIndex: number): number { return _C(this, 5893, layerIndex) as number; }
+
+    /**
+     * Sets the physics material for bodies in the given TileSet physics layer.
+     */
+    setPhysicsLayerPhysicsMaterial(layerIndex: number, physicsMaterial: PhysicsMaterial): void { _C(this, 12315, layerIndex, physicsMaterial); }
+
+    /**
+     * Returns the physics material of bodies on the given TileSet's physics layer.
+     */
+    getPhysicsLayerPhysicsMaterial(layerIndex: number): PhysicsMaterial { return _C(this, 5894, layerIndex) as PhysicsMaterial; }
+
+    /**
+     * Returns the terrain sets count.
+     */
+    getTerrainSetsCount(): number { return _C(this, 6713) as number; }
+
+    /**
+     * Adds a new terrain set at the given position `toPosition` in the array. If `toPosition` is -1, adds it at the end of the array.
+     */
+    addTerrainSet(toPosition?: number /* = -1 */): void { _C(this, 1306, toPosition); }
+
+    /**
+     * Moves the terrain set at index `terrainSet` to the given position `toPosition` in the array. Also updates the atlas tiles accordingly.
+     */
+    moveTerrainSet(terrainSet: number, toPosition: number): void { _C(this, 8998, terrainSet, toPosition); }
+
+    /**
+     * Removes the terrain set at index `terrainSet`. Also updates the atlas tiles accordingly.
+     */
+    removeTerrainSet(terrainSet: number): void { _C(this, 9967, terrainSet); }
+
+    /**
+     * Sets a terrain mode. Each mode determines which bits of a tile shape is used to match the neighboring tiles' terrains.
+     */
+    setTerrainSetMode(terrainSet: number, mode: TerrainMode): void { _C(this, 13018, terrainSet, mode); }
+
+    /**
+     * Returns a terrain set mode.
+     */
+    getTerrainSetMode(terrainSet: number): TerrainMode { return _C(this, 6712, terrainSet) as TerrainMode; }
+
+    /**
+     * Returns the number of terrains in the given terrain set.
+     */
+    getTerrainsCount(terrainSet: number): number { return _C(this, 6714, terrainSet) as number; }
+
+    /**
+     * Adds a new terrain to the given terrain set `terrainSet` at the given position `toPosition` in the array. If `toPosition` is -1, adds it at the end of the array.
+     */
+    addTerrain(terrainSet: number, toPosition?: number /* = -1 */): void { _C(this, 1305, terrainSet, toPosition); }
+
+    /**
+     * Moves the terrain at index `terrainIndex` for terrain set `terrainSet` to the given position `toPosition` in the array. Also updates the atlas tiles accordingly.
+     */
+    moveTerrain(terrainSet: number, terrainIndex: number, toPosition: number): void { _C(this, 8997, terrainSet, terrainIndex, toPosition); }
+
+    /**
+     * Removes the terrain at index `terrainIndex` in the given terrain set `terrainSet`. Also updates the atlas tiles accordingly.
+     */
+    removeTerrain(terrainSet: number, terrainIndex: number): void { _C(this, 9966, terrainSet, terrainIndex); }
+
+    /**
+     * Clears all terrain properties for the given terrain set.
+     */
+    clearTerrains(terrainSet: number): void { _C(this, 2302, terrainSet); }
+
+    /**
+     * Sets a terrain's name.
+     */
+    setTerrainName(terrainSet: number, terrainIndex: number, name: string): void { _C(this, 13015, terrainSet, terrainIndex, name); }
+
+    /**
+     * Returns a terrain's name.
+     */
+    getTerrainName(terrainSet: number, terrainIndex: number): string { return _C(this, 6709, terrainSet, terrainIndex) as string; }
+
+    /**
+     * Sets a terrain's color. This color is used for identifying the different terrains in the TileSet editor.
+     */
+    setTerrainColor(terrainSet: number, terrainIndex: number, color: Color): void { _C(this, 13014, terrainSet, terrainIndex, color); }
+
+    /**
+     * Returns a terrain's color.
+     */
+    getTerrainColor(terrainSet: number, terrainIndex: number): Color { return _C(this, 6708, terrainSet, terrainIndex) as Color; }
+
+    /**
+     * Returns the navigation layers count.
+     */
+    getNavigationLayersCount(): number { return _C(this, 5611) as number; }
+
+    /**
+     * Adds a navigation layer to the TileSet at the given position `toPosition` in the array. If `toPosition` is -1, adds it at the end of the array.
+     * Navigation layers allow assigning a navigable area to atlas tiles.
+     */
+    addNavigationLayer(toPosition?: number /* = -1 */): void { _C(this, 1255, toPosition); }
+
+    /**
+     * Moves the navigation layer at index `layerIndex` to the given position `toPosition` in the array. Also updates the atlas tiles accordingly.
+     */
+    moveNavigationLayer(layerIndex: number, toPosition: number): void { _C(this, 8990, layerIndex, toPosition); }
+
+    /**
+     * Removes the navigation layer at index `layerIndex`. Also updates the atlas tiles accordingly.
+     */
+    removeNavigationLayer(layerIndex: number): void { _C(this, 9935, layerIndex); }
+
+    /**
+     * Sets the navigation layers (as in the navigation server) for navigation regions in the given TileSet navigation layer.
+     */
+    setNavigationLayerLayers(layerIndex: number, layers: number /* uint32 */): void { _C(this, 12117, layerIndex, layers); }
+
+    /**
+     * Returns the navigation layers (as in the Navigation server) of the given TileSet navigation layer.
+     */
+    getNavigationLayerLayers(layerIndex: number): number { return _C(this, 5608, layerIndex) as number; }
+
+    /**
+     * Based on `value`, enables or disables the specified navigation layer of the TileSet navigation data layer identified by the given `layerIndex`, given a navigation_layers `layerNumber` between 1 and 32.
+     */
+    setNavigationLayerLayerValue(layerIndex: number, layerNumber: number, value: boolean): void { _C(this, 12116, layerIndex, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified navigation layer of the TileSet navigation data layer identified by the given `layerIndex` is enabled, given a navigation_layers `layerNumber` between 1 and 32.
+     */
+    getNavigationLayerLayerValue(layerIndex: number, layerNumber: number): boolean { return _C(this, 5607, layerIndex, layerNumber) as boolean; }
+
+    /**
+     * Returns the custom data layers count.
+     */
+    getCustomDataLayersCount(): number { return _C(this, 4384) as number; }
+
+    /**
+     * Adds a custom data layer to the TileSet at the given position `toPosition` in the array. If `toPosition` is -1, adds it at the end of the array.
+     * Custom data layers allow assigning custom properties to atlas tiles.
+     */
+    addCustomDataLayer(toPosition?: number /* = -1 */): void { _C(this, 1205, toPosition); }
+
+    /**
+     * Moves the custom data layer at index `layerIndex` to the given position `toPosition` in the array. Also updates the atlas tiles accordingly.
+     */
+    moveCustomDataLayer(layerIndex: number, toPosition: number): void { _C(this, 8983, layerIndex, toPosition); }
+
+    /**
+     * Removes the custom data layer at index `layerIndex`. Also updates the atlas tiles accordingly.
+     */
+    removeCustomDataLayer(layerIndex: number): void { _C(this, 9904, layerIndex); }
+
+    /**
+     * Returns the index of the custom data layer identified by the given name.
+     */
+    getCustomDataLayerByName(layerName: string): number { return _C(this, 4381, layerName) as number; }
+
+    /**
+     * Sets the name of the custom data layer identified by the given index. Names are identifiers of the layer therefore if the name is already taken it will fail and raise an error.
+     */
+    setCustomDataLayerName(layerIndex: number, layerName: string): void { _C(this, 11007, layerIndex, layerName); }
+
+    /**
+     * Returns if there is a custom data layer named `layerName`.
+     */
+    hasCustomDataLayerByName(layerName: string): boolean { return _C(this, 7383, layerName) as boolean; }
+
+    /**
+     * Returns the name of the custom data layer identified by the given index.
+     */
+    getCustomDataLayerName(layerIndex: number): string { return _C(this, 4382, layerIndex) as string; }
+
+    /**
+     * Sets the type of the custom data layer identified by the given index.
+     */
+    setCustomDataLayerType(layerIndex: number, layerType: number): void { _C(this, 11008, layerIndex, layerType); }
+
+    /**
+     * Returns the type of the custom data layer identified by the given index.
+     */
+    getCustomDataLayerType(layerIndex: number): number { return _C(this, 4383, layerIndex) as number; }
+
+    /**
+     * Creates a source-level proxy for the given source ID. A proxy will map set of tile identifiers to another set of identifiers. Both the atlas coordinates ID and the alternative tile ID are kept the same when using source-level proxies.
+     * Proxied tiles can be automatically replaced in TileMapLayer nodes using the editor.
+     */
+    setSourceLevelTileProxy(sourceFrom: number, sourceTo: number): void { _C(this, 12818, sourceFrom, sourceTo); }
+
+    /**
+     * Returns the source-level proxy for the given source identifier.
+     * If the TileSet has no proxy for the given identifier, returns -1.
+     */
+    getSourceLevelTileProxy(sourceFrom: number): number { return _C(this, 6462, sourceFrom) as number; }
+
+    /**
+     * Returns if there is a source-level proxy for the given source ID.
+     */
+    hasSourceLevelTileProxy(sourceFrom: number): boolean { return _C(this, 7451, sourceFrom) as boolean; }
+
+    /**
+     * Removes a source-level tile proxy.
+     */
+    removeSourceLevelTileProxy(sourceFrom: number): void { _C(this, 9960, sourceFrom); }
+
+    /**
+     * Creates a coordinates-level proxy for the given identifiers. A proxy will map set of tile identifiers to another set of identifiers. The alternative tile ID is kept the same when using coordinates-level proxies.
+     * Proxied tiles can be automatically replaced in TileMapLayer nodes using the editor.
+     */
+    setCoordsLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i, sourceTo: number, coordsTo: Vector2i): void { _C(this, 10965, sourceFrom, coordsFrom, sourceTo, coordsTo); }
+
+    /**
+     * Returns the coordinate-level proxy for the given identifiers. The returned array contains the two target identifiers of the proxy (source ID and atlas coordinates ID).
+     * If the TileSet has no proxy for the given identifiers, returns an empty Array.
+     */
+    getCoordsLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i): GodotArray { return _C(this, 4325, sourceFrom, coordsFrom) as GodotArray; }
+
+    /**
+     * Returns if there is a coodinates-level proxy for the given identifiers.
+     */
+    hasCoordsLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i): boolean { return _C(this, 7381, sourceFrom, coordsFrom) as boolean; }
+
+    /**
+     * Removes a coordinates-level proxy for the given identifiers.
+     */
+    removeCoordsLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i): void { _C(this, 9903, sourceFrom, coordsFrom); }
+
+    /**
+     * Create an alternative-level proxy for the given identifiers. A proxy will map set of tile identifiers to another set of identifiers.
+     * Proxied tiles can be automatically replaced in TileMapLayer nodes using the editor.
+     */
+    setAlternativeLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i, alternativeFrom: number, sourceTo: number, coordsTo: Vector2i, alternativeTo: number): void { _C(this, 10473, sourceFrom, coordsFrom, alternativeFrom, sourceTo, coordsTo, alternativeTo); }
+
+    /**
+     * Returns the alternative-level proxy for the given identifiers. The returned array contains the three proxie's target identifiers (source ID, atlas coords ID and alternative tile ID).
+     * If the TileSet has no proxy for the given identifiers, returns an empty Array.
+     */
+    getAlternativeLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i, alternativeFrom: number): GodotArray { return _C(this, 3731, sourceFrom, coordsFrom, alternativeFrom) as GodotArray; }
+
+    /**
+     * Returns if there is an alternative-level proxy for the given identifiers.
+     */
+    hasAlternativeLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i, alternativeFrom: number): boolean { return _C(this, 7354, sourceFrom, coordsFrom, alternativeFrom) as boolean; }
+
+    /**
+     * Removes an alternative-level proxy for the given identifiers.
+     */
+    removeAlternativeLevelTileProxy(sourceFrom: number, coordsFrom: Vector2i, alternativeFrom: number): void { _C(this, 9881, sourceFrom, coordsFrom, alternativeFrom); }
+
+    /**
+     * According to the configured proxies, maps the provided identifiers to a new set of identifiers. The source ID, atlas coordinates ID and alternative tile ID are returned as a 3 elements Array.
+     * This function first look for matching alternative-level proxies, then coordinates-level proxies, then source-level proxies.
+     * If no proxy corresponding to provided identifiers are found, returns the same values the ones used as arguments.
+     */
+    mapTileProxy(sourceFrom: number, coordsFrom: Vector2i, alternativeFrom: number): GodotArray { return _C(this, 8781, sourceFrom, coordsFrom, alternativeFrom) as GodotArray; }
+
+    /**
+     * Clears tile proxies pointing to invalid tiles.
+     */
+    cleanupInvalidTileProxies(): void { _C(this, 2231); }
+
+    /**
+     * Clears all tile proxies.
+     */
+    clearTileProxies(): void { _C(this, 2305); }
+
+    /**
+     * Adds a {@link TileMapPattern} to be stored in the TileSet resource. If provided, insert it at the given `index`.
+     */
+    addPattern(pattern: TileMapPattern, index?: number /* = -1 */): number { return _C(this, 1267, pattern, index) as number; }
+
+    /**
+     * Returns the {@link TileMapPattern} at the given `index`.
+     */
+    getPattern(index?: number /* = -1 */): TileMapPattern { return _C(this, 5867, index) as TileMapPattern; }
+
+    /**
+     * Remove the {@link TileMapPattern} at the given index.
+     */
+    removePattern(index: number): void { _C(this, 9944, index); }
+
+    /**
+     * Returns the number of {@link TileMapPattern} this tile set handles.
+     */
+    getPatternsCount(): number { return _C(this, 5868) as number; }
+
+    /**
+     * The tile shape.
+     */
+    get tileShape(): TileShape { return _C(this, 6797) as TileShape; }
+    set tileShape(v: TileShape) { _C(this, 13076, v); }
+
+    /**
+     * For all half-offset shapes (Isometric, Hexagonal and Half-Offset square), changes the way tiles are indexed in the {@link TileMapLayer} grid.
+     */
+    get tileLayout(): TileLayout { return _C(this, 6793) as TileLayout; }
+    set tileLayout(v: TileLayout) { _C(this, 13071, v); }
+
+    /**
+     * For all half-offset shapes (Isometric, Hexagonal and Half-Offset square), determines the offset axis.
+     */
+    get tileOffsetAxis(): TileOffsetAxis { return _C(this, 6795) as TileOffsetAxis; }
+    set tileOffsetAxis(v: TileOffsetAxis) { _C(this, 13073, v); }
+
+    /**
+     * The tile size, in pixels. For all tile shapes, this size corresponds to the encompassing rectangle of the tile shape. This is thus the minimal cell size required in an atlas.
+     */
+    get tileSize(): Vector2i { return _C(this, 6798) as Vector2i; }
+    set tileSize(v: Vector2i) { _C(this, 13077, v); }
+
+    /**
+     * Enables/Disable uv clipping when rendering the tiles.
+     */
+    get uvClipping(): boolean { return _C(this, 8430) as boolean; }
+    set uvClipping(v: boolean) { _C(this, 13260, v); }
+
+    static readonly name = _R(797, TileSet);
+}
+
+export const TileShape = {
+    /**
+     * Rectangular tile shape.
+     */
+    TILE_SHAPE_SQUARE: 0,
+    /**
+     * Diamond tile shape (for isometric look).
+     * **Note:** Isometric {@link TileSet} works best if all sibling {@link TileMapLayer}s and their parent inheriting from {@link Node2D} have Y-sort enabled.
+     */
+    TILE_SHAPE_ISOMETRIC: 1,
+    /**
+     * Rectangular tile shape with one row/column out of two offset by half a tile.
+     */
+    TILE_SHAPE_HALF_OFFSET_SQUARE: 2,
+    /**
+     * Hexagonal tile shape.
+     */
+    TILE_SHAPE_HEXAGON: 3,
+} as const;
+
+export type TileShape = (typeof TileShape)[keyof typeof TileShape];
+
+export const TileLayout = {
+    /**
+     * Tile coordinates layout where both axis stay consistent with their respective local horizontal and vertical axis.
+     */
+    TILE_LAYOUT_STACKED: 0,
+    /**
+     * Same as {@link TILE_LAYOUT_STACKED}, but the first half-offset is negative instead of positive.
+     */
+    TILE_LAYOUT_STACKED_OFFSET: 1,
+    /**
+     * Tile coordinates layout where the horizontal axis stay horizontal, and the vertical one goes down-right.
+     */
+    TILE_LAYOUT_STAIRS_RIGHT: 2,
+    /**
+     * Tile coordinates layout where the vertical axis stay vertical, and the horizontal one goes down-right.
+     */
+    TILE_LAYOUT_STAIRS_DOWN: 3,
+    /**
+     * Tile coordinates layout where the horizontal axis goes up-right, and the vertical one goes down-right.
+     */
+    TILE_LAYOUT_DIAMOND_RIGHT: 4,
+    /**
+     * Tile coordinates layout where the horizontal axis goes down-right, and the vertical one goes down-left.
+     */
+    TILE_LAYOUT_DIAMOND_DOWN: 5,
+} as const;
+
+export type TileLayout = (typeof TileLayout)[keyof typeof TileLayout];
+
+export const TileOffsetAxis = {
+    /**
+     * Horizontal half-offset.
+     */
+    TILE_OFFSET_AXIS_HORIZONTAL: 0,
+    /**
+     * Vertical half-offset.
+     */
+    TILE_OFFSET_AXIS_VERTICAL: 1,
+} as const;
+
+export type TileOffsetAxis = (typeof TileOffsetAxis)[keyof typeof TileOffsetAxis];
+
+export const CellNeighbor = {
+    /**
+     * Neighbor on the right side.
+     */
+    CELL_NEIGHBOR_RIGHT_SIDE: 0,
+    /**
+     * Neighbor in the right corner.
+     */
+    CELL_NEIGHBOR_RIGHT_CORNER: 1,
+    /**
+     * Neighbor on the bottom right side.
+     */
+    CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE: 2,
+    /**
+     * Neighbor in the bottom right corner.
+     */
+    CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER: 3,
+    /**
+     * Neighbor on the bottom side.
+     */
+    CELL_NEIGHBOR_BOTTOM_SIDE: 4,
+    /**
+     * Neighbor in the bottom corner.
+     */
+    CELL_NEIGHBOR_BOTTOM_CORNER: 5,
+    /**
+     * Neighbor on the bottom left side.
+     */
+    CELL_NEIGHBOR_BOTTOM_LEFT_SIDE: 6,
+    /**
+     * Neighbor in the bottom left corner.
+     */
+    CELL_NEIGHBOR_BOTTOM_LEFT_CORNER: 7,
+    /**
+     * Neighbor on the left side.
+     */
+    CELL_NEIGHBOR_LEFT_SIDE: 8,
+    /**
+     * Neighbor in the left corner.
+     */
+    CELL_NEIGHBOR_LEFT_CORNER: 9,
+    /**
+     * Neighbor on the top left side.
+     */
+    CELL_NEIGHBOR_TOP_LEFT_SIDE: 10,
+    /**
+     * Neighbor in the top left corner.
+     */
+    CELL_NEIGHBOR_TOP_LEFT_CORNER: 11,
+    /**
+     * Neighbor on the top side.
+     */
+    CELL_NEIGHBOR_TOP_SIDE: 12,
+    /**
+     * Neighbor in the top corner.
+     */
+    CELL_NEIGHBOR_TOP_CORNER: 13,
+    /**
+     * Neighbor on the top right side.
+     */
+    CELL_NEIGHBOR_TOP_RIGHT_SIDE: 14,
+    /**
+     * Neighbor in the top right corner.
+     */
+    CELL_NEIGHBOR_TOP_RIGHT_CORNER: 15,
+} as const;
+
+export type CellNeighbor = (typeof CellNeighbor)[keyof typeof CellNeighbor];
+
+export const TerrainMode = {
+    /**
+     * Requires both corners and side to match with neighboring tiles' terrains.
+     */
+    TERRAIN_MODE_MATCH_CORNERS_AND_SIDES: 0,
+    /**
+     * Requires corners to match with neighboring tiles' terrains.
+     */
+    TERRAIN_MODE_MATCH_CORNERS: 1,
+    /**
+     * Requires sides to match with neighboring tiles' terrains.
+     */
+    TERRAIN_MODE_MATCH_SIDES: 2,
+} as const;
+
+export type TerrainMode = (typeof TerrainMode)[keyof typeof TerrainMode];
+