Conditional Control Structures

Decision-Making in Game Development

A video game is not a static sequence of instructions that executes from start to finish without interruption; it is a dynamic, reactive system. At every moment, the engine evaluates changing conditions: whether the player presses a button, whether an enemy touches a hazard, whether the health bar reaches zero, or whether collected coins reach the threshold for an extra life. For a program to respond appropriately to these events, it needs mechanisms that branch execution flow based on the environment's current state.

In GameMaker, these logical branches are managed primarily through conditional structures. While GameMaker offers a visual scripting environment called GML Visual (where these decisions are represented through interconnected action blocks such as 'If Variable' or 'If Collision'), in professional development and throughout this course we focus on GML Code. Writing code provides precise, flexible, and maintainable syntax, allowing you to model complex mechanics without the spatial and speed constraints inherent to visual flowcharts.

In the previous lesson, we established the basics of syntax and data storage using variables such as 'puntos_vida', 'velocidad_x', and 'monedas'. In this lesson, we will use those same variables to govern object behavior using 'if', 'else if', 'else', and 'switch' statements, building the core gameplay logic for our 2D platformer.

Boolean Expressions and Comparison Operators

Every conditional control structure rests on a straightforward mathematical premise: evaluating a boolean expression. A boolean expression is any instruction or calculation that evaluates to exactly one of two possible states: true or false. Internally in GameMaker, the boolean value 'true' evaluates to the integer 1 (or any numeric value greater than 0.5), while 'false' evaluates to 0.

To construct these expressions, we use relational comparison operators. These operators inspect two operands (such as variables, constants, or expressions) and resolve whether the mathematical relation between them is true or false. The following table summarizes the comparison operators supported in GML Code:

💡 Beware of assignment vs. comparison: in programming, a single '=' sign assigns a value to a variable (e.g., vida = 100;), while the double '==' sign tests whether two values are equal (e.g., if (vida == 100)). Although GameMaker historically permits a single '=' inside an 'if' condition, relying on this is poor practice that causes subtle bugs and confusion across other programming languages. Always use '==' to check equality.

Logical Operators

Frequently, game behavior depends not on a single isolated condition, but on a combination of multiple simultaneous or alternative factors. To chain multiple boolean comparisons together, we use logical operators:

The 'if' Statement: Basic Conditional Execution

The 'if' statement is the foundational building block for programmatic decision-making. Its operation is straightforward: it evaluates the boolean expression inside parentheses. If the expression evaluates to true, GameMaker's runtime enters the code block enclosed by curly braces '{ }' and executes the statements inside. If the expression evaluates to false, the braced block is skipped entirely, and execution resumes immediately after it.

// General syntax of an if statement
if (expresion_booleana)
{
    // Code block executed only if the expression evaluates to true
    instruccion_uno();
    instruccion_dos();
}

Let's look at an example using our main character, the 'obj_player' object. In the previous lesson, we initialized 'monedas' to 0 and 'vidas' to 3 inside its Create event. Suppose we want to grant an extra life and deduct 100 coins whenever the player collects 100 coins.

// Object: obj_player
// Event: Step

// Check whether the collected coin milestone has been reached
if (monedas >= 100)
{
    vidas += 1;
    monedas -= 100;
    show_debug_message("Reward! Current lives: " + string(vidas));
}

The Step event executes on every game frame (typically 60 times per second). On every frame, GameMaker checks the current value of 'monedas'. As long as 'monedas' is between 0 and 99, the expression '(monedas >= 100)' returns false, so the engine skips the three statements inside. On the exact frame 'monedas' reaches or exceeds 100, the expression evaluates to true: 'vidas' increases by one, 100 coins are deducted to prevent awarding endless lives, and a message prints to the output console.

Alternative Paths: The 'else' and 'else if' Clauses

When designing mechanics, you will often need to execute one action when a condition is met, and a completely different action when it is not. For this pattern, we use the 'else' clause. The 'else' clause never takes a condition of its own in parentheses; it attaches directly to an preceding 'if' and runs only when that 'if' condition evaluates to false.

// Object: obj_player
// Event: Step

if (esta_envenenado == true)
{
    // If the player is poisoned, drain health progressively
    puntos_vida -= 0.1;
}
else
{
    // If not poisoned, passively regenerate health
    if (puntos_vida < salud_maxima)
    {
        puntos_vida += 0.05;
    }
}

When you have more than two mutually exclusive paths, chaining multiple independent 'if' statements is inefficient and can cause unexpected bugs. Instead, use an 'else if' structure. This structure checks a second condition only if the previous condition evaluated to false, allowing you to link as many branches as your game logic requires, optionally ending with a final 'else' fallback to handle any unhandled cases.

The 'switch' Statement: Optimized Multi-Branching

As your game expands, you will frequently encounter variables acting as selectors: variables storing discrete values (such as an integer state code or a string identifier) that determine what an entity should do. Modeling a system with five or ten different states using chained 'else if' statements quickly results in verbose, error-prone, and hard-to-read code.

For these scenarios, GameMaker provides the 'switch' statement. This structure evaluates a single variable and matches it against a list of predefined 'case' values. Once a match is found, it runs the associated block of code until it hits a 'break' statement.

// General syntax of a switch statement
switch (variable_a_evaluar)
{
    case valor_1:
        // Code if variable_a_evaluar == valor_1
        break;
        
    case valor_2:
        // Code if variable_a_evaluar == valor_2
        break;
        
    default:
        // Code executed if none of the cases matched
        break;
}

There are two essential keywords to understand when working with 'switch':

1. 'break': The exit command. It instructs GameMaker to terminate execution of the 'switch' and jump past its closing brace. If you omit 'break' at the end of a case, the runtime continues executing code in subsequent cases sequentially (known as fall-through), which almost always causes unintended logical bugs.

2. 'default': The equivalent of 'else' inside a 'switch'. It is typically placed at the end and defines what code should execute if the evaluated variable matches none of the specified 'case' blocks. It is essential for safeguarding your game against unexpected states or corrupted data.