TileMap¶

Inherits: Node2D < CanvasItem < Node < Object

Node for 2D tile-based maps.

Description¶

Node for 2D tile-based maps. Tilemaps use a TileSet which contain a list of tiles (textures plus optional collision, navigation, and/or occluder shapes) which are used to create grid-based maps.

When doing physics queries against the tilemap, the cell coordinates are encoded as metadata for each detected collision shape returned by methods such as Physics2DDirectSpaceState.intersect_shape, Physics2DDirectBodyState.get_contact_collider_shape_metadata, etc.

Tutorials¶

Properties¶

bool	bake_navigation	`false`
bool	cell_clip_uv	`false`
Transform2D	cell_custom_transform	`Transform2D( 64, 0, 0, 64, 0, 0 )`
HalfOffset	cell_half_offset	`2`
int	cell_quadrant_size	`16`
Vector2	cell_size	`Vector2( 64, 64 )`
TileOrigin	cell_tile_origin	`0`
bool	cell_y_sort	`false`
bool	centered_textures	`false`
float	collision_bounce	`0.0`
float	collision_friction	`1.0`
int	collision_layer	`1`
int	collision_mask	`1`
bool	collision_use_kinematic	`false`
bool	collision_use_parent	`false`
bool	compatibility_mode	`false`
Mode	mode	`0`
int	navigation_layers	`1`
int	occluder_light_mask	`1`
bool	show_collision	`false`
TileSet	tile_set

Methods¶

void	clear ( )
void	fix_invalid_tiles ( )
int	get_cell ( int x, int y ) const
Vector2	get_cell_autotile_coord ( int x, int y ) const
int	get_cellv ( Vector2 position ) const
bool	get_collision_layer_bit ( int bit ) const
bool	get_collision_mask_bit ( int bit ) const
Array	get_used_cells ( ) const
Array	get_used_cells_by_id ( int id ) const
Rect2	get_used_rect ( )
bool	is_cell_transposed ( int x, int y ) const
bool	is_cell_x_flipped ( int x, int y ) const
bool	is_cell_y_flipped ( int x, int y ) const
Vector2	map_to_world ( Vector2 map_position, bool ignore_half_ofs=false ) const
void	set_cell ( int x, int y, int tile, bool flip_x=false, bool flip_y=false, bool transpose=false, Vector2 autotile_coord=Vector2( 0, 0 ) )
void	set_cellv ( Vector2 position, int tile, bool flip_x=false, bool flip_y=false, bool transpose=false, Vector2 autotile_coord=Vector2( 0, 0 ) )
void	set_collision_layer_bit ( int bit, bool value )
void	set_collision_mask_bit ( int bit, bool value )
void	update_bitmask_area ( Vector2 position )
void	update_bitmask_region ( Vector2 start=Vector2( 0, 0 ), Vector2 end=Vector2( 0, 0 ) )
void	update_dirty_quadrants ( )
Vector2	world_to_map ( Vector2 world_position ) const

Signals¶

settings_changed ( )

Emitted when a tilemap setting has changed.

Enumerations¶

enum Mode:

Mode MODE_SQUARE = 0

Orthogonal orientation mode.

Mode MODE_ISOMETRIC = 1

Isometric orientation mode.

Mode MODE_CUSTOM = 2

Custom orientation mode.

enum HalfOffset:

HalfOffset HALF_OFFSET_X = 0

Half offset on the X coordinate.

HalfOffset HALF_OFFSET_Y = 1

Half offset on the Y coordinate.

HalfOffset HALF_OFFSET_DISABLED = 2

Half offset disabled.

HalfOffset HALF_OFFSET_NEGATIVE_X = 3

Half offset on the X coordinate (negative).

HalfOffset HALF_OFFSET_NEGATIVE_Y = 4

Half offset on the Y coordinate (negative).

enum TileOrigin:

TileOrigin TILE_ORIGIN_TOP_LEFT = 0

Tile origin at its top-left corner.

TileOrigin TILE_ORIGIN_CENTER = 1

Tile origin at its center.

TileOrigin TILE_ORIGIN_BOTTOM_LEFT = 2

Tile origin at its bottom-left corner.

Constants¶

INVALID_CELL = -1

Returned when a cell doesn't exist.

Property Descriptions¶

bool bake_navigation = false

void set_bake_navigation ( bool value )
bool is_baking_navigation ( )

If true, this TileMap bakes a navigation region.

bool cell_clip_uv = false

void set_clip_uv ( bool value )
bool get_clip_uv ( )

If true, the cell's UVs will be clipped.

Transform2D cell_custom_transform = Transform2D( 64, 0, 0, 64, 0, 0 )

void set_custom_transform ( Transform2D value )
Transform2D get_custom_transform ( )

The custom Transform2D to be applied to the TileMap's cells.

HalfOffset cell_half_offset = 2

void set_half_offset ( HalfOffset value )
HalfOffset get_half_offset ( )

Amount to offset alternating tiles. See HalfOffset for possible values.

int cell_quadrant_size = 16

void set_quadrant_size ( int value )
int get_quadrant_size ( )

The TileMap's quadrant size. Optimizes drawing by batching, using chunks of this size.

Vector2 cell_size = Vector2( 64, 64 )

void set_cell_size ( Vector2 value )
Vector2 get_cell_size ( )

The TileMap's cell size.

TileOrigin cell_tile_origin = 0

void set_tile_origin ( TileOrigin value )
TileOrigin get_tile_origin ( )

Position for tile origin. See TileOrigin for possible values.

bool cell_y_sort = false

void set_y_sort_mode ( bool value )
bool is_y_sort_mode_enabled ( )

If true, the TileMap's direct children will be drawn in order of their Y coordinate.

bool centered_textures = false

void set_centered_textures ( bool value )
bool is_centered_textures_enabled ( )

If true, the textures will be centered in the middle of each tile. This is useful for certain isometric or top-down modes when textures are made larger or smaller than the tiles (e.g. to avoid flickering on tile edges). The offset is still applied, but from the center of the tile. If used, compatibility_mode is ignored.

If false, the texture position start in the top-left corner unless compatibility_mode is enabled.

float collision_bounce = 0.0

void set_collision_bounce ( float value )
float get_collision_bounce ( )

Bounce value for static body collisions (see collision_use_kinematic).

float collision_friction = 1.0

void set_collision_friction ( float value )
float get_collision_friction ( )

Friction value for static body collisions (see collision_use_kinematic).

int collision_layer = 1

void set_collision_layer ( int value )
int get_collision_layer ( )

The collision layer(s) for all colliders in the TileMap. See Collision layers and masks in the documentation for more information.

int collision_mask = 1

void set_collision_mask ( int value )
int get_collision_mask ( )

The collision mask(s) for all colliders in the TileMap. See Collision layers and masks in the documentation for more information.

bool collision_use_kinematic = false

void set_collision_use_kinematic ( bool value )
bool get_collision_use_kinematic ( )

If true, TileMap collisions will be handled as a kinematic body. If false, collisions will be handled as static body.

bool collision_use_parent = false

void set_collision_use_parent ( bool value )
bool get_collision_use_parent ( )

If true, this tilemap's collision shape will be added to the collision shape of the parent. The parent has to be a CollisionObject2D.

bool compatibility_mode = false

void set_compatibility_mode ( bool value )
bool is_compatibility_mode_enabled ( )

If true, the compatibility with the tilemaps made in Redot 3.1 or earlier is maintained (textures move when the tile origin changes and rotate if the texture size is not homogeneous). This mode presents problems when doing flip_h, flip_v and transpose tile operations on non-homogeneous isometric tiles (e.g. 2:1), in which the texture could not coincide with the collision, thus it is not recommended for isometric or non-square tiles.

If false, the textures do not move when doing flip_h, flip_v operations if no offset is used, nor when changing the tile origin.

The compatibility mode doesn't work with the centered_textures option, because displacing textures with the cell_tile_origin option or in irregular tiles is not relevant when centering those textures.

Mode mode = 0

void set_mode ( Mode value )
Mode get_mode ( )

The TileMap orientation mode. See Mode for possible values.

int navigation_layers = 1

void set_navigation_layers ( int value )
int get_navigation_layers ( )

The navigation layers the TileMap generates its navigation regions in.

int occluder_light_mask = 1

void set_occluder_light_mask ( int value )
int get_occluder_light_mask ( )

The light mask assigned to all light occluders in the TileMap. The TileSet's light occluders will cast shadows only from Light2D(s) that have the same light mask(s).

bool show_collision = false

void set_show_collision ( bool value )
bool is_show_collision_enabled ( )

If true, collision shapes are visible in the editor. Doesn't affect collision shapes visibility at runtime. To show collision shapes at runtime, enable Visible Collision Shapes in the Debug menu instead.

TileSet tile_set

void set_tileset ( TileSet value )
TileSet get_tileset ( )

The assigned TileSet.

Method Descriptions¶

void clear ( )

Clears all cells.

void fix_invalid_tiles ( )

Clears cells that do not exist in the tileset.

int get_cell ( int x, int y ) const

Returns the tile index of the given cell. If no tile exists in the cell, returns INVALID_CELL.

Vector2 get_cell_autotile_coord ( int x, int y ) const

Returns the coordinate (subtile column and row) of the autotile variation in the tileset. Returns a zero vector if the cell doesn't have autotiling.

int get_cellv ( Vector2 position ) const

Returns the tile index of the cell given by a Vector2. If no tile exists in the cell, returns INVALID_CELL.

bool get_collision_layer_bit ( int bit ) const

Returns true if the given collision layer bit is set.

bool get_collision_mask_bit ( int bit ) const

Returns true if the given collision mask bit is set.

Array get_used_cells ( ) const

Returns a Vector2 array with the positions of all cells containing a tile from the tileset (i.e. a tile index different from -1).

Array get_used_cells_by_id ( int id ) const

Returns an array of all cells with the given tile index specified in id.

Rect2 get_used_rect ( )

Returns a rectangle enclosing the used (non-empty) tiles of the map.

bool is_cell_transposed ( int x, int y ) const

Returns true if the given cell is transposed, i.e. the X and Y axes are swapped.

bool is_cell_x_flipped ( int x, int y ) const

Returns true if the given cell is flipped in the X axis.

bool is_cell_y_flipped ( int x, int y ) const

Returns true if the given cell is flipped in the Y axis.

Vector2 map_to_world ( Vector2 map_position, bool ignore_half_ofs=false ) const

Returns the local position of the top left corner of the cell corresponding to the given tilemap (grid-based) coordinates.

To get the global position, use Node2D.to_global:

var local_position = my_tilemap.map_to_world(map_position)
var global_position = my_tilemap.to_global(local_position)

Optionally, the tilemap's half offset can be ignored.

void set_cell ( int x, int y, int tile, bool flip_x=false, bool flip_y=false, bool transpose=false, Vector2 autotile_coord=Vector2( 0, 0 ) )

Sets the tile index for the given cell.

An index of -1 clears the cell.

Optionally, the tile can also be flipped, transposed, or given autotile coordinates. The autotile coordinate refers to the column and row of the subtile.

Note: Data such as navigation polygons and collision shapes are not immediately updated for performance reasons.

If you need these to be immediately updated, you can call update_dirty_quadrants.

Overriding this method also overrides it internally, allowing custom logic to be implemented when tiles are placed/removed:

func set_cell(x, y, tile, flip_x=false, flip_y=false, transpose=false, autotile_coord=Vector2()):
    # Write your custom logic here.
    # To call the default method:
    .set_cell(x, y, tile, flip_x, flip_y, transpose, autotile_coord)

void set_cellv ( Vector2 position, int tile, bool flip_x=false, bool flip_y=false, bool transpose=false, Vector2 autotile_coord=Vector2( 0, 0 ) )

Sets the tile index for the cell given by a Vector2.

An index of -1 clears the cell.

Optionally, the tile can also be flipped, transposed, or given autotile coordinates. The autotile coordinate refers to the column and row of the subtile.

Note: Data such as navigation polygons and collision shapes are not immediately updated for performance reasons.

If you need these to be immediately updated, you can call update_dirty_quadrants.

void set_collision_layer_bit ( int bit, bool value )

Sets the given collision layer bit.

void set_collision_mask_bit ( int bit, bool value )

Sets the given collision mask bit.

void update_bitmask_area ( Vector2 position )

Applies autotiling rules to the cell (and its adjacent cells) referenced by its grid-based X and Y coordinates.

void update_bitmask_region ( Vector2 start=Vector2( 0, 0 ), Vector2 end=Vector2( 0, 0 ) )

Applies autotiling rules to the cells in the given region (specified by grid-based X and Y coordinates).

Calling with invalid (or missing) parameters applies autotiling rules for the entire tilemap.

void update_dirty_quadrants ( )

Updates the tile map's quadrants, allowing things such as navigation and collision shapes to be immediately used if modified.

Vector2 world_to_map ( Vector2 world_position ) const

Returns the tilemap (grid-based) coordinates corresponding to the given local position.

To use this with a global position, first determine the local position with Node2D.to_local:

var local_position = my_tilemap.to_local(global_position)
var map_position = my_tilemap.world_to_map(local_position)