Introducción a los Tilemaps (mosaicos)

Estrategias de capas: Estructura, Decoración y Profundidad

Un error común al iniciarse en el diseño de niveles consiste en intentar pintar todo el entorno en una única capa de Tilemap. Esto genera problemas visuales evidentes: si quieres colocar enredaderas o raíces colgando de un bloque de roca, o flores y piedras pequeñas sobre el césped, colocar la flor en la misma celda sobrescribirá y borrará el bloque de césped inferior, ya que una celda en una capa de Tilemap solo puede contener un único índice numérico a la vez.

La solución profesional consiste en estructurar el nivel mediante capas superpuestas de Tilemaps, cada una con un propósito bien definido y con un orden de profundidad (Depth) coherente:

1. Capa `Tiles_Fondo_Estructural`: Ubicada detrás de los personajes y de las plataformas sólidas. En ella se pintan paredes interiores de cuevas sombrías, ventanas hacia el exterior, vigas de madera de soporte o ruinas lejanas. Estas baldosas suelen diseñarse con colores menos saturados o tonos más oscuros para no competir visualmente con los elementos interactivos. 2. Capa `Tiles_Terreno`: Es la capa principal donde descansan las plataformas sólidas, suelos, techos y paredes verticales con las que interactúa el juego. 3. Capa `Tiles_Decoracion`: Situada justo por encima de `Tiles_Terreno`. En esta capa se pintan matas de hierba adicionales, flores, piedras sueltas, carteles y elementos que enriquecen el aspecto visual sin romper la estructura de las plataformas base. 4. Capa `Tiles_Primer_Plano` (Foreground): Ubicada por encima de la capa `Instances`. Se utiliza con moderación para colocar ramas de árboles gigantes que cruzan por el frente de la pantalla, bordes de cavernas en penumbra o columnas que tapan temporalmente al jugador al pasar detrás de ellas, aportando una notable sensación de profundidad tridimensional a un entorno 2D.

Manipulación de Tilemaps mediante GML Code

Aunque la mayor parte del diseño de escenarios se realiza de forma visual en el Room Editor, en GameMaker los Tilemaps son estructuras dinámicas que podemos consultar, leer y modificar en tiempo real durante la ejecución de la partida mediante GameMaker Language (GML). Para los desarrolladores que prefieran o conozcan GML Visual, existen bloques de acción equivalentes bajo la categoría 'Tiles' (como 'Get Tile' o 'Set Tile'); sin embargo, comprender las funciones en código puro proporciona una precisión y velocidad insustituibles.

Para interactuar con una capa de mosaicos por código, primero debemos obtener el identificador de la capa en la sala mediante `layer_get_id()`, y luego obtener el identificador específico del elemento Tilemap contenido en dicha capa mediante `layer_tilemap_get_id()`. Una vez obtenido dicho identificador, podemos alterar o consultar cualquier celda del escenario.

Examinemos las funciones esenciales que constituyen los cimientos para la lectura y modificación programática del terreno:

A continuación, implementaremos un ejemplo práctico y contextualizado. Crearemos un objeto controlador llamado `obj_terreno_controller` que se encargará de gestionar el acceso al Tilemap y permitirá un comportamiento dinámico común en los juegos de plataformas: destruir una baldosa de terreno agrietado cuando el jugador hace clic sobre ella con el ratón (o cuando ocurre un impacto), modificando el mapa en memoria de forma instantánea.

En el Asset Browser, crea un objeto y nómbralo `obj_terreno_controller`. En su evento **Create**, inicializamos las variables y capturamos las referencias a la capa gráfica:

// --------------------------------------------------------
// Objeto: obj_terreno_controller
// Evento: Create
// Descripción: Localiza la capa de terreno y guarda el ID del tilemap
// --------------------------------------------------------

// 1. Obtenemos el identificador de la capa creada en el Room Editor
var _layer_id = layer_get_id("Tiles_Terreno");

