Voltar para o Blog
Quest Log

Geração Procedural na Unity: Mapas com C#

Mapa 2D gerado por computador com ilhas, praias, grama e rochas num grid de tiles

Tutorial de geração procedural na Unity com C#: ruído de Perlin para heightmap e biomas, pintura num Tilemap e seed fixa para mapas reprodutíveis.

Ferramenta:Unity

Geração procedural na Unity é a técnica de construir o mapa por código em vez de desenhar cada tile à mão. Em vez de um nível fixo, você escreve as regras do terreno e deixa o computador montar o mundo a cada partida. Neste tutorial você vai sair do zero: entender por que ruído é diferente de aleatório puro, usar Mathf.PerlinNoise para um heightmap com biomas, pintar o resultado num Tilemap da Unity e fixar a seed com System.Random para o mapa sair idêntico quando você quiser.

O exemplo final é um MonoBehaviour que gera e pinta um grid completo. Dá para colar, apontar quatro tiles e rodar.

Aleatório puro não é terreno

A primeira tentativa de todo mundo é sortear cada célula direto:

System.Random prng = new System.Random(seed);
int valor = prng.Next(0, 4); // 0 agua, 1 areia, 2 grama, 3 rocha

O problema é que cada célula ignora a vizinha. Uma casa de água pode ter rocha dos dois lados e grama em cima. O resultado é estática: ruído branco, sem ilhas, sem praias, sem montanha que sobe aos poucos. Visualmente parece televisão fora do ar, não um mundo.

Terreno de verdade tem continuidade. A altura de um ponto se parece com a altura do ponto ao lado. É disso que o ruído de Perlin cuida: ele é uma função que, dado um par de coordenadas, devolve um número entre 0 e 1 que muda suave conforme você anda pelo grid. Pontos próximos recebem valores próximos, pontos distantes podem divergir. Esse é o ingrediente que transforma números aleatórios em relevo.

Na Unity isso vem pronto em Mathf.PerlinNoise(float x, float y). Você passa duas coordenadas e recebe um float. A sacada é como escolher essas coordenadas.

Geração procedural na Unity com ruído de Perlin

A escala importa. Se você passar x e y inteiros direto (0, 1, 2...), o Perlin devolve valores quase sem variação, porque em números inteiros pequenos ele tende a repetir perto de 0,5. A solução é dividir as coordenadas por um fator de escala, para andar em passos fracionados dentro da função:

float px = x / scale;
float py = y / scale;
float altura = Mathf.PerlinNoise(px, py); // 0..1, suave

Com scale = 10, cada célula do grid avança 0,1 na função. Escala maior estica o relevo (colinas largas); escala menor aperta (terreno mais picotado).

Uma camada só de Perlin já dá colinas, mas fica lisa demais. Para o terreno ganhar detalhe, somamos várias camadas de ruído em frequências diferentes, as octaves. A primeira octave desenha as formas grandes (continentes), e cada octave seguinte tem frequência maior e amplitude menor, acrescentando os detalhes finos (pequenas elevações). persistence controla o quanto cada octave perde de força, e lacunarity controla o quanto ganha de frequência.

private float SampleHeight(int x, int y, Vector2 offset)
{
    float amplitude = 1f;
    float frequency = 1f;
    float valor = 0f;
    float maxValor = 0f;

    for (int i = 0; i < octaves; i++)
    {
        float px = (x / scale) * frequency + offset.x;
        float py = (y / scale) * frequency + offset.y;

        float ruido = Mathf.PerlinNoise(px, py);
        valor += ruido * amplitude;
        maxValor += amplitude;

        amplitude *= persistence; // perde forca a cada octave
        frequency *= lacunarity;  // ganha frequencia a cada octave
    }

    return valor / maxValor; // normaliza de volta para 0..1
}

Dividir por maxValor no fim garante que o resultado continue entre 0 e 1 mesmo depois de somar quatro octaves. Isso facilita a próxima etapa: cortar faixas de altura em biomas.

De altura para biomas

Com um float de 0 a 1 por célula, biomas viram só faixas de corte. Água no fundo, areia na beira, grama no meio, rocha no topo:

private TileBase TileForHeight(float altura)
{
    if (altura < 0.30f) return waterTile;
    if (altura < 0.40f) return sandTile;
    if (altura < 0.75f) return grassTile;
    return rockTile;
}

