Introduction to Tilemaps

Layering Strategies: Structure, Decoration, and Depth

A common beginner mistake in level design is attempting to paint the entire environment onto a single Tile Layer. This creates immediate visual conflicts: if you want to place hanging vines under a stone ledge, or small flowers and rocks on top of the grass, placing the flower in that cell overwrites and erases the underlying grass tile, since each cell in a Tile Layer can only store one index at a time.

The professional solution is to structure levels using multiple overlapping Tile Layers, each with a distinct role and consistent depth order:

1. `Tiles_Fondo_Estructural` (Background Structure): Sits behind characters and solid platforms. Use this layer to paint dim cave interiors, exterior windows, support beams, or distant ruins. These tiles are often drawn with lower saturation or darker tones so they do not compete visually with interactive gameplay elements. 2. `Tiles_Terreno` (Main Terrain): The primary layer holding the solid platforms, floors, ceilings, and walls that the gameplay relies upon. 3. `Tiles_Decoracion` (Decoration): Placed directly above `Tiles_Terreno`. Use this layer for grass tufts, flowers, loose stones, signs, and props that enrich the visuals without breaking the underlying platform structures. 4. `Tiles_Primer_Plano` (Foreground): Positioned above the `Instances` layer. Used sparingly for large foreground tree branches, shadowy cavern overhangs, or pillars that the player walks behind, adding a noticeable sense of depth to a 2D scene.

Manipulating Tilemaps via GML Code

While most level design takes place visually in the Room Editor, GameMaker Tilemaps are dynamic data structures that can be read, queried, and modified in real time during gameplay using GameMaker Language (GML). For developers who prefer GML Visual, equivalent action blocks exist under the 'Tiles' category (such as 'Get Tile' or 'Set Tile'); however, understanding the code functions provides precision and flexibility that are hard to beat.

To interact with a tile layer via code, we first retrieve the layer's ID using `layer_get_id()`, and then get the specific tilemap element ID hosted on that layer using `layer_tilemap_get_id()`. With that element ID in hand, we can inspect or alter any cell across the level.

Let's review the core functions used for reading and modifying terrain programmatically:

Now let's build a practical, contextualized example. We will create a controller object named `obj_terreno_controller` to manage tilemap access and implement a common platformer feature: destroying cracked ground blocks when clicked with the mouse (or upon impact), modifying the map in memory instantly.

In the Asset Browser, create an object named `obj_terreno_controller`. In its **Create** event, initialize variables and store the layer references:

// --------------------------------------------------------
// Object: obj_terreno_controller
// Event: Create
// Description: Locates the terrain layer and stores the tilemap ID
// --------------------------------------------------------

// 1. Get the ID of the layer created in the Room Editor
var _layer_id = layer_get_id("Tiles_Terreno");

// 2. Retrieve the ID of the tilemap element on that layer
mapa_terreno = layer_tilemap_get_id(_layer_id);

// Debug console safety check
if (mapa_terreno == -1) {
    show_debug_message("ERROR: Tiles_Terreno layer not found or contains no valid Tilemap.");
} else {
    show_debug_message("Tilemap successfully connected. ID: " + string(mapa_terreno));
}

Next, in the **Step** event of this controller object, implement an interactive routine: if the player clicks the left mouse button (`mb_left`), the system reads the tile under the cursor. If a tile is present (index greater than 0), it clears it immediately by setting its index to 0 (the empty cell):

// --------------------------------------------------------
// Object: obj_terreno_controller
// Event: Step
// Description: Detects and clears tiles under the mouse cursor
// --------------------------------------------------------

// Only execute if the tilemap was initialized properly
if (mapa_terreno != -1) {
    // Check if the player pressed the left mouse button
    if (mouse_check_button_pressed(mb_left)) {
        // Read the tile index at the cursor's exact room coordinates
        var _tile_actual = tilemap_get_at_pixel(mapa_terreno, mouse_x, mouse_y);
        
        // An index greater than 0 confirms a visible, solid tile is present
        if (_tile_actual > 0) {
            show_debug_message("Tile removed. Previous index: " + string(_tile_actual));
            
            // Set the index to 0 to erase the selected cell
            tilemap_set_at_pixel(mapa_terreno, 0, mouse_x, mouse_y);
        }
    }
}

