Estructuras de control condicionales

Toma de decisiones en el desarrollo de videojuegos

Un videojuego no es una secuencia fija de instrucciones que se ejecuta de principio a fin sin alteraciones; es un sistema reactivo y dinámico. En cada instante, el motor evalúa condiciones cambiantes: si el jugador presiona un botón, si un enemigo entra en contacto con una trampa, si la barra de vida llega a cero o si la cantidad de monedas recolectadas alcanza el umbral necesario para otorgar una vida extra. Para que un programa responda adecuadamente a tales eventos, requiere mecanismos que modifiquen el flujo de ejecución del código basándose en el estado del entorno.

En GameMaker, estas bifurcaciones lógicas se gestionan principalmente mediante estructuras condicionales. Aunque la herramienta ofrece un entorno visual denominado GML Visual (donde estas decisiones se representan mediante bloques de acción interconectados como 'If Variable' o 'If Collision'), en el desarrollo profesional y en este curso nos enfocaremos en GML Code. Programar mediante código ofrece una sintaxis precisa, flexible y rápida de mantener, permitiendo modelar mecánicas complejas sin las restricciones de espacio y velocidad inherentes a los diagramas visuales.

En la clase anterior establecimos las bases de la sintaxis y el almacenamiento de datos a través de variables como 'puntos_vida', 'velocidad_x' y 'monedas'. En esta lección, utilizaremos esas mismas variables para gobernar el comportamiento de los objetos mediante las sentencias 'if', 'else if', 'else' y 'switch', construyendo la lógica fundamental de nuestro juego de plataformas 2D.

Expresiones booleanas y operadores de comparación

Toda estructura de control condicional se apoya en una premisa matemática simple: la evaluación de una expresión booleana. Una expresión booleana es cualquier instrucción o cálculo que da como resultado exactamente uno de dos estados posibles: verdadero (true) o falso (false). En GameMaker, internamente, el valor booleano 'true' equivale al número entero 1 (o a cualquier valor numérico mayor que 0.5), mientras que 'false' equivale al número 0.

Para construir estas expresiones, se emplean operadores relacionales de comparación. Estos operadores inspeccionan dos operandos (como variables, constantes o cálculos) y resuelven si la relación matemática entre ellos es cierta o falsa. La siguiente tabla resume los operadores de comparación admitidos en GML Code:

💡 Cuidado con la asignación frente a la comparación: en programación, el signo simple '=' se reserva para asignar un valor a una variable (por ejemplo: vida = 100;), mientras que el doble signo '==' se utiliza para comparar si dos valores son iguales (por ejemplo: if (vida == 100)). Aunque GameMaker tolera el uso de un solo '=' dentro de una condición 'if', es una mala práctica que genera confusión y errores graves en otros lenguajes. Utiliza siempre '==' para evaluar igualdades.

Operadores lógicos

Con frecuencia, una acción en un videojuego no depende de una única condición aislada, sino de la combinación de múltiples factores simultáneos o alternativos. Para enlazar diversas comparaciones booleanas, se utilizan los operadores lógicos:

La sentencia 'if': ejecución condicional básica

La sentencia 'if' es el bloque elemental sobre el que se sustentan todas las decisiones de programación. Su funcionamiento es directo: evalúa la expresión booleana colocada entre paréntesis; si la expresión resulta ser verdadera, el intérprete de GameMaker entra al bloque de código delimitado por llaves '{ }' y ejecuta las líneas que contiene. Si la expresión resulta falsa, el bloque de llaves es completamente ignorado y la ejecución continúa en la línea inmediatamente posterior.

// Sintaxis general de una sentencia if
if (expresion_booleana)
{
    // Bloque de código que se ejecuta solo si la expresión es verdadera
    instruccion_uno();
    instruccion_dos();
}

Veamos un ejemplo contextualizado en nuestro personaje principal, el objeto 'obj_player'. En la clase anterior inicializamos en su evento Create la variable 'monedas' en 0 y la variable 'vidas' en 3. Supongamos que deseamos que, cada vez que el jugador reúna 100 monedas, se le otorgue una vida adicional y su contador de monedas vuelva a cero.

// Objeto: obj_player
// Evento: Step

// Verificamos si se ha alcanzado la meta de monedas recolectadas
if (monedas >= 100)
{
    vidas += 1;
    monedas -= 100;
    show_debug_message("¡Recompensa! Vidas actuales: " + string(vidas));
}

El evento Step se ejecuta en cada ciclo del juego (normalmente 60 veces por segundo). En cada uno de esos fotogramas, GameMaker lee el valor actual de 'monedas'. Mientras 'monedas' oscile entre 0 y 99, la expresión '(monedas >= 100)' devuelve false, por lo que el motor ignora por completo las tres líneas interiores. En el fotograma exacto en el que 'monedas' alcance o supere 100, la expresión se vuelve true: la variable 'vidas' se incrementa en uno, se descuentan 100 monedas para no otorgar vidas infinitas de inmediato y se emite un mensaje por consola.

Rutas alternativas: las cláusulas 'else' y 'else if'

En el diseño de mecánicas es habitual encontrarse con situaciones donde no solo deseamos actuar cuando una condición se cumple, sino también tomar una acción diametralmente opuesta cuando no se cumple. Para este patrón se utiliza la cláusula 'else' (que significa 'de lo contrario'). La cláusula 'else' nunca lleva una condición propia entre paréntesis; se enlaza directamente a un 'if' previo y se ejecuta únicamente cuando la condición de dicho 'if' resulta ser falsa.

// Objeto: obj_player
// Evento: Step

if (esta_envenenado == true)
{
    // Si el jugador está sufriendo envenenamiento, pierde salud progresivamente
    puntos_vida -= 0.1;
}
else
{
    // Si no está envenenado, recupera energía de forma pasiva
    if (puntos_vida < salud_maxima)
    {
        puntos_vida += 0.05;
    }
}

Cuando existen más de dos caminos posibles y estos son mutuamente excluyentes, encadenar múltiples sentencias 'if' aisladas es ineficiente y puede provocar comportamientos no deseados. En su lugar, se recurre a la construcción 'else if'. Esta estructura evalúa una segunda condición únicamente si la primera resultó ser falsa, permitiendo encadenar tantas ramas como requiera la lógica del juego, culminando opcionalmente con un 'else' final que actúe como red de seguridad para cualquier caso no previsto.

La sentencia 'switch': ramificaciones múltiples optimizadas

A medida que un videojuego crece, es muy común encontrarse con variables que actúan como selectores: variables que pueden albergar múltiples valores discretos (como un número entero de estado o una cadena de texto) que determinan qué debe hacer una entidad. Si intentáramos modelar un sistema de cinco o diez estados diferentes mediante 'else if', el código resultante se volvería engorroso, propenso a errores tipográficos y difícil de leer.

Para estos escenarios, GameMaker ofrece la sentencia 'switch'. Esta estructura toma el valor de una única variable y lo compara contra una serie de valores definidos llamados 'case' (casos). Cuando encuentra una coincidencia, ejecuta el bloque de código asociado hasta encontrar la instrucción 'break'.

// Sintaxis general de una sentencia switch
switch (variable_a_evaluar)
{
    case valor_1:
        // Código si variable_a_evaluar == valor_1
        break;
        
    case valor_2:
        // Código si variable_a_evaluar == valor_2
        break;
        
    default:
        // Código que se ejecuta si ningún caso anterior coincidió
        break;
}

Existen dos palabras clave críticas dentro del funcionamiento de un 'switch':

1. 'break': Es la orden de escape. Le indica a GameMaker que dé por finalizada la ejecución del 'switch' y salte fuera de las llaves. Si olvidas colocar un 'break' al final de un caso, el intérprete continuará ejecutando las líneas del siguiente caso de forma secuencial (un fenómeno conocido como caída o fall-through), lo cual casi siempre resulta en errores de lógica inadvertidos.

2. 'default': Es el equivalente al 'else' dentro del 'switch'. Se ubica habitualmente al final y define qué debe ocurrir si el valor de la variable evaluada no coincidió con ninguno de los bloques 'case' especificados. Es indispensable para garantizar la robustez del juego ante estados inesperados o datos corruptos.