Esses números são os botões de design do seu mundo. Subir o corte da água de 0,30 para 0,45 alaga tudo e cria arquipélago; descer para 0,15 deixa quase todo o mapa seco. Ajustar essas quatro faixas muda o planeta inteiro sem tocar no resto do código. O mesmo raciocínio de amostrar ruído e cortar em faixas vale em qualquer engine; se você já viu o pilar de geração procedural com ruído, vai reconhecer a estrutura idêntica do lado Godot.

Para biomas por clima em vez de altura, a técnica é a mesma com dois ruídos independentes: um mapa de temperatura e um de umidade, cada um com sua própria seed, cruzados numa tabela. Mas comece pela altura, que já entrega um mundo convincente.

Fixar a seed para reprodutibilidade

Se você rodar o código de cima sem offset, o mapa sai sempre igual, porque Mathf.PerlinNoise é determinístico: mesma coordenada, mesmo valor. Isso é bom para reprodutibilidade, mas ruim se você quer mapas diferentes a cada jogo. A resposta para os dois casos é a seed.

Use System.Random com um número de seed para calcular um offset fixo e some esse offset nas coordenadas do ruído. Mesma seed produz o mesmo offset, que produz o mesmo mapa. Troque a seed e o mundo inteiro muda, mas continua recriável:

System.Random prng = new System.Random(seed);
float offsetX = prng.Next(-100000, 100000);
float offsetY = prng.Next(-100000, 100000);
Vector2 offset = new Vector2(offsetX, offsetY);

Esse offset grande e positivo resolve dois problemas de uma vez: afasta a amostragem da região repetitiva perto da origem e garante que você nunca cai em coordenadas negativas, onde o Perlin da Unity espelha e cria simetria artificial. Guarde o seed no save do jogador e você recria o mundo exato quando quiser, sem armazenar o mapa inteiro. É assim que jogos mostram "seed do mundo" para o jogador compartilhar.

Aprender sozinho, essas peças parecem soltas: ruído, octaves, Tilemap, seed, cada tutorial num canto. O que trava não é um conceito, é juntar todos num projeto que roda sem você passar a tarde caçando por que o Tilemap ficou branco. Se você quer aprender a desenvolver na Unity de verdade, montando sistemas inteiros com acompanhamento em vez de recortes avulsos, é esse encaixe que o curso de Unity da CursoGame.Dev treina do protótipo ao build.

Curso de Unity
Quer fazer seu primeiro jogo na Unity?

No curso de Unity 6 da CursoGame.Dev você vai do zero ao primeiro jogo, com um desafio prático em cada level e suporte individual no WhatsApp quando travar.

Conhecer o curso de Unity
Suporte no WhatsAppAcesso vitalícioGarantia de 7 dias

O script completo

Juntando tudo num MonoBehaviour. Crie no cenário um objeto com Grid e, dentro dele, um Tilemap (GameObject > 2D Object > Tilemap). Ponha este script no mesmo objeto do Tilemap e arraste os quatro TileBase no Inspector:

using UnityEngine;
using UnityEngine.Tilemaps;

public class ProceduralMap : MonoBehaviour
{
    [Header("Dimensoes")]
    public int width = 64;
    public int height = 64;

    [Header("Ruido")]
    public float scale = 12f;
    public int octaves = 4;
    [Range(0f, 1f)] public float persistence = 0.5f;
    public float lacunarity = 2f;

    [Header("Seed")]
    public int seed = 12345;

    [Header("Tilemap")]
    public Tilemap tilemap;
    public TileBase waterTile;
    public TileBase sandTile;
    public TileBase grassTile;
    public TileBase rockTile;

    private void Start()
    {
        Generate();
    }

    public void Generate()
    {
        System.Random prng = new System.Random(seed);
        float offsetX = prng.Next(-100000, 100000);
        float offsetY = prng.Next(-100000, 100000);
        Vector2 offset = new Vector2(offsetX, offsetY);

        tilemap.ClearAllTiles();

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                float altura = SampleHeight(x, y, offset);
                TileBase tile = TileForHeight(altura);
                tilemap.SetTile(new Vector3Int(x, y, 0), tile);
            }
        }
    }

    private float SampleHeight(int x, int y, Vector2 offset)
    {
        float amplitude = 1f;
        float frequency = 1f;
        float valor = 0f;
        float maxValor = 0f;

        for (int i = 0; i < octaves; i++)
        {
            float px = (x / scale) * frequency + offset.x;
            float py = (y / scale) * frequency + offset.y;

            float ruido = Mathf.PerlinNoise(px, py);
            valor += ruido * amplitude;
            maxValor += amplitude;

            amplitude *= persistence;
            frequency *= lacunarity;
        }

        return valor / maxValor;
    }

    private TileBase TileForHeight(float altura)
    {
        if (altura < 0.30f) return waterTile;
        if (altura < 0.40f) return sandTile;
        if (altura < 0.75f) return grassTile;
        return rockTile;
    }
}

Dê Play e um mapa de 64 por 64 aparece pintado em ilhas, praias e picos. Mude o seed no Inspector e rode de novo: outro mundo, mesma lógica. A separação entre SampleHeight (decide a altura) e TileForHeight (decide o visual) deixa fácil trocar a aparência sem mexer na matemática.

Garantir jogabilidade

Um mapa bonito ainda pode ser injogável: o jogador nasce no meio do oceano, ou duas metades caminháveis ficam separadas por um mar intransponível. Ruído não sabe das suas regras, então a validação vem depois da geração.

Três checagens que resolvem a maioria dos casos:

  • Proporção de bioma. Conte quantas células caíram em cada faixa. Se a água passou de uns 60% do mapa, regenere com outra seed. Isso evita o mundo "só oceano" que às vezes sai.
  • Ponto de spawn válido. Antes de posicionar o jogador, procure uma célula de grama ou areia perto do centro. Nunca nasça o jogador numa célula de água sem antes confirmar que ela existe.
  • Conectividade. Se o jogo exige atravessar o mapa a pé, rode um flood fill (uma busca em largura) a partir do spawn marcando toda célula caminhável alcançável. Se sobrar ilha isolada que você precisava acessar, gere de novo ou abra uma ponte.

Fazer essas checagens e, quando falham, chamar Generate() com uma seed incrementada é o padrão "gerar e testar" que a maioria dos jogos procedurais usa por baixo. Barato e à prova de mapa quebrado.

Daqui dá para crescer em várias direções. Chunks que carregam conforme o jogador anda transformam este grid num mundo infinito, a mesma ideia de reciclar pedaços que sustenta um endless runner na Unity. E se você ainda está decidindo entre engines antes de investir fundo em procedural, vale ler a comparação completa entre Godot e Unity para escolher com base no que cada uma entrega.

Comece pelo script deste tutorial, ajuste as quatro faixas de altura até o mapa ficar com a cara do seu jogo e só então acrescente biomas por clima, rios ou cavernas. Procedural recompensa quem monta em camadas: uma peça sólida de cada vez, cada uma testada antes da próxima.

Perguntas frequentes

Qual a diferença entre aleatório puro e ruído de Perlin na geração de mapas?

Aleatório puro sorteia cada célula de forma independente, então o resultado vira estática sem forma. O ruído de Perlin produz valores que variam suave entre células vizinhas, criando colinas, ilhas e transições que parecem terreno de verdade.

Como fixar a seed para gerar o mesmo mapa de novo na Unity?

Use System.Random com um número de seed para calcular um offset fixo e some esse offset nas coordenadas passadas para Mathf.PerlinNoise. Mesma seed, mesmo offset, mesmo mapa. Guarde a seed junto do save para recriar o mundo sempre igual.

Por que o Mathf.PerlinNoise devolve sempre o mesmo valor perto da origem?

O Mathf.PerlinNoise é espelhado em torno de zero e tende a devolver 0,5 em coordenadas inteiras pequenas. Por isso você soma um offset grande e usa uma escala fracionada, para amostrar uma região variada da função em vez da parte repetitiva.

Como garantir que o mapa procedural seja jogável?

Depois de gerar, valide: limite a proporção de água, confirme que existe uma área inicial caminhável e, se o jogo exige atravessar o mapa, rode um flood fill para checar que as regiões caminháveis estão conectadas. Se falhar, gere de novo com outra seed.