Bucles y funciones básicas

Introducción al flujo iterativo y a las funciones nativas en GameMaker

Hasta este punto del curso, hemos aprendido a almacenar información mediante variables y a tomar decisiones con estructuras condicionales como if, else y switch. Sin embargo, en el desarrollo de videojuegos existe una necesidad constante: ejecutar una misma operación decenas, cientos o miles de veces de forma automática, estructurada y sin escribir manualmente la misma línea de código una y otra vez. Para resolver este desafío, los lenguajes de programación proporcionan los bucles (también llamados ciclos o estructuras repetitivas), los cuales trabajan en estrecha colaboración con las funciones incorporadas del motor.

Uno de los errores conceptuales más frecuentes entre quienes inician en GameMaker consiste en confundir el ciclo natural del motor —el Evento Step, que se ejecuta continuamente a la velocidad del juego (por ejemplo, 60 veces por segundo)— con la ejecución de un bucle de código como for o while. Es fundamental comprender esta distinción: mientras que el Evento Step distribuye sus ciclos a lo largo del tiempo, permitiendo que la pantalla se actualice entre un fotograma y el siguiente, un bucle de código dentro de un evento se ejecuta por completo dentro del mismo fotograma, congelando la renderización visual hasta que todas sus repeticiones hayan finalizado. Si un bucle tarda demasiado o entra en un ciclo infinito, el juego entero se congelará.

En esta lección profundizaremos en el funcionamiento interno de las funciones nativas de GameMaker (GML Code), analizando cómo reciben parámetros y devuelven datos para realizar cálculos trigonométricos, matemáticos o de gestión de instancias. Posteriormente, estudiaremos a fondo las tres estructuras de repetición esenciales en GML: el ciclo repeat, el bucle for y el bucle while, complementados con las instrucciones de interrupción break y continue. Aplicaremos estos conceptos de manera directa sobre nuestro proyecto del juego de plataformas 2D, automatizando tareas como la generación de hileras de monedas coleccionables y la dispersión controlada de elementos visuales.

¿Qué es una función nativa y cómo opera en GML?

En términos de programación, una función es un bloque de código encapsulado diseñado para llevar a cabo una tarea específica. GameMaker incorpora cientos de funciones nativas creadas para facilitarnos la vida: desde calcular la distancia entre dos entidades en la sala hasta redondear un número decimal o generar valores aleatorios para otorgar dinamismo a las mecánicas del juego. Invocar o llamar a una función consiste en escribir su nombre seguido de un par de paréntesis dentro de los cuales podemos enviar datos de entrada conocidos como argumentos o parámetros.

Muchas funciones realizan una acción inmediata y no necesitan comunicar un resultado numérico (por ejemplo, instance_destroy() destruye la instancia actual sin devolver nada). Por otro lado, un grupo muy amplio de funciones realiza cálculos y 'devuelve' un valor resultante, el cual podemos almacenar directamente en una variable o utilizar en el interior de una expresión matemática o condicional. La sintaxis general para invocar una función con retorno consiste en asignar su resultado a una variable: mi_resultado = nombre_de_funcion(arg0, arg1, ...);

Observemos cómo interactúan estas funciones en un bloque real de programación. Supongamos que deseamos restringir la velocidad de nuestro personaje y verificar si un objeto coleccionable se encuentra dentro del rango de recolección de nuestro héroe:

// Ubicación: obj_player -> Evento Step

// 1. Limitar la velocidad horizontal entre -velocidad_maxima y velocidad_maxima
velocidad_horizontal = clamp(velocidad_horizontal, -velocidad_maxima, velocidad_maxima);

// 2. Comprobar la distancia con una posición de referencia (por ejemplo, el centro de un cofre)
var _distancia_al_objetivo = point_distance(x, y, 320, 240);

if (_distancia_al_objetivo < 64)
{
    // Imprimir en la consola de salida para depuración
    show_debug_message("El jugador está cerca del cofre interactivo.");
}

La palabra clave 'var' que antecede a _distancia_al_objetivo define una variable local temporal. Las variables locales nacen y mueren exclusivamente dentro del bloque de código en el que se declaran, lo que optimiza la memoria y evita colisiones accidentales de nombres entre diferentes eventos u objetos del juego. Estudiaremos su alcance completo en la siguiente clase, pero es indispensable comenzar a utilizarlas al trabajar con bucles y funciones.

El ciclo repeat: iteraciones directas y eficientes

La estructura de bucle más sencilla y ligera en GameMaker es la sentencia repeat. Su propósito es directo: tomar una expresión numérica entera y ejecutar el bloque de instrucciones contenido entre llaves exactamente esa cantidad de veces. A diferencia de otros lenguajes de programación que carecen de esta construcción nativa, GameMaker ofrece repeat como una herramienta altamente optimizada para aquellos casos donde no necesitamos saber en qué número de iteración nos encontramos, sino simplemente repetir una acción N veces.

La sintaxis general de repeat es: repeat (cantidad_de_repeticiones) { // Código a ejecutar en cada ciclo } Si el valor dentro del paréntesis es menor o igual a cero, GameMaker omite por completo el bloque sin producir errores. Si el número contiene decimales, se redondea hacia abajo hacia el entero más cercano.

// Ubicación: obj_player -> Evento Destroy (o cuando el jugador es derrotado)
// Generamos 12 partículas visuales de impacto en la posición actual

repeat (12)
{
    var _offset_x = irandom_range(-16, 16);
    var _offset_y = irandom_range(-16, 16);
    
    // Creamos una instancia decorativa en la capa 'Efectos'
    instance_create_layer(x + _offset_x, y + _offset_y, "Instances", obj_particula_muerte);
}

En el ejemplo anterior, cada una de las 12 ejecuciones del bloque repeat calcula un desfase aleatorio independiente mediante irandom_range y coloca una instancia de obj_particula_muerte. Todo esto ocurre de manera instantánea dentro del mismo fotograma en el que la instancia de obj_player deja de existir, ofreciendo al jugador una explosión visual coordinada sin necesidad de escribir doce veces la misma línea de instanciación.

El bucle for: iteración con índice y control estructurado

Aunque repeat resulta idóneo para acciones masivas ciegas, en la inmensa mayoría de las mecánicas de videojuegos necesitamos tener constancia de en qué iteración exacta nos encontramos. Por ejemplo, si queremos crear una fila de cinco bloques de suelo o posicionar diez monedas con una separación idéntica de 32 píxeles entre sí, necesitamos conocer el valor del contador en cada ciclo. Para este propósito, el bucle for es la estructura estándar por excelencia.

El bucle for organiza su lógica en tres secciones claramente delimitadas dentro de sus paréntesis, separadas por signos de punto y coma: for (inicialización; condición; incremento). Primero se inicializa una variable contadora (comúnmente llamada 'i' por convención técnica). Segundo, se comprueba la condición de continuidad antes de cada iteración; si es verdadera, el cuerpo del bucle se ejecuta, y si es falsa, el bucle termina inmediatamente. Tercero, tras finalizar el código interno de la iteración, se aplica el incremento o decremento al contador, pasando a la siguiente evaluación.

// Ubicación: obj_controlador_nivel -> Evento Create
// Generar una hilera horizontal de 6 monedas coleccionables separadas por 40 píxeles

var _inicio_x = 120;
var _posicion_y = 300;
var _separacion = 40;

for (var i = 0; i < 6; i++)
{
    var _spawn_x = _inicio_x + (i * _separacion);
    instance_create_layer(_spawn_x, _posicion_y, "Instances", obj_moneda);
    
    show_debug_message("Moneda creada en el índice: " + string(i) + " en X=" + string(_spawn_x));
}

Analicemos minuciosamente el recorrido matemático de esta rutina: en la primera vuelta, i vale 0, por lo que _spawn_x se calcula como 120 + (0 * 40) = 120. En la segunda vuelta, i se incrementa a 1, dando 120 + (1 * 40) = 160. El proceso continúa progresivamente hasta i = 5 (X = 320). Cuando i pasa a valer 6 gracias al operador de incremento 'i++', la condición i < 6 evalúa a falso y GameMaker salta a la siguiente instrucción fuera del for. Todo este cálculo e instanciación de 6 monedas toma apenas microsegundos dentro del primer fotograma en el que se inicia la sala.