Place a single instance of `obj_terreno_controller` onto the `Instances` layer of your room and run the game (by pressing F5). Clicking on any section of ground painted with your Tile Set will instantly erase that block. This mechanic illustrates how tilemap functions work under the hood and forms the basis for breakable walls, diggable tunnels, and real-time environment modification.

Logical Data Mapping and Collision Preparation

Keep in mind that at this stage, the tilemap is purely visual. If you run your game with the player character from Module 5 (`obj_jugador`) standing on a platform built purely with tiles, the character will fall straight through the ground due to gravity.

This happens because our collision system from Module 5 was built to check physical instances (`place_meeting(x + vel_x, y, obj_bloque)`). By replacing thousands of `obj_bloque` instances with a tilemap, there are no longer any solid objects in the room for that method to detect.

In the next lesson, we will cover 'Tilemap Collisions' in depth, updating our player movement code to query the mathematical cells of the tilemap directly using `tilemap_get_at_pixel()`. This will provide responsive, rock-solid platformer physics without needing a single collision object instance in the room.

Best Practices for Tile Set Design

As your game environments become larger and more visually detailed, keeping your art assets structured is essential for avoiding costly rework. Follow these industry best practices:

1. Maintain a consistent grid size throughout the project: If your characters and movement mechanics are tuned for a 16x16 grid, design all tilesets at 16x16. Mixing 16x16 tiles with 24x24 or 32x32 tiles within the same gameplay plane creates visual inconsistency and breaks collision math.

2. Always design standard modular connecting tiles (9-Slice): For any biome (dirt, stone, metal), be sure to draw at least the standard 9-piece set: 4 outer corners, 4 outer edges/walls, and 1 solid center fill. This allows you to build arbitrary rectangular platforms and shapes without leaving awkward unfinished edges.

3. Enforce strict layer naming conventions: Use identical layer names across all rooms (e.g., `Tiles_Fondo`, `Tiles_Terreno`, `Tiles_Decoracion`). When writing GML scripts that locate layers by string (`layer_get_id("Tiles_Terreno")`), any typo or variation between rooms (`Tiles_Piso`, `Terreno_1`) will cause the code to fail or miss solid ground entirely.

Hands-On Exercises

Complete these three exercises to master creating, designing, and inspecting tilemaps:

**Exercise 1: Creating a Tile Set Asset and Respecting Tile 0** Create a sprite named `spr_tileset_castillo` sized at 64x64 pixels and divided into 16x16 cells (a 4-column by 4-row matrix). Leave the top-left cell (column 0, row 0) completely transparent. In the neighboring cells, draw stone brick tiles: a brick with a top edge, a brick with a side edge, and an interior filler brick. Then create a Tile Set asset named `tls_castillo`, assign your sprite to it, and confirm the cell sizes are set to exactly 16x16 pixels. *Verification criteria:* When opening `tls_castillo`, the first cell in the top-left corner must display index 0 with a transparent background, and all other tiles must align perfectly within the grid lines without cutoffs or offset issues.

**Exercise 2: Building a Multi-Layered Level** Open `rm_nivel_1`. Remove or disable the massive rows of `obj_bloque` instances used in earlier prototypes. Create three tile layers named `Tiles_Fondo`, `Tiles_Terreno`, and `Tiles_Decoracion`. Arrange them to respect proper layer hierarchy relative to `Instances`. Paint a level containing at least two elevated platforms, a set of stepped terrain ledges, and an underground cavern with a solid structural background. *Verification criteria:* In the Room Editor, toggling the visibility of `Tiles_Decoracion` or `Tiles_Fondo` (via the eye icon in the layer list) should leave the main terrain structure intact without textures erasing or overlapping each other destructively.

**Exercise 3: Debugging Cell Data via GML** Extend the Step event in `obj_terreno_controller` so that, in addition to erasing tiles on left-click, pressing the Spacebar (`keyboard_check_pressed(vk_space)`) reads the player's position (`obj_jugador.x`, `obj_jugador.y`) and prints to the Output console via `show_debug_message()` the tile index and grid coordinates (column and row) directly beneath the player's feet. *Verification criteria:* Run the game, navigate the character across different terrain sections, and press Space. The GameMaker Output window should display clear debug messages stating the detected tile index, column, and row under the player.