Voltar para o Blog
Quest Log

Geração Procedural no GameMaker: Mapas com GML

Mapa de caverna visto de cima gerado por computador, com corredores sinuosos cavados num grid de células

Tutorial de geração procedural game maker: gere mapas e cavernas em GML com ds_grid, random walk e seed fixa pra reproduzir o mesmo mapa no GameMaker.

Ferramenta:GameMaker

Geração procedural assusta mais pelo nome do que pela prática. No fundo é só isto: em vez de desenhar cada fase na mão no editor de salas, você escreve um código que monta o mapa seguindo regras. Neste tutorial a gente implementa geração procedural game maker do zero, em GML puro, usando um ds_grid pra guardar o mapa e um algoritmo de random walk pra cavar os corredores. No fim você vai ter um gerador que desenha uma caverna diferente a cada partida e que, quando você quiser, reproduz exatamente o mesmo mapa com uma seed fixa.

A ideia vale pra qualquer engine, e se você quiser a fundamentação teórica mais completa dá uma olhada no pilar de geração procedural. Aqui o foco é fazer funcionar dentro do GameMaker.

Aleatório de verdade vs reprodutível: randomize e random_set_seed

Antes de cavar qualquer mapa, você precisa entender a parte que mais gera confusão em geração procedural game maker: o GameMaker não sorteia números do nada, ele segue uma sequência calculada a partir de uma seed. Mude a seed, muda a sequência inteira. Entenda isso e você controla a aleatoriedade em vez de apanhar dela.

Por padrão o GameMaker usa sempre a mesma seed quando o jogo abre. Isso significa que, sem fazer nada, o seu "aleatório" sai idêntico toda vez que você roda o jogo. Útil pra testar, péssimo pro jogador. Pra quebrar esse padrão existe o randomize:

randomize();

Essa linha sorteia uma seed nova (baseada em algo imprevisível, como o relógio) e a partir dali cada partida gera um mapa diferente. É o que você quer no jogo publicado.

O oposto é o random_set_seed, que fixa a seed num valor que você escolhe:

random_set_seed(42);

Com a seed 42 travada, a sequência de números aleatórios é sempre a mesma, então o mapa gerado é sempre idêntico. Isso parece contraproducente num jogo que quer variedade, mas é ouro em duas situações. A primeira é debug: apareceu um mapa quebrado, com a saída ilhada? Se você sabe a seed, roda de novo e olha o problema exato, em vez de torcer pra ele reaparecer. A segunda é o desafio diário, onde todo mundo joga o mesmo layout no mesmo dia, estilo os roguelikes modernos.

Uma dica que poupa dor de cabeça: guarde a seed que você usou. Dá pra capturar e exibir assim:

randomize();
var _seed = random_get_seed();
show_debug_message("Mapa gerado com a seed: " + string(_seed));

Com o valor em mãos, qualquer mapa vira reproduzível. Um detalhe importante: random, random_range, irandom, irandom_range e choose todos bebem da mesma sequência de seed. Então a ordem em que você chama essas funções importa. Trocar duas chamadas de lugar muda o resultado inteiro, mesmo com a mesma seed.

O ds_grid como planta baixa do mapa

Precisamos de um lugar pra guardar o desenho do mapa antes de transformá-lo em tiles ou objetos. A estrutura certa pra isso no GameMaker é o ds_grid: uma matriz 2D nativa onde cada célula guarda um número. A gente combina um significado pra cada número; aqui vamos usar 0 para parede e 1 para chão.

Crie o grid e preencha tudo de parede primeiro. Começar com o mapa sólido e depois escavar é mais simples do que o contrário:

// Constantes do mapa
#macro LARGURA 48
#macro ALTURA  32
#macro PAREDE  0
#macro CHAO    1

// Cria o grid e preenche tudo de parede
grid = ds_grid_create(LARGURA, ALTURA);
ds_grid_clear(grid, PAREDE);

O ds_grid_clear joga o mesmo valor em todas as células de uma vez, bem mais rápido que um laço duplo na mão. Pra ler ou escrever uma célula específica a gente usa ds_grid_get e ds_grid_set:

ds_grid_set(grid, 10, 5, CHAO);          // marca a célula (10, 5) como chão
var _valor = ds_grid_get(grid, 10, 5);   // lê o valor dessa célula

Um aviso que muita gente esquece: o ds_grid não é limpo pelo garbage collector. Quando a sala acaba ou você vai gerar um mapa novo, destrua o grid antigo com ds_grid_destroy(grid), senão você vaza memória a cada geração.

Random walk: o coração da geração procedural game maker

Com o mapa todo de parede, falta abrir caminho. O algoritmo de random walk é o jeito mais direto e visualmente agradável de fazer isso. A ideia é a de um "escavador" que começa no meio do mapa e anda em passos aleatórios, transformando em chão cada célula por onde passa. O resultado é uma caverna orgânica, cheia de curvas, sem nada quadrado demais.

A lógica em palavras: posicione o escavador no centro, marque a célula atual como chão, sorteie uma das quatro direções, dê um passo (sem sair das bordas) e repita por um número de passos. Quanto mais passos, mais área escavada.

// Começa no centro do mapa
var _cx = LARGURA div 2;
var _cy = ALTURA div 2;

// Quantas células de chão queremos abrir (uns 40% do mapa)
var _total_passos = (LARGURA * ALTURA) * 0.40;

repeat (_total_passos) {
    // Garante que a posição atual vira chão
    ds_grid_set(grid, _cx, _cy, CHAO);

    // Sorteia uma direção: 0=cima, 1=baixo, 2=esquerda, 3=direita
    var _dir = irandom(3);

    switch (_dir) {
        case 0: _cy -= 1; break;
        case 1: _cy += 1; break;
        case 2: _cx -= 1; break;
        case 3: _cx += 1; break;
    }

    // Mantém o escavador dentro das bordas (deixa 1 célula de margem)
    _cx = clamp(_cx, 1, LARGURA - 2);
    _cy = clamp(_cy, 1, ALTURA - 2);
}

Repare no irandom(3): ele devolve um inteiro de 0 a 3, exatamente as quatro direções. Se você usasse irandom_range(1, 4) pegaria 1 a 4, só precisaria ajustar os casos. E o clamp é o que impede o escavador de furar a parede externa e escapar do grid, o que daria erro de índice fora do range. A margem de 1 célula garante que o mapa sempre tem uma borda sólida em volta.

Esse mesmo escavador, com pequenas variações, é a base de cavernas em dezenas de jogos. Se você quiser ver a versão do random walk em outra engine, com salas e corredores em L, o tutorial de dungeon procedural na Godot mostra o mesmo raciocínio aplicado lá, e comparar as duas implementações ajuda a fixar o conceito.

Quer mais cavernas abertas e menos corredores finos? Rode mais de um escavador partindo de pontos diferentes, ou aumente a chance de o escavador seguir na mesma direção algumas células seguidas antes de sortear de novo. Pequenos ajustes nessas regras mudam bastante o "sabor" do mapa.

A beleza de ter isolado a lógica dentro do grid é esta: até aqui a gente não desenhou nada na tela. Só manipulou números numa matriz. Isso deixa o código fácil de testar e de evoluir, e é a diferença entre programar de verdade e empilhar gambiarra. É também o tipo de fundamento que a gente leva pra qualquer engine, e por isso vale mais aprender a pensar em algoritmo do que decorar um clique de editor.

Black Friday: leve 3, pague 2
Travou no código ou na arte? Na Black Friday, leve os dois.

Curso de Godot + curso de Arte 2D + um curso bônus que você só descobre lá dentro. De R$ 2.691 por R$ 997, acesso vitalício, em até 18x no cartão.

Quero os 3 cursos com Godot
Suporte no WhatsAppAcesso vitalício7 dias de garantia

Transformando o grid em tiles e objetos

Agora que o grid guarda o desenho, falta materializar o mapa na sala. A gente percorre todas as células com um laço duplo e, pra cada célula, decide o que colocar ali. O jeito mais simples de começar é instanciando objetos: um obj_parede onde o valor é parede, nada (ou um chão) onde é passagem.

var _tam = 32; // tamanho de cada célula em pixels

for (var _i = 0; _i < LARGURA; _i++) {
    for (var _j = 0; _j < ALTURA; _j++) {
        var _celula = ds_grid_get(grid, _i, _j);
        var _px = _i * _tam;
        var _py = _j * _tam;

        if (_celula == PAREDE) {
            instance_create_layer(_px, _py, "Instances", obj_parede);
        } else {
            instance_create_layer(_px, _py, "Instances", obj_chao);
        }
    }
}

O instance_create_layer precisa de uma layer que exista na sala; aqui chamei de "Instances", que é o nome padrão. Multiplicar o índice da célula pelo tamanho em pixels (_i * _tam) converte a coordenada de grid pra coordenada de mundo. Célula (3, 2) com tiles de 32px vira o pixel (96, 64).

Instanciar um objeto por célula funciona e é ótimo pra aprender, mas em mapas grandes vira milhares de instâncias e pesa. O passo seguinte, quando o mapa crescer, é usar a camada de tiles (tilemap_set) pra pintar o chão e as paredes sem criar instância pra cada célula, reservando objetos só pro que realmente precisa de lógica: inimigos, baús, portas.

Pra posicionar o jogador, uma regra prática: sorteie uma célula até cair numa que seja chão, e coloque ele ali. Assim você nunca spawna dentro de uma parede.

var _spawn_x, _spawn_y;
do {
    _spawn_x = irandom_range(1, LARGURA - 2);
    _spawn_y = irandom_range(1, ALTURA - 2);
} until (ds_grid_get(grid, _spawn_x, _spawn_y) == CHAO);

instance_create_layer(_spawn_x * _tam, _spawn_y * _tam, "Instances", obj_player);

Como o random walk sempre começa no centro, dá pra garantir também que o centro é chão e spawnar lá direto, sem o sorteio. Mas o laço do...until acima é um padrão útil pra quando você precisa de qualquer célula livre, como pra espalhar inimigos ou itens pelo mapa.

Juntando tudo: o gerador completo e a seed

Vamos ver a ordem das coisas no evento Create de um obj_gerador. A sequência importa por causa da seed: primeiro você decide a aleatoriedade, depois gera.

// 1. Decide a aleatoriedade
// Troque por randomize() quando for pro jogo final
random_set_seed(42);

// 2. Cria e limpa o grid
grid = ds_grid_create(LARGURA, ALTURA);
ds_grid_clear(grid, PAREDE);

// 3. Cava com random walk
var _cx = LARGURA div 2;
var _cy = ALTURA div 2;
repeat ((LARGURA * ALTURA) * 0.40) {
    ds_grid_set(grid, _cx, _cy, CHAO);
    switch (irandom(3)) {
        case 0: _cy -= 1; break;
        case 1: _cy += 1; break;
        case 2: _cx -= 1; break;
        case 3: _cx += 1; break;
    }
    _cx = clamp(_cx, 1, LARGURA - 2);
    _cy = clamp(_cy, 1, ALTURA - 2);
}

// 4. Materializa o mapa (laço de tiles/objetos da seção anterior)
// ...

// 5. Lembre de destruir o grid quando trocar de mapa
// ds_grid_destroy(grid);

Com random_set_seed(42) na primeira linha, roda o jogo quantas vezes quiser: o mapa sai igualzinho. Troque por randomize() e cada partida vira uma caverna nova. Essa única linha é a chave de ligar e desligar entre "estou debugando, quero o mesmo mapa" e "é o jogo de verdade, quero variedade".

Quando for soltar isso num projeto maior, pense em verificar se o mapa gerado é jogável antes de aceitá-lo: dá pra contar quantas células de chão ficaram conectadas e, se o random walk produziu uma caverna pequena ou ilhas separadas, descartar e gerar de novo com outra seed. Esse tipo de validação é o que separa um gerador de brinquedo de um que você confia num jogo publicado.

Geração procedural é um daqueles assuntos que compensam o esforço: você troca semanas desenhando fases por um algoritmo que entrega conteúdo quase infinito. E o raciocínio que você montou aqui (guardar o estado num grid, escavar com regras, materializar no mundo, controlar a seed) é o mesmo em qualquer engine. Se você está decidindo em qual ferramenta se aprofundar depois do GameMaker, a comparação Godot vs Unity ajuda a entender pra onde esse tipo de técnica escala melhor conforme o seu projeto cresce.

Perguntas frequentes

Como fazer geração procedural no GameMaker?

Guarde o layout do mapa num ds_grid de inteiros, escave os caminhos com um algoritmo como o random walk e depois percorra o grid criando tiles ou objetos conforme o valor de cada célula. É só código GML, não precisa de nenhuma extensão.

Qual a diferença entre randomize e random_set_seed no GameMaker?

randomize sorteia uma seed nova a cada execução, então o mapa sai diferente toda vez. random_set_seed fixa a seed num valor que você escolhe, então a mesma seed gera exatamente o mesmo mapa sempre. Use randomize no jogo final e random_set_seed pra debugar e pra desafio diário.

Como reproduzir o mesmo mapa procedural duas vezes?

Chame random_set_seed com um número fixo antes de gerar o mapa. Com a mesma seed e o mesmo código, a sequência de números aleatórios é idêntica, então o layout sai igual. Guarde a seed usada pra conseguir recriar qualquer mapa que der problema.

ds_grid é a melhor estrutura pra guardar um mapa no GameMaker?

Pra um mapa em grade, sim. O ds_grid é uma matriz 2D nativa com acesso rápido por coluna e linha, ideal pra guardar que célula é chão e qual é parede. Lembre de destruir com ds_grid_destroy quando não precisar mais, porque ele não é liberado pelo garbage collector.