Efectos de polvo al saltar y correr

Efectos de polvo al saltar y correr: Aportando peso y respuesta visual

Uno de los factores que separa un prototipo rígido de un videojuego satisfactorio al interactuar con el mando es lo que comúnmente se denomina «game feel» o respuesta visual y física. Cuando un personaje corre sobre un terreno de tierra o piedra, la ausencia de cualquier interacción física visible hace que parezca que flota o patina sobre el escenario. El polvo es el recurso visual por excelencia en los videojuegos de plataformas en dos dimensiones para anclar al personaje al entorno, transmitir peso, aceleración e inercia.

En la lección anterior aprendiste los conceptos fundamentales de los sistemas de partículas en GameMaker: el emisor, los tipos de partículas y la gestión del sistema para evitar fugas de memoria. En esta clase llevaremos esa teoría a la práctica activa, vinculando la generación de partículas con la máquina de estados y las variables de movimiento horizontal y vertical de nuestro personaje principal (`obj_player`), creadas a lo largo de los módulos de colisiones y movimiento.

¿Cuándo debe aparecer el polvo? Los tres momentos clave

Para que el polvo se sienta natural y aporte información al jugador en lugar de saturar la pantalla con ruido visual, debe responder a eventos mecánicos concretos dentro del bucle de juego. Existen tres momentos críticos en los que el polvo cumple una función expresiva indispensable:

1. **La carrera constante (Pasos):** Pequeñas motas de polvo o pequeñas nubes tenues que se desprenden intermitentemente de los talones del personaje mientras se desplaza por el suelo a velocidad considerable. 2. **El impulso de salto:** Un estallido concentrado hacia abajo y hacia los lados en las coordenadas de la base del personaje justo en el fotograma exacto en el que abandona la superficie mediante el comando de salto. 3. **El impacto de aterrizaje:** Una dispersión horizontal hacia ambos costados (izquierda y derecha) en el instante preciso en que el personaje deja de estar en el aire y colisiona nuevamente contra una superficie sólida, reflejando la absorción de la inercia vertical.

Arquitectura recomendada: El gestor de efectos globales

En proyectos de desarrollo con GameMaker, es tentador crear sistemas de partículas dentro del evento `Create` del propio personaje (`obj_player`). Sin embargo, en un entorno de desarrollo estructurado y escalable, esta práctica genera acoplamiento indeseado: si el jugador muere y su instancia se destruye, el sistema de partículas podría desaparecer prematuramente, cortando las partículas activas en el aire, o bien provocar fugas de memoria si se recrea en cada reaparición.

La mejor práctica consiste en delegar la creación y el mantenimiento de los sistemas de partículas en un objeto controlador permanente, por ejemplo `obj_fx_manager`, o centralizarlos a través de variables globales seguras. En este módulo utilizaremos un objeto gestor persistente que inicializa los tipos de partículas al arrancar la escena y los mantiene listos para que cualquier entidad del juego pueda emitirlos cuando sea necesario.

Crea un nuevo objeto en tu proyecto y nómbralo `obj_fx_manager`. En sus propiedades, marca la casilla **Persistent** (Persistente) para asegurar que acompañe al jugador a través de todas las pantallas del juego sin reinicializarse.

// ====================================================================
// OBJETO: obj_fx_manager
// EVENTO: Create
// PROPÓSITO: Inicializar el sistema de partículas global y configurar
//            los tipos de partículas de polvo para el jugador.
// ====================================================================

// 1. Creación del sistema de partículas global en una capa visual profunda
global.part_sys = part_system_create();
part_system_depth(global.part_sys, -100); // Se dibuja por delante del fondo pero detrás del HUD

// 2. Definición de la partícula de polvo para la CARRERA
global.pt_dust_run = part_type_create();
part_type_shape(global.pt_dust_run, pt_shape_smoke);
part_type_size(global.pt_dust_run, 0.08, 0.15, -0.005, 0); // Comienza pequeña y encoge
part_type_scale(global.pt_dust_run, 1, 1);
part_type_color1(global.pt_dust_run, c_silver);
part_type_alpha3(global.pt_dust_run, 0.6, 0.4, 0.0);       // Nace semi-opaca y se desvanece
part_type_speed(global.pt_dust_run, 0.2, 0.6, -0.01, 0);   // Velocidad suave de deriva
part_type_direction(global.pt_dust_run, 70, 110, 0, 0);    // Sube levemente hacia arriba
part_type_gravity(global.pt_dust_run, 0.01, 270);          // Muy leve resistencia de caída
part_type_life(global.pt_dust_run, 15, 25);                // Vida corta (entre 15 y 25 pasos)

// 3. Definición de la partícula de polvo para el SALTO
global.pt_dust_jump = part_type_create();
part_type_shape(global.pt_dust_jump, pt_shape_smoke);
part_type_size(global.pt_dust_jump, 0.15, 0.25, -0.01, 0);
part_type_scale(global.pt_dust_jump, 1, 1);
part_type_color2(global.pt_dust_jump, c_white, c_gray);
part_type_alpha3(global.pt_dust_jump, 0.8, 0.5, 0.0);
part_type_speed(global.pt_dust_jump, 1.0, 2.0, -0.05, 0);
part_type_direction(global.pt_dust_jump, 20, 160, 0, 10);  // Se abre hacia los costados
part_type_life(global.pt_dust_jump, 20, 30);

// 4. Definición de la partícula de polvo para el ATERRIZAJE
global.pt_dust_land = part_type_create();
part_type_shape(global.pt_dust_land, pt_shape_smoke);
part_type_size(global.pt_dust_land, 0.2, 0.35, -0.012, 0);
part_type_scale(global.pt_dust_land, 1, 0.6);              // Aplanada horizontalmente
part_type_color2(global.pt_dust_land, c_white, c_ltgray);
part_type_alpha3(global.pt_dust_land, 0.9, 0.4, 0.0);
part_type_speed(global.pt_dust_land, 1.5, 3.2, -0.08, 0);  // Expulsión veloz hacia los lados
part_type_life(global.pt_dust_land, 20, 35);

Analicemos las decisiones técnicas tomadas en esta configuración. La función `part_type_alpha3` es una herramienta clave de GameMaker: define tres fases en la opacidad de la partícula (inicio, mitad de su ciclo vital y final). Al establecer `0.6` al nacer, `0.4` a mitad de vida y `0.0` al morir, nos aseguramos de que el polvo nunca desaparezca de golpe frente a los ojos del jugador mediante un parpadeo tosco, sino que se disuelva gradualmente en el aire.

Asimismo, el factor negativo en el tercer argumento de `part_type_size` (denominado *size increase*) indica cuánto debe cambiar el tamaño por cada fotograma. Un valor como `-0.005` hace que la partícula se contraiga orgánicamente hasta esfumarse por completo.

Limpieza de memoria obligatoria (Clean Up)

Como se destacó al abordar los sistemas de partículas, las estructuras de datos nativas del motor gráfico no están sujetas al recolector de basura automático de GML. Es estrictamente obligatorio liberar cada tipo de partícula y el sistema en sí cuando el objeto gestor sea destruido o el juego finalice.

// ====================================================================
// OBJETO: obj_fx_manager
// EVENTO: Clean Up
// PROPÓSITO: Destruir recursos de partículas para evitar fugas de memoria.
// ====================================================================

// Destrucción de tipos de partículas individuales
if (variable_global_exists("pt_dust_run")) {
    part_type_destroy(global.pt_dust_run);
}
if (variable_global_exists("pt_dust_jump")) {
    part_type_destroy(global.pt_dust_jump);
}
if (variable_global_exists("pt_dust_land")) {
    part_type_destroy(global.pt_dust_land);
}

// Destrucción del sistema que las contiene
if (variable_global_exists("part_sys")) {
    part_system_destroy(global.part_sys);
}

💡 Recuerda que el evento Clean Up se ejecuta automáticamente tanto si una instancia es destruida con instance_destroy() como si la sala (Room) cambia o el juego se cierra con game_end(). Es la ubicación más segura y moderna de GameMaker para la recolección manual de recursos de memoria.

Preparación del personaje: Variables de estado y temporización

Ahora que las definiciones físicas del polvo existen en memoria y están listas para ser disparadas en cualquier coordenada del juego, abriremos el objeto del personaje principal, `obj_player`. Para sincronizar la emisión de partículas con sus movimientos, necesitamos agregar dos variables de control en su evento `Create`:

// ====================================================================
// OBJETO: obj_player
// EVENTO: Create (Fragmento complementario para partículas)
// ====================================================================

// Variables de movimiento heredadas de módulos anteriores:
// hsp = 0;
// vsp = 0;
// grounded = false;

// Variables de control para efectos de partículas:
was_grounded = false;     // Almacena el estado grounded del fotograma anterior
dust_timer = 0;           // Temporizador para espaciar las partículas al correr
dust_interval = 8;        // Cantidad de fotogramas entre cada partícula de carrera

La variable `was_grounded` es fundamental: nos permite comparar si el jugador estaba en el aire en el fotograma anterior y tocó el suelo en el fotograma actual. La variable `dust_timer` evita un error común en principiantes: disparar partículas de carrera en cada fotograma sucesivo (lo que generaría 60 partículas por segundo), provocando una masa blanca densa y desagradable.