// 2. Extraemos el identificador del tilemap contenido en esa capa
mapa_terreno = layer_tilemap_get_id(_layer_id);

// Comprobación de seguridad en la consola de depuración
if (mapa_terreno == -1) {
    show_debug_message("ERROR: No se encontró la capa Tiles_Terreno o no contiene un Tilemap válido.");
} else {
    show_debug_message("Tilemap conectado exitosamente. ID: " + string(mapa_terreno));
}

Ahora, en el evento **Step** de este mismo objeto controlador, implementaremos una rutina interactiva simple: si el jugador presiona el botón izquierdo del ratón (`mb_left`), el sistema leerá qué baldosa hay bajo el cursor. Si existe un mosaico dibujado (índice mayor a 0), lo borrará inmediatamente estableciendo su índice a 0 (la casilla vacía):

// --------------------------------------------------------
// Objeto: obj_terreno_controller
// Evento: Step
// Descripción: Detección y destrucción de celdas bajo el puntero
// --------------------------------------------------------

// Solo actuar si el tilemap está correctamente inicializado
if (mapa_terreno != -1) {
    // Si el usuario presiona el botón izquierdo del ratón
    if (mouse_check_button_pressed(mb_left)) {
        // Leemos el índice del mosaico en la posición exacta del cursor en la sala
        var _tile_actual = tilemap_get_at_pixel(mapa_terreno, mouse_x, mouse_y);
        
        // Un índice mayor a 0 confirma la presencia de un tile sólido o visible
        if (_tile_actual > 0) {
            show_debug_message("Tile eliminado. Índice previo: " + string(_tile_actual));
            
            // Asignamos el índice 0 para borrar la celda seleccionada
            tilemap_set_at_pixel(mapa_terreno, 0, mouse_x, mouse_y);
        }
    }
}

Coloca una única instancia de `obj_terreno_controller` en la capa `Instances` de tu sala y ejecuta el juego (presionando F5). Al hacer clic sobre cualquier sección de suelo construida con el Tile Set, comprobarás que el bloque desaparece al instante. Este mecanismo no solo ilustra el funcionamiento interno de las funciones de Tilemap, sino que constituye la base para implementar paredes rompibles, túneles secretos excavables y modificación dinámica del entorno durante el juego.

Mapeo lógico de datos y preparación para las colisiones

Es fundamental tener presente que, en esta etapa, el Tilemap es puramente un elemento de representación gráfica. Si ejecutas el juego con tu personaje del Módulo 5 (`obj_jugador`) sobre una plataforma pintada exclusivamente con mosaicos, notarás que el personaje atravesará el suelo y caerá al vacío por la gravedad.

Esto ocurre porque nuestro código de colisiones del Módulo 5 estaba programado para verificar colisiones físicas contra objetos (`place_meeting(x + vel_x, y, obj_bloque)`). Al sustituir los miles de `obj_bloque` por un Tilemap, ya no existen instancias sólidas con las cuales colisionar bajo ese método tradicional.

En la siguiente lección abordaremos en profundidad el sistema de 'Colisiones precisas con Tilemaps', donde adaptaremos los scripts de movimiento del jugador para que interroguen directamente a las celdas matemáticas del Tilemap utilizando la función `tilemap_get_at_pixel()`. De este modo, mantendremos la física de plataformas sólida, responsiva y perfecta sin necesidad de colocar un solo objeto de colisión en la sala.

Buenas prácticas para el diseño con Tile Sets

A medida que los escenarios de tu videojuego se vuelvan más extensos y visualmente ricos, mantener el orden en los recursos gráficos será la clave para no perder tiempo rehaciendo trabajo. Ten en cuenta las siguientes recomendaciones profesionales:

1. Mantén un tamaño de cuadrícula unificado en todo el proyecto: Si tus personajes y mecánicas se diseñaron para un paso de 16x16 píxeles, diseña todos tus tilesets a 16x16. Mezclar baldosas de 16x16 con otras de 24x24 o 32x32 en el mismo plano genera discontinuidades visuales y descalibra los cálculos matemáticos de colisión.

2. Diseña siempre las piezas de unión (9-Slice modular): Para cualquier bioma (tierra, roca, metal), asegúrate de dibujar el conjunto canónico de 9 piezas mínimas: 4 esquinas exteriores, 4 paredes/bordes exteriores y 1 centro sólido. Esto te permitirá construir cualquier forma geométrica rectangular o plataforma sin dejar bordes cortados de manera antiestética.

3. Nomenclatura rigurosa de capas: Utiliza nombres estándar en todas las salas de tu juego (por ejemplo, `Tiles_Fondo`, `Tiles_Terreno`, `Tiles_Decoracion`). Cuando desarrollemos sistemas en GML que busquen capas por su nombre en cadena de texto (`layer_get_id("Tiles_Terreno")`), cualquier variación o error tipográfico en una sala (`Tiles_Piso`, `Terreno_1`) provocará que el código falle o no encuentre la superficie sólida.

Ejercicios prácticos

Realiza los siguientes tres ejercicios para consolidar la creación, diseño e inspección de mapas de mosaicos en tu proyecto:

**Ejercicio 1: Creación del recurso Tile Set con respeto a la celda cero** Crea un sprite llamado `spr_tileset_castillo` con dimensiones de 64x64 píxeles subdividido en celdas de 16x16 (una matriz de 4 columnas por 4 filas). Deja la celda superior izquierda (columna 0, fila 0) completamente transparente. Dibuja en las casillas contiguas bloques de ladrillo de piedra: un ladrillo con borde superior, un ladrillo con borde lateral y un ladrillo de relleno interior. Posteriormente crea el recurso Tile Set `tls_castillo`, asígnale el sprite y verifica que los tamaños de celda estén configurados exactamente en 16x16 píxeles. *Criterio de comprobación:* Al abrir `tls_castillo`, la primera casilla visible en la esquina superior izquierda debe tener el número 0 y fondo transparente; las demás piezas deben estar perfectamente encuadradas dentro de las líneas de la cuadrícula sin recortes ni desfases visuales.

**Ejercicio 2: Construcción de un escenario estructurado en capas** Abre la sala `rm_nivel_1`. Elimina o desactiva las instancias masivas de `obj_bloque` que servían de prueba inicial. Crea tres capas de mosaicos con los siguientes nombres: `Tiles_Fondo`, `Tiles_Terreno` y `Tiles_Decoracion`. Ordena las capas respetando la jerarquía visual frente a la capa `Instances`. Pinta un nivel que contenga al menos dos plataformas elevadas, una escalera de terreno y una cavidad subterránea con fondo estructural cerrado. *Criterio de comprobación:* En el Room Editor debes poder ocultar individualmente la capa `Tiles_Decoracion` o `Tiles_Fondo` (haciendo clic en el icono del ojo en la lista de capas) y ver cómo el escenario mantiene su estructura intacta sin que las texturas se pisen o borren entre sí.

**Ejercicio 3: Lector de información de celdas por depuración en GML** Amplía el código del evento Step de `obj_terreno_controller` para que, además de borrar baldosas con el clic izquierdo, al presionar la barra espaciadora (`keyboard_check_pressed(vk_space)`) lea la posición del jugador (`obj_jugador.x`, `obj_jugador.y`) e imprima en la consola de depuración mediante `show_debug_message()` el índice de la baldosa y las coordenadas de celda (columna y fila) que se encuentran exactamente debajo de los pies del jugador. *Criterio de comprobación:* Ejecuta el juego, mueve el personaje sobre diferentes sectores del nivel y presiona espacio. En la ventana de salida de GameMaker (Output) deben imprimirse mensajes legibles indicando la columna, fila e índice del tile detectado bajo el jugador.