class Eagle::TileMap

Overview

A grid of tiles drawn from a tileset, for levels, backgrounds and dungeon maps.

Each cell holds a tile id, an index into the tileset read left to right and top to bottom, or -1 for empty. Drawing is culled to the camera, so large maps stay cheap.

tiles = Texture.new(Image.checkerboard(64, 16, 16))
map = TileMap.new(tiles, 16, 16)
map.load_layout(<<-MAP)
  0 0 0 0
  1 . . 1
  2 2 2 2
  MAP
map[1, 1] = 3                             # set one cell
cx, cy = map.world_to_cell(Input.mouse)   # which tile is under the mouse?
solid = map[cx, cy] >= 0

TileMap only draws. For collisions, add StaticBody2D boxes for solid cells, as the platformer example does.

Defined in:

eagle/nodes/tilemap.cr

Constructors

Instance Method Summary

Instance methods inherited from class Eagle::Node2D

direction_to(other : Node2D) : Vec2 direction_to, distance_to(other : Node2D) : Float32 distance_to, down : Vec2 down, forward : Vec2 forward, global_position : Vec2 global_position, global_position=(p : Vec2) global_position=, global_rotation : Float32 global_rotation, global_scale : Vec2 global_scale, global_transform : Transform2D global_transform, look_at(target : Vec2) : Nil look_at, modulate : Color modulate, modulate=(modulate : Color) modulate=, parent_2d : Node2D | Nil parent_2d, position : Vec2 position, position=(p : Vec2) position=, right : Vec2 right, rotate(rad : Number) : Nil rotate, rotation : Float32 rotation, rotation=(rotation : Float32) rotation=, rotation_degrees : Float32 rotation_degrees, rotation_degrees=(d : Number) rotation_degrees=, scale : Vec2 scale, scale=(s : Vec2)
scale=(s : Number) scale=, to_global(local : Vec2) : Vec2 to_global, to_local(global : Vec2) : Vec2 to_local, top_level=(top_level : Bool) top_level=, top_level? : Bool top_level?, transform : Transform2D transform, transform=(t : Transform2D) transform=, translate(x : Number, y : Number) : Nil
translate(v : Vec2) : Nil translate, x : Float32 x, x=(v : Number) x=, y : Float32 y, y=(v : Number) y=

Constructor methods inherited from class Eagle::Node2D

new(name : String = "", position : Eagle::Vec2 = Vec2::ZERO, rotation : Float32 = 0_f32, scale : Eagle::Vec2 = Vec2::ONE) new

Instance methods inherited from class Eagle::Node

<<(child : Node) : self <<, [](path : String) : Node [], []?(path : String) : Node | Nil []?, add(child : Node) : Node
add(*children : Node) : Nil add, add_child(child : Node) : Node add_child, add_to_group(group : String) : self add_to_group, ancestor_of?(node : Node) : Bool ancestor_of?, can_process? : Bool can_process?, child?(name : String) : Node | Nil child?, child_added : Eagle::Emitter(Node) child_added, child_count : Int32 child_count, child_removed : Eagle::Emitter(Node) child_removed, children : Array(Eagle::Node) children, children_of(type : T.class) : Array(T) forall T children_of, clear_children : Nil clear_children, draw(g : Graphics) : Nil draw, dump(io : IO = STDOUT, indent = 0) : Nil dump, each_ancestor(& : Node -> ) : Nil each_ancestor, each_child(& : Node -> ) : Nil each_child, each_descendant(&block : Node -> ) : Nil each_descendant, emit_child_added(*args) : Nil emit_child_added, emit_child_removed(*args) : Nil emit_child_removed, emit_tree_entered(*args) : Nil emit_tree_entered, emit_tree_exited(*args) : Nil emit_tree_exited, enter_tree : Nil enter_tree, exit_tree : Nil exit_tree, find(name : String) : Node | Nil find, find_all(type : T.class) : Array(T) forall T find_all, first_child : Node | Nil first_child, free : Nil free, get_node(path : String, type : T.class) : T forall T
get_node(path : String) : Node get_node, get_node?(path : String) : Node | Nil get_node?, groups : Set(String) groups, in_group?(group : String) : Bool in_group?, in_tree? : Bool in_tree?, input(event : Event) : Nil input, name : String name, name=(name : String) name=, on_child_added(&block : Node -> Nil) : Proc(Node, Nil) on_child_added, on_child_removed(&block : Node -> Nil) : Proc(Node, Nil) on_child_removed, on_tree_entered(&block : -> Nil) : Proc(Nil) on_tree_entered, on_tree_exited(&block : -> Nil) : Proc(Nil) on_tree_exited, parent : Node | Nil parent, path : String path, physics_process(dt : Float32) : Nil physics_process, process(dt : Float32) : Nil process, process_mode : Eagle::Node::ProcessMode process_mode, process_mode=(process_mode : Eagle::Node::ProcessMode) process_mode=, queue_free : Nil queue_free, queued_free? : Bool queued_free?, ready : Nil ready, ready_called? : Bool ready_called?, remove(child : Node) : Nil remove, remove_child(child : Node) : Nil remove_child, remove_from_group(group : String) : Nil remove_from_group, remove_from_parent : Nil remove_from_parent, resized(width : Int32, height : Int32) : Nil resized, root : Node root, to_s(io : IO) : Nil to_s, tree_entered : Eagle::Emitter() tree_entered, tree_exited : Eagle::Emitter() tree_exited, visible=(visible : Bool) visible=, visible? : Bool visible?, z_index : Int32 z_index, z_index=(z_index : Int32) z_index=

Constructor methods inherited from class Eagle::Node

new(name : String = "") new

Constructor Detail

def self.new(tileset : Texture, tile_width : Int32, tile_height : Int32, name : String = "", spacing : Int32 = 0) #

Creates a map from a tileset cut into tile_width x tile_height tiles, with spacing pixels between tiles in the texture.


Instance Method Detail

def [](x : Int32, y : Int32) : Int32 #

Short form of #get_cell.


def []=(x : Int32, y : Int32, id : Int32) #

Short form of #set_cell.


def cell_count : Int32 #

Number of non-empty cells.


def cell_rect(x : Int32, y : Int32) : Rect #

A cell's area in local space.


def cell_to_world(x : Int32, y : Int32) : Vec2 #

The world-space position of a cell's top-left corner.


def clear : Nil #

Removes every tile.


def color : Color #

Tint applied to every tile.


def color=(color : Color) #

Tint applied to every tile.


def draw(g : Graphics) : Nil #

Draws the visible tiles.


def get_cell(x : Int32, y : Int32) : Int32 #

The tile at column x, row y, or -1 when empty.


def height : Int32 #

Number of rows in use.


def load_layout(text : String) : self #

Fills the map from text: one row per line, whitespace-separated tile ids, with . or a negative number for empty. Returns self.


def set_cell(x : Int32, y : Int32, id : Int32) : Nil #

Sets the tile at column x, row y. Use -1 to clear it.


def tile_count : Int32 #

Number of tiles in the tileset.


def tile_height : Int32 #

Tile height in pixels.


def tile_size : Vec2 #

(tile_width, tile_height).


def tile_width : Int32 #

Tile width in pixels.


def tileset : Texture #

The texture tiles are cut from.


def used_cells : Array(Tuple(Int32, Int32)) #

Coordinates of every non-empty cell.


def width : Int32 #

Number of columns in use.


def world_to_cell(global : Vec2) : Tuple(Int32, Int32) #

The cell containing a world-space point.