Rule Tile na Unity: Autotile sem Pintar Borda à Mão

O Unity Rule Tile é um tipo de tile que escolhe sozinho qual sprite mostrar olhando para os 8 vizinhos da célula: se em cima está vazio, vira borda de grama; se em cima e à esquerda estão vazios, vira canto. Você pinta o terreno com um único pincel e as bordas se ajustam enquanto pinta. É o autotile da Unity, e vem no pacote 2D Tilemap Extras.

Aqui você configura um Rule Tile regra por regra para um tileset de terreno 3x3 com cantos internos, entende como ler a grade de vizinhos, por que a ordem das regras decide tudo, e adiciona variação com Random e Animated Tile. Tudo no Unity 6.3 LTS.

O que é Rule Tile e autotile

Sem autotile, pintar uma plataforma é escolher à mão: canto superior esquerdo, borda de cima, borda de cima, canto superior direito, lateral, centro... e repetir quando você muda o formato. Mudou o tamanho da plataforma, repinta as bordas.

O Rule Tile guarda uma lista de regras. Cada regra é uma grade 3x3 de condições sobre os vizinhos mais um sprite de saída. Quando você pinta, a Unity avalia as regras da célula e dos vizinhos dela, e cada uma passa a mostrar o sprite certo.

Instalar o 2D Tilemap Extras

1. Window > Package Manager.
2. Em Unity Registry, procure 2D Tilemap Extras (com.unity.2d.tilemap.extras). O manual do Unity 6.3 lista a versão 6.0 para o editor 6000.3.
3. Instale. Projetos criados pelo template 2D costumam já trazer o pacote junto das ferramentas 2D.

O pacote traz, além do Rule Tile: Animated Tile, Rule Override Tile, Isometric Rule Tile e pincéis extras (Random, Line, Group, GameObject).

Montar o tileset certo para autotile

Para um terreno de plataforma completo você precisa de 13 tiles:

• 9 do bloco 3x3: 4 cantos externos, 4 bordas e o centro.
• 4 cantos internos: a quina que aparece quando o terreno faz um "L" (por exemplo, terra com uma reentrância).

Desenhe os 9 como um bloco 3x3 na sprite sheet e os 4 cantos internos ao lado. Todos no mesmo tamanho (16x16 ou 32x32), mesma paleta, e com as bordas casando entre si: o lado direito da borda de cima precisa continuar no lado esquerdo do próximo tile de borda de cima. O post sobre desenhar tileset no Aseprite mostra como testar esse encaixe com o modo de tiles antes de exportar.

Importe com Sprite Mode Multiple, PPU igual ao tamanho do tile, Filter Mode Point e fatie com Grid By Cell Size.

Rule Tile na Unity: criar as regras de borda e canto

1. No Project, botão direito > Create > 2D > Tiles > Rule Tile. Nomeie GroundRuleTile.
2. Default Sprite: o tile de centro. É o que aparece quando nenhuma regra bate, e no meio do terreno nenhuma borda bate.
3. Em Tiling Rules, clique no + para cada regra. Cada uma tem a grade 3x3 e um campo de sprite.

Como ler a grade. O quadrado do meio é a própria célula. Os 8 em volta são os vizinhos. Clicar num vizinho alterna:

• Seta verde (This): o vizinho precisa ser este mesmo Rule Tile.
• X vermelho (Not This): o vizinho precisa ser vazio ou outro tile.
• Vazio: tanto faz.

Use "tanto faz" sem medo: regra que só testa o necessário é regra que funciona em mais formatos de terreno.

As regras do terreno, na ordem em que vão na lista:

1. Canto interno superior esquerdo. Cima, baixo, esquerda e direita: This. Diagonal superior esquerda: Not This. Sprite: canto interno correspondente. Transform: Mirror X, para a mesma regra cobrir o canto interno superior direito.
2. Canto interno inferior esquerdo. Os quatro lados This, diagonal inferior esquerda Not This. Mirror X.
3. Canto externo superior esquerdo. Cima: Not This. Esquerda: Not This. Direita: This. Baixo: This. Mirror X.
4. Canto externo inferior esquerdo. Baixo: Not This. Esquerda: Not This. Direita e cima: This. Mirror X.
5. Borda de cima. Cima: Not This. Esquerda, direita e baixo: This.
6. Borda de baixo. Baixo: Not This. Esquerda, direita e cima: This.
7. Borda esquerda. Esquerda: Not This. Cima, baixo e direita: This. Mirror X para a borda direita.

O centro não precisa de regra: o Default Sprite cobre.

Arraste o GroundRuleTile para a Tile Palette e pinte. Faça uma plataforma, depois um "L", depois um buraco no meio: cada borda e canto deve aparecer sozinho.

Ordem das regras e o padrão Fixed, Rotated e Mirror

Ordem. A documentação do pacote é direta: a Unity testa as regras em sequência, a partir do topo, e aplica a primeira que bate. Por isso os cantos internos estão no topo da lista acima. Uma célula de canto interno tem os quatro lados preenchidos, igual a uma célula de centro. Se, mais tarde, você criar uma regra de centro testando só os quatro lados (para usar Output Random, por exemplo) e ela ficar acima dos cantos internos, ela bate primeiro e os cantos internos somem. Regra mais específica (mais condições) vai em cima, regra genérica vai embaixo.

Transform, o campo de cada regra:

• Fixed: testa a grade só do jeito que está.
• Rotated: testa também girada 90, 180 e 270 graus, e gira o sprite junto. Uma regra de borda vira as quatro bordas.
• Mirror X / Mirror Y / Mirror XY: testa espelhada no eixo, e espelha o sprite.
• Rotated Mirror: combina rotação e espelhamento.

Quando usar cada: Rotated só funciona se a arte gira sem estranhar. Parede de masmorra vista de cima, com tijolo igual em todos os lados: Rotated economiza regras. Terreno de plataforma, com grama só em cima e terra nas laterais: Rotated colocaria grama na parede. Use Mirror X para esquerda e direita, e regras Fixed separadas para cima e para baixo.

Para jogos que geram fase por código, o Rule Tile faz o trabalho de borda também. O gerador só decide onde tem terreno.

Arquivo PlatformGenerator.cs:

using UnityEngine;
using UnityEngine.Tilemaps;

public class PlatformGenerator : MonoBehaviour
{
    [SerializeField] private Tilemap groundTilemap;
    [SerializeField] private TileBase groundRuleTile;
    [SerializeField] private int platformCount = 8;
    [SerializeField] private int minWidth = 3;
    [SerializeField] private int maxWidth = 8;
    [SerializeField] private int minHeight = 2;
    [SerializeField] private int maxHeight = 4;
    [SerializeField] private Vector2Int areaSize = new Vector2Int(60, 20);

    private void Start()
    {
        Generate();
    }

    public void Generate()
    {
        groundTilemap.ClearAllTiles();

        for (int i = 0; i < platformCount; i++)
        {
            int width = Random.Range(minWidth, maxWidth + 1);
            int height = Random.Range(minHeight, maxHeight + 1);
            int startX = Random.Range(0, areaSize.x - width);
            int startY = Random.Range(0, areaSize.y - height);

            for (int x = startX; x < startX + width; x++)
            {
                for (int y = startY; y < startY + height; y++)
                {
                    groundTilemap.SetTile(new Vector3Int(x, y, 0), groundRuleTile);
                }
            }
        }
    }
}

O script só preenche retângulos com o mesmo tile. Quando dois retângulos se sobrepõem, as regras resolvem os cantos internos que aparecem na junção. Para gerar muitos tiles de uma vez com mais desempenho, Tilemap.SetTiles recebe arrays de posições e tiles numa chamada só.

Pintar bordas automáticas é um alívio. O que segue travando quem faz jogo sozinho é o resto: colisão que não prende o personagem, câmera que respeita o limite do mapa, inimigos que patrulham sem cair e o jogo inteiro funcionando junto. O curso de Unity constrói jogos 2D completos passando por essas integrações na ordem certa.

Random e Animated Tile para variação

Random dentro do Rule Tile. Cada regra tem o campo Output:

• Single: um sprite.
• Random: uma lista de sprites, sorteada por célula. Ajuste Noise (o quanto a escolha varia) e Shuffle (se o sorteio pode girar ou espelhar o sprite). Use no centro do terreno, com 3 ou 4 variações de terra com pedrinhas diferentes, e a repetição some.
• Animation: uma lista de sprites tocada em sequência, com velocidade mínima e máxima.

Para o Default Sprite variar, crie uma regra de centro (os 8 vizinhos This) com Output Random e coloque no fim da lista.

Animated Tile. Para tiles que se mexem sozinhos sem depender de vizinho (tocha na parede, água, lava): Create > 2D > Tiles > Animated Tile. Arraste os frames, defina velocidade mínima e máxima. Velocidade aleatória entre um intervalo faz tochas vizinhas piscarem fora de sincronia.

Rule Override Tile. Fez o terreno de grama e quer um de neve com as mesmas regras? Crie um Rule Override Tile apontando para o Rule Tile original e troque só os sprites. As regras ficam num lugar só.

Erros comuns: canto errado, regra que nunca dispara

Canto errado aparecendo. Ordem das regras. Mova a regra mais específica para o topo.

Regra que nunca dispara. Ela está abaixo de uma regra mais genérica que bate antes, ou exige condições demais (testando diagonais que não importam). Troque as diagonais desnecessárias para "tanto faz".

Grama na parede lateral. Regra de borda com Rotated em tileset que não é simétrico. Troque para Fixed ou Mirror X.

Tile de outro tipo vira "vazio" para o Rule Tile. Por padrão, "This" significa exatamente este Rule Tile. Terra e pedra como Rule Tiles diferentes não se reconhecem e as duas desenham borda na junção. Para terrenos que se conectam, use um Rule Tile só com variações, ou estenda o Rule Tile com regras próprias (o pacote documenta como criar Custom Rules).

Borda com uma linha de pixel errada. O problema está na arte, não na regra: as bordas dos tiles não casam. Teste o tileset repetido antes de importar.

Próximo passo

Monte o Rule Tile com as 7 regras acima, pinte uma fase com plataformas, buracos e reentrâncias e procure qualquer canto errado. Depois adicione uma regra de centro com Output Random e veja a diferença na repetição.

O próximo passo natural é a colisão: um Tilemap com Rule Tile e Composite Collider 2D. Se você ainda não montou a base de Grid, paleta e camadas, volte ao post sobre Tilemap na Unity. E se usa Godot também, o post sobre autotile de terreno no TileMap da Godot mostra o mesmo problema resolvido com Terrains, e comparar os dois ajuda a entender o que o autotile está fazendo.