Creación de coleccionables (monedas y gemas)

Introducción al diseño de coleccionables

Los coleccionables son uno de los componentes más versátiles y fundamentales en el diseño de videojuegos de plataformas 2D. No constituyen únicamente una recompensa matemática para el jugador en forma de números ascendentes, sino que cumplen funciones críticas de diseño de niveles (level design): actúan como guías visuales (conocidas como 'migas de pan' o breadcrumbs) que enseñan al jugador hacia dónde debe avanzar, señalan el camino óptimo para realizar un salto difícil y recompensan la curiosidad al explorar rutas secretas o áreas de alto riesgo.

En esta clase ampliaremos el proyecto del juego de plataformas retro que venimos construyendo a lo largo del curso. Hasta este momento disponemos de un personaje con movimiento físico, detección de suelo, saltos ajustados, un enemigo patrullero y un sistema de salud con vidas. Ahora añadiremos dos tipos esenciales de coleccionables:

1. Monedas (Coins): Elementos comunes, distribuidos en secuencias o arcos a lo largo del nivel. Tienen un valor modesto (10 puntos) y su propósito es trazar trayectorias de movimiento e incentivar la fluidez mecánica del jugador. 2. Gemas (Gems): Elementos raros o especiales, colocados en zonas elevadas, escondites o protegidos por enemigos. Tienen un valor superior (50 o 100 puntos) y representan un logro o reto opcional para el jugador completista.

Para evitar repetir código y construir un proyecto desordenado, implementaremos una arquitectura orientada a objetos mediante la jerarquía de herencia (parenting) de GameMaker. Esto nos permitirá crear una plantilla base con todo el comportamiento común de recolección y luego ramificar fácilmente decenas de objetos distintos sin duplicar una sola línea de lógica.

Creación y configuración de recursos gráficos (Sprites)

Antes de programar la recolección, necesitamos configurar los recursos visuales en el Asset Browser. Crearemos dos sprites con estética de píxel retro: una moneda giratoria o brillante y una gema flotante.

Para crear el sprite de la moneda, haz clic derecho sobre la carpeta 'Sprites' en el Asset Browser y selecciona 'Create -> Sprite'. Nómbralo 'spr_coin'. Si diseñas un sprite en el editor interno de GameMaker, establece unas dimensiones de 16x16 píxeles (o 24x24 según la escala visual elegida en tu proyecto). Puedes dibujar una pequeña elipse dorada de 4 a 6 fotogramas simulando el giro horizontal sobre su propio eje. Si prefieres un elemento estático, un único fotograma con un brillo sutil también funcionará a la perfección.

Repite el procedimiento para la gema: crea un sprite denominado 'spr_gem', de 16x16 píxeles, con forma de rombo o cristal en tonos esmeralda, rubí o zafiro.

💡 Punto de origen crítico: A diferencia de los bloques de suelo (cuyo origen suele situarse en Top-Left para alinearse a la cuadrícula) o del jugador (cuyo origen suele situarse en Bottom-Centre para apoyarse correctamente sobre el suelo), para los coleccionables se recomienda configurar el origen en 'Middle Centre' (Centro Medio). Esto garantiza que cualquier efecto de rotación, escalado al recogerse o animación matemática de oscilación ocurra alrededor del centro geométrico del objeto sin desplazarse de su eje original.

Respecto a la máscara de colisión (Collision Mask), asegúrate de que sea cómoda para el jugador. En los juegos de plataformas resulta frustrante pasar extremadamente cerca de una moneda sin llegar a recogerla. En la sección 'Collision Mask' de ambos sprites, selecciona la forma 'Rectangle' o 'Ellipse' y expande ligeramente los bordes para que la recolección sea indulgente y satisfactoria.

Arquitectura de herencia: Creación del objeto padre

Imagina que en el futuro tu videojuego incorpora llaves, pociones de salud, vidas extra, diamantes de colores y pergaminos. Si programaras la colisión con el jugador de forma individual dentro de cada objeto, cualquier ajuste a la lógica requeriría modificar decenas de eventos idénticos. Aquí es donde brilla el sistema de herencia de GameMaker.

Crearemos un objeto base llamado 'obj_parent_collectible'. Este objeto actuará como plantilla abstracta: albergará toda la lógica común de detección, animación flotante y recolección. Posteriormente crearemos los objetos hijos 'obj_coin' y 'obj_gem', los cuales heredarán todas las propiedades del padre y solo redefinirán variables específicas como el sprite y el valor numérico de la puntuación.

Para crear este sistema en GameMaker, sigue estos pasos estructurados:

1. Haz clic derecho en el Asset Browser sobre la carpeta 'Objects' y selecciona 'Create -> Object'. Nómbralo 'obj_parent_collectible'. No le asignes ningún sprite, ya que servirá exclusivamente de contenedor lógico.

2. Crea un segundo objeto llamado 'obj_coin'. Asígnale el sprite 'spr_coin'. En el panel de propiedades del objeto, busca la sección 'Parent', haz clic sobre ella y selecciona 'obj_parent_collectible' como su objeto padre.

3. Crea un tercer objeto llamado 'obj_gem'. Asígnale el sprite 'spr_gem'. De igual manera, asígnale como 'Parent' a 'obj_parent_collectible'.

Programación del objeto base: Variables y animación sinusoidal

Un detalle visual característico de los videojuegos clásicos es que los coleccionables parecen levitar suavemente en el aire. En lugar de dibujar una animación cuadro por cuadro para lograr esto, podemos emplear una sencilla función trigonométrica en GML Code. El uso del seno matemático genera una oscilación armónica periódica entre -1 y 1, lo que produce un movimiento suave y continuo sin necesidad de físicas complejas.

Abre el objeto 'obj_parent_collectible' y añade un evento 'Create'. En este evento definiremos las variables que gobernarán el valor del objeto y los parámetros de su animación:

/// @description Inicialización del objeto recolectable base

// Valor en puntos que otorgará este coleccionable por defecto
valor_puntos = 10;

// Variables de animación de levitación (oscilación armónica)
y_base = y;               // Almacena la posición Y original en la habitación
tiempo_oscilacion = 0;    // Contador interno para el ángulo matemático
velocidad_flotacion = 0.05; // Velocidad del ciclo de oscilación
amplitud_flotacion = 4;   // Cantidad máxima de píxeles que sube y baja

A continuación, añade el evento 'Step' a 'obj_parent_collectible'. En cada fotograma del juego, incrementaremos el contador de tiempo y recalcularemos la posición vertical del objeto utilizando la función trigonométrica 'sin()':

/// @description Animación continua y lógica de recolección

// 1. Animación suave de flotación
tiempo_oscilacion += velocidad_flotacion;
y = y_base + (sin(tiempo_oscilacion) * amplitud_flotacion);

// 2. Comprobación de colisión con el jugador
if (place_meeting(x, y, obj_player))
{
    // Añadir el puntaje a la variable global correspondiente
    global.puntos += valor_puntos;
    
    // Mensaje de comprobación en la consola de depuración
    show_debug_message("Item recogido! Valor: +" + string(valor_puntos) + " | Total: " + string(global.puntos));
    
    // Destruir esta instancia tras ser recogida
    instance_destroy();
}

Analicemos con detalle lo que ocurre en este código. La función 'sin(tiempo_oscilacion)' devuelve un valor decimal entre -1.0 y 1.0. Al multiplicarlo por 'amplitud_flotacion' (4 en nuestro ejemplo), el resultado varía fluidamente entre -4 y +4 píxeles. Sumar este valor a 'y_base' produce una oscilación natural, independiente de si el sprite tiene o no fotogramas de animación interna.

Posteriormente, la instrucción 'place_meeting(x, y, obj_player)' verifica si la máscara de colisión de este coleccionable se superpone con la instancia activa de 'obj_player'. Si el jugador lo toca, se incrementa la puntuación global y se destruye la instancia del coleccionable con 'instance_destroy()', liberándola inmediatamente de la memoria del motor.

Personalización de los objetos hijos mediante event_inherited()

Ahora que la plantilla 'obj_parent_collectible' contiene toda la funcionalidad mecánica, los objetos hijos 'obj_coin' y 'obj_gem' ya funcionan automáticamente por herencia. Si colocaras 'obj_coin' en la sala sin escribir una sola línea de código adicional, el juego funcionaría y otorgaría 10 puntos.

Sin embargo, queremos que 'obj_gem' tenga un valor mucho más alto y una oscilación con diferente cadencia para distinguirse visualmente. ¿Cómo modificamos las variables de un hijo sin perder la lógica que definimos en el padre? La respuesta es la función fundamental 'event_inherited()'.

Abre el objeto 'obj_gem' y añade un evento 'Create'. Si añades un evento en un hijo, GameMaker por defecto sobrescribe por completo el evento del padre a menos que invoques explícitamente a su progenitor. Escribe el siguiente código:

/// @description Personalización de la Gema

// Ejecutar primero todo el código Create del padre (obj_parent_collectible)
event_inherited();

// Sobrescribir variables específicas para la gema
valor_puntos = 50;
velocidad_flotacion = 0.08; // Flota ligeramente más rápido
amplitud_flotacion = 6;    // Rango de oscilación vertical más amplio

Al llamar a 'event_inherited()', GameMaker inicializa primero 'y_base', 'tiempo_oscilacion' y el resto de variables esenciales. Inmediatamente después, redefinimos 'valor_puntos' asignándole 50 puntos y aumentamos la amplitud a 6 píxeles. De esta forma logramos un comportamiento único para la gema en apenas cuatro líneas de código, conservando intacta toda la lógica de colisión y destrucción.

💡 Regla de oro de la herencia: Siempre que definas un evento en un objeto hijo (como Create, Step o Destroy) y quieras conservar lo que hace el objeto padre, debes colocar 'event_inherited();' al inicio del bloque de código. Si lo omites, el código del padre no se ejecutará para ese evento específico.