Loops and Basic Built-in Functions

Introduction to Iterative Flow and Built-in Functions in GameMaker

Up to this point in the course, we have learned how to store information using variables and make decisions with conditional structures such as if, else, and switch. However, game development involves a constant demand: executing the exact same operation dozens, hundreds, or thousands of times automatically, cleanly, and without manually writing duplicate code. To solve this challenge, programming languages provide loops (or iteration structures), which work hand in hand with the engine's built-in functions.

One of the most frequent misconceptions among GameMaker beginners is confusing the engine's natural update cycle—the Step Event, which runs continuously at the game's room speed (e.g., 60 times per second)—with a code loop such as for or while. Understanding this distinction is vital: while the Step Event distributes its ticks across real time, allowing the screen to render between one frame and the next, a code loop inside an event executes completely within a single frame, halting visual rendering until all its iterations finish. If a loop takes too long or enters an infinite loop, the entire game will freeze.

In this lesson, we will explore the inner workings of GameMaker's built-in functions (GML Code), examining how they accept parameters and return values to handle trigonometry, general math, or instance management. Then, we will thoroughly dissect the three primary iteration structures in GML: the repeat statement, the for loop, and the while loop, along with the break and continue flow control statements. Finally, we will apply these concepts directly to our 2D platformer project, automating tasks like generating rows of collectible coins and scattering visual particle effects.

What Is a Built-in Function and How Does It Work in GML?

In programming terms, a function is an encapsulated block of code designed to carry out a specific task. GameMaker includes hundreds of built-in functions designed to streamline development: from calculating the distance between two entities in a room to rounding decimal values or generating random numbers to make game mechanics feel dynamic. Calling or invoking a function simply means writing its name followed by a pair of parentheses, inside of which we pass input values known as arguments or parameters.

Many functions trigger an immediate action without returning a numeric result (for example, instance_destroy() destroys the current instance and returns nothing). Conversely, a wide variety of functions perform calculations and 'return' a resulting value that we can store in a variable or use directly inside a mathematical or conditional expression. The general syntax for calling a function with a return value assigns its output to a variable: my_result = function_name(arg0, arg1, ...);

Let's see how these functions interact in an actual script. Suppose we want to cap our character's movement speed and check whether a collectible chest is within our hero's interaction range:

// Location: obj_player -> Step Event

// 1. Clamp horizontal speed between -velocidad_maxima and velocidad_maxima
velocidad_horizontal = clamp(velocidad_horizontal, -velocidad_maxima, velocidad_maxima);

// 2. Check the distance to a reference position (for example, the center of a chest)
var _distancia_al_objetivo = point_distance(x, y, 320, 240);

if (_distancia_al_objetivo < 64)
{
    // Print to the Output Console for debugging
    show_debug_message("The player is close to the interactive chest.");
}

The 'var' keyword preceding _distancia_al_objetivo defines a temporary local variable. Local variables exist solely within the code block where they are declared and are discarded as soon as the block finishes executing. This saves memory and prevents accidental name collisions between different events or game objects. We will explore variable scope in detail in an upcoming lesson, but using local variables when working with loops and temporary calculations is an essential best practice.

The repeat Loop: Direct and Efficient Iteration

The simplest and fastest iteration structure in GameMaker is the repeat statement. Its purpose is straightforward: take an integer expression and execute the enclosed block of instructions exactly that many times. Unlike languages that lack this dedicated construct, GameMaker provides repeat as a highly optimized tool for scenarios where you do not need an index tracking which iteration is currently running, but simply want an action repeated N times.

The general syntax for repeat is: repeat (number_of_iterations) { // Code to execute on each cycle } If the value inside the parentheses is zero or negative, GameMaker skips the entire block without throwing an error. If the value has decimals, it is truncated down to the nearest integer.

// Location: obj_player -> Destroy Event (or when the player is defeated)
// Spawn 12 visual impact particles at the current position

repeat (12)
{
    var _offset_x = irandom_range(-16, 16);
    var _offset_y = irandom_range(-16, 16);
    
    // Create a decorative instance on the 'Instances' layer
    instance_create_layer(x + _offset_x, y + _offset_y, "Instances", obj_particula_muerte);
}

In the example above, each of the 12 iterations calculates an independent random offset using irandom_range and creates an instance of obj_particula_muerte. This all happens instantly within the single frame in which obj_player is destroyed, producing a coordinated burst effect without requiring twelve duplicate lines of code.

The for Loop: Indexed Iteration and Structured Control

While repeat is ideal for blind bursts, most game mechanics require knowing exactly which iteration is currently executing. For instance, if you want to place a row of five floor tiles or position ten coins spaced exactly 32 pixels apart, you need the counter value on every pass. For this purpose, the for loop is the industry-standard structure.

A for loop organizes its control logic into three distinct sections separated by semicolons: for (initialization; condition; increment). First, a counter variable is initialized (conventionally named 'i'). Second, the condition is evaluated before each iteration; if true, the loop body runs; if false, the loop terminates immediately. Third, after running the body, the counter is incremented or decremented, and the loop checks the condition again.

// Location: obj_controlador_nivel -> Create Event
// Spawn a horizontal row of 6 collectible coins spaced 40 pixels apart

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("Coin created at index: " + string(i) + " at X=" + string(_spawn_x));
}

Let's trace the math step by step: on the first pass, i is 0, so _spawn_x evaluates to 120 + (0 * 40) = 120. On the second pass, i increments to 1, producing 120 + (1 * 40) = 160. This sequence continues up to i = 5 (X = 320). Once i hits 6 via the increment operator 'i++', the condition i < 6 evaluates to false, and GameMaker proceeds to the next line outside the loop. Calculating and instantiating all 6 coins takes just microseconds during the room's very first frame.