Ámbito de variables y buenas prácticas

Buenas prácticas de programación y código limpio en GameMaker

Escribir código no consiste únicamente en lograr que el juego funcione en la pantalla; consiste en hacerlo de manera comprensible, escalable y mantenible. Cuando retomes tu proyecto semanas después de haberlo pausado, un código desordenado será incomprensible incluso para ti mismo. A continuación, repasamos las directrices fundamentales para mantener un estándar profesional en GameMaker.

1. Convenciones de nomenclatura claras y coherentes

En GameMaker es altamente recomendable utilizar prefijos de tres letras para los recursos del proyecto (Assets), lo que evita confundir un recurso gráfico con un objeto o un sonido:

• Sprites: `spr_personaje_caminar`, `spr_bloque_piso`, `spr_moneda`. • Objetos: `obj_jugador`, `obj_enemigo_patrulla`, `obj_bloque_solido`. • Sonidos: `snd_salto`, `snd_moneda`, `mus_nivel_1`. • Salas (Rooms): `rm_menu_inicio`, `rm_nivel_1`, `rm_pantalla_victoria`. • Scripts: `scr_calcular_danio`, `scr_guardar_partida`.

Para las variables, se recomienda el formato 'snake_case' (palabras en minúsculas separadas por guiones bajos) en español o inglés neutro, utilizando nombres descriptivos que expliquen su función sin necesidad de adivinanzas. Evita nombres genéricos de una sola letra como `a = 10;` o `temp = true;`. Utiliza en su lugar `velocidad_maxima = 10;` o `esta_invencible = true;`.

2. Evitar números mágicos mediante variables y macros

Un 'número mágico' es un valor numérico escrito directamente en medio de la lógica del juego sin explicación aparente. Por ejemplo, escribir en el evento Step `if (y > 720) { instance_destroy(); }`. Si más adelante decides cambiar la resolución de la pantalla o la altura del nivel, tendrás que buscar manualmente ese '720' repartido en decenas de objetos distintos.

Es preferible declarar una variable con nombre descriptivo o definir una macro global con la directiva `#macro`. Las macros sustituyen una palabra clave por un valor constante antes de compilar y no pueden modificarse en tiempo de ejecución:

// Declaración de macros en un script global (por ejemplo: scr_configuracion)
#macro LIMITE_INFERIOR_PANTALLA 720
#macro GRAVEDAD_BASE 0.4
#macro MAX_VIDAS 3

// Uso limpio en el evento Step de obj_jugador:
if (y > LIMITE_INFERIOR_PANTALLA) {
    scr_reiniciar_posicion_jugador();
}

3. Comentarios significativos y estructura visual

Los comentarios en el código deben explicar el 'por qué' de una decisión, no únicamente repetir lo que la sintaxis ya dice de forma obvia. GML admite comentarios de una sola línea mediante `//` y bloques multilínea mediante `/* ... */`.

// Comentario redundante (no aporta valor real):
// Sumamos 5 a la x
x = x + 5;

// Comentario limpio y descriptivo (explica la intención del diseño):
// Añadimos velocidad constante para simular el desplazamiento forzado de la cinta transportadora
x = x + velocidad_cinta;

Ejemplo práctico: Refactorización limpia del Jugador y Controlador

Apliquemos todo lo aprendido en la arquitectura de nuestro juego de plataformas retro. Vamos a crear dos elementos coordinados de forma limpia: el objeto de control general `obj_controlador_juego` y la refactorización del movimiento básico de nuestro personaje `obj_jugador` utilizando variables de instancia, locales y globales.

Paso 1: Creamos el objeto `obj_controlador_juego`. En el Inspector de GameMaker, activamos la casilla de verificación 'Persistent'. En su evento Create inicializamos el estado global del proyecto:

// Recurso: Objetos -> obj_controlador_juego
// Evento: Create

// Inicialización de variables globales del juego
global.puntuacion = 0;
global.vidas = 3;
global.nivel_completado = false;

// Mensaje de confirmación en la consola de depuración de GameMaker
show_debug_message("Sistema de juego inicializado correctamente.");

Paso 2: Ahora abrimos nuestro `obj_jugador`. En su evento Create, declaramos únicamente sus variables de instancia, evitando mezclar variables que solo se usan en un cálculo momentáneo:

// Recurso: Objetos -> obj_jugador
// Evento: Create

// Variables de instancia: velocidad y estado físico
velocidad_movimiento = 3.5;
velocidad_vertical = 0;
velocidad_horizontal = 0;
fuerza_salto = -8;
gravedad_personaje = 0.35;
estrellado_contra_suelo = true;

Paso 3: En el evento Step de `obj_jugador`, utilizamos variables locales (`var`) para capturar las entradas de teclado y calcular las velocidades del fotograma. Observa cómo ninguna de estas variables intermedias satura la memoria permanente de la instancia:

// Recurso: Objetos -> obj_jugador
// Evento: Step

// 1. Lectura de controles con variables locales
var presiona_izquierda = keyboard_check(vk_left) || keyboard_check(ord("A"));
var presiona_derecha = keyboard_check(vk_right) || keyboard_check(ord("D"));
var presiona_salto = keyboard_check_pressed(vk_space) || keyboard_check_pressed(ord("W"));

// 2. Cálculo vectorial del eje horizontal con variable local
var direccion_horizontal = presiona_derecha - presiona_izquierda;

// 3. Asignación a variables de instancia para el movimiento
velocidad_horizontal = direccion_horizontal * velocidad_movimiento;

// Aplicación de la gravedad sobre la velocidad vertical de instancia
velocidad_vertical += gravedad_personaje;

// 4. Salto básico provisional si se detecta pulsación
if (presiona_salto && estrellado_contra_suelo) {
    velocidad_vertical = fuerza_salto;
    estrellado_contra_suelo = false;
}

// 5. Aplicación física a las coordenadas intrínsecas de la instancia
x += velocidad_horizontal;
y += velocidad_vertical;

// Límite provisional de suelo para pruebas (la colisión real se verá en el Módulo 5)
if (y >= 400) {
    y = 400;
    velocidad_vertical = 0;
    estrellado_contra_suelo = true;
}

Al separar con total claridad las variables que solo importan en este instante (`presiona_izquierda`, `direccion_horizontal`) de las que definen el estado sostenido de la entidad (`velocidad_vertical`, `estrellado_contra_suelo`) y de las globales (`global.vidas`), logramos una base técnica sólida, legible y preparada para incorporar sistemas complejos sin generar conflictos de memoria ni de nombres.

Ejercicios prácticos

Pon a prueba tu comprensión de los tres ámbitos de variables y las buenas prácticas de programación en GML resolviendo los siguientes tres ejercicios guiados:

Ejercicio 1: Refactorización de código con fugas de ámbito Analiza el siguiente fragmento problemático escrito en el evento Step de un proyectil disparado por el jugador (`obj_proyectil`). El desarrollador novato olvidó usar `var` en variables que solo sirven para un cálculo trigonométrico inmediato: ```gml // Código problemático actual: angulo_rad = degtorad(image_angle); componente_x = cos(angulo_rad) * 6; componente_y = -sin(angulo_rad) * 6; x += componente_x; y += componente_y; ``` Reescribe el fragmento corrigiendo el ámbito para que esas tres variables intermedias (`angulo_rad`, `componente_x`, `componente_y`) se conviertan estrictamente en variables locales temporales. Criterio de comprobación: Verifica que al anteponer la palabra clave `var` a esas variables, el proyectil siga moviéndose con total fluidez en pantalla pero ya no figuren como propiedades permanentes de la instancia en la pestaña 'Variables' del depurador.

Ejercicio 2: Creación del objeto recolectable de monedas con variable global Crea un nuevo objeto en tu proyecto llamado `obj_moneda`. Asógnale un sprite simple cuadrado o circular de color dorado (puedes dibujarlo en el editor interno de GameMaker con un tamaño de 16x16 píxeles). En el evento Collision de `obj_moneda` con `obj_jugador`, programa las siguientes acciones: 1. Suma 25 unidades a la variable global `global.puntuacion`. 2. Muestra un mensaje en consola usando `show_debug_message()` que indique el nuevo total de puntos. 3. Destruye la instancia de la moneda recolectada con `instance_destroy()`. Criterio de comprobación: Coloca tres monedas en tu sala `rm_nivel_1`. Inicia el juego, muévete hacia ellas y observa la ventana de salida 'Output' de GameMaker; el contador debe aumentar secuencialmente a 25, 50 y 75 a medida que las monedas desaparecen del escenario.

Ejercicio 3: Detección y corrección de colisión de nombres (Shadowing) Imagina que un programador escribió en el evento Create del jugador: `velocidad = 5;`. Luego, en el evento Step, escribió por error: `var velocidad = 10; x += velocidad;`. Explica por escrito qué sucederá con la variable de instancia original en ese fotograma y qué efecto visual producirá en el jugador. Modifica el código para que las variables tengan nombres descriptivos independientes y no se solapen. Criterio de comprobación: Comprueba que el jugador se mueva a la velocidad correspondiente de su configuración de instancia sin que una variable temporal opaque (haga 'shadowing') a la variable original del objeto.