Entregar Arte para o Programador: Nomes, Tamanhos e Pastas

Entregar assets ao programador sem retrabalho depende de quatro combinados: um padrão de nome (personagem_acao_direcao), o mesmo tamanho de canvas e o mesmo pivô em todos os frames, uma estrutura de pastas que espelha o projeto e uma exportação previsível (no Aseprite, sprite sheet PNG com JSON). Com isso definido no primeiro dia, a arte entra na engine sem ninguém ajustar frame por frame.

Este post é o padrão de entrega que você pode copiar para o seu time ou mandar junto com o primeiro pacote para um cliente, com os passos de exportação no Aseprite e uma checklist final.

Por que entregar assets organizados economiza dias

Pense do lado de quem recebe. O programador abre a pasta e encontra Personagem Final.png, personagem final2.png, corrida_NOVA.png e ataque.gif. Antes de escrever uma linha de código, ele precisa:

• descobrir qual arquivo é o atual;
• medir o tamanho de cada frame, porque cada sheet tem um;
• ajustar o pivô de cada animação, porque o personagem flutua no ataque e afunda na corrida;
• renomear tudo para o padrão do código;
• perguntar para você o que é cada coisa, e esperar a resposta.

Multiplique isso por dezenas de animações e algumas rodadas de revisão. Organização na entrega não é capricho: é tempo de produção do jogo. E uma regra boa: o artista que entrega organizado é o artista que recebe o próximo pedido.

Nomenclatura de sprites: padrão e exemplos

Combine o padrão por escrito, num arquivo LEIAME.txt na raiz da pasta de arte. Um padrão que funciona para a maioria dos jogos 2D:

<entidade>_<acao>_<direcao>.<ext>

Regras:

• tudo em minúsculas;
• sem espaço, sem acento, sem cedilha (o sistema de arquivos e o código agradecem);
• underline separando as partes, hífen só dentro de uma parte composta;
• direção sempre no mesmo vocabulário (cima, baixo, esquerda, direita, ou n, s, l, o);
• sem "final", "novo", "v2" no nome: versão fica no controle de versão, não no arquivo.

Exemplos:

heroi_parado_baixo.png
heroi_correr_direita.png
heroi_atacar-espada_direita.png
slime-verde_pular.png
ui_botao_pressionado.png
tileset_floresta.png
icone_pocao-vida.png

Para animações que vão numa sheet só, com várias ações, o nome do arquivo é a entidade (heroi.png + heroi.json) e as ações viram tags no Aseprite, com o mesmo vocabulário: parado, correr, pular, atacar. O programador lê o nome da tag no JSON e toca a animação certa.

Tamanho do canvas, pivô e alinhamento entre frames

Três regras evitam o problema mais comum de importação, o personagem que "pula" ao trocar de animação:

1. Mesmo canvas para todas as animações do personagem. Se o personagem tem 24 pixels de altura e a espada passa disso no ataque, o canvas de todas as animações é o tamanho que cabe o ataque, por exemplo 48x48. Corrida, idle e pulo usam o mesmo 48x48, com espaço sobrando.

2. Pivô no mesmo ponto. Para personagem de plataforma, o pivô quase sempre é o meio dos pés. Escolha uma coordenada fixa (por exemplo, x 24, y 44 num canvas 48x48) e desenhe todos os frames com os pés tocando essa linha. No Aseprite, uma forma de marcar isso é criar uma camada guia com uma linha de 1 pixel na altura do chão e deixar ela oculta na exportação. Outra é usar um slice (ferramenta Slice, atalho Shift+C) com pivô definido: o Aseprite grava o pivô do slice no JSON quando a opção de slices está marcada na exportação.

3. Mesma escala. Todos os personagens do jogo na mesma escala de pixel. Nada de desenhar o inimigo a 2x e "reduzir depois". Se o jogo é 16 pixels por tile, o personagem foi pensado em 16 pixels por tile.

Escreva tamanho de canvas e pivô no LEIAME.txt. O programador vai configurar isso uma vez na engine e reaproveitar para todas as sheets.

Estrutura de pastas espelhando o projeto

A pasta de entrega deve ter a mesma lógica da pasta do jogo, para o programador arrastar e soltar. Um exemplo:

arte/
  LEIAME.txt
  fonte/                    (arquivos .aseprite, versionados, não vão para o jogo)
    personagens/heroi.aseprite
    inimigos/slime-verde.aseprite
  exportado/                (o que entra no jogo)
    personagens/
      heroi.png
      heroi.json
    inimigos/
      slime-verde.png
      slime-verde.json
    tilesets/
      tileset_floresta.png
    ui/
      ui_botao_normal.png
      ui_botao_pressionado.png

Se o projeto é no Godot, o post sobre estrutura de pastas no Godot mostra como o programador costuma organizar o lado dele. Combine com ele antes de criar a sua: duas estruturas diferentes para a mesma coisa é retrabalho garantido.

Exportação do Aseprite: sprite sheet + JSON

No Aseprite, a sheet sai em File > Export > Export Sprite Sheet (Ctrl+E). A janela tem quatro seções. O que configurar em cada uma para uma entrega previsível:

Layout. Em Sheet Type, escolha By Rows (com Split Tags marcado na seção Sprite, cada tag ocupa uma linha, bom para leitura humana) ou Packed se o importador do programador lê posições pelo JSON e você quer economizar espaço. Combine com ele.

Sprite. Em Layers, exporte só as camadas visíveis (desligue a camada guia antes). Em Frames, todos ou uma tag específica. Split Layers e Split Tags separam a saída por camada ou por tag, úteis em casos específicos, como personagem modular.

Borders. Para pixel art, deixe Trim desligado se o programador não vai usar o deslocamento do JSON: trim corta o espaço vazio de cada frame e muda o tamanho de cada um. Um Border Padding de 1 ou 2 pixels evita que pixels do frame vizinho apareçam por causa de filtragem.

Output. Marque Output File (o PNG) e JSON Data, escolhendo Hash ou Array conforme o importador. Em Meta, marque Tags (o nome das animações vai para o JSON) e Slices se você marcou pivô com slice.

Para entregar muitos arquivos, use a linha de comando, que é previsível e repetível. O comando abaixo, rodado na pasta do projeto, exporta a sheet em linhas, com JSON em array e as tags no campo meta.frameTags:

aseprite -b fonte/personagens/heroi.aseprite --sheet exportado/personagens/heroi.png --data exportado/personagens/heroi.json --format json-array --sheet-type rows --list-tags

O post como montar uma sprite sheet explica a lógica das sheets e do JSON com mais calma, se for a sua primeira vez.

Exportar certo é metade do trabalho; a outra metade é saber o que acontece depois que a arte chega na engine. Artista que já levou a própria arte até o jogo rodando entende por que o pivô importa e para de cometer os erros deste post sem precisar de checklist.

Na engine: o que o programador faz com isso

No Godot, o programador ajusta o filtro de textura para pixel art em Project Settings > Rendering > Textures > Canvas Textures > Default Texture Filter como Nearest, cria um AnimatedSprite2D e, no painel SpriteFrames, usa o botão de adicionar frames a partir de sprite sheet, informando quantas colunas e linhas a sua imagem tem. O pivô vira o offset do nó. Com canvas e pivô iguais em todas as animações, ele configura uma vez e pronto.

Na Unity, ele seleciona o PNG e, no Inspector, define Texture Type como Sprite (2D and UI), Sprite Mode Multiple, Pixels Per Unit igual ao tamanho do tile, Filter Mode Point (no filter) e Compression None. No Sprite Editor, fatia com Slice > Grid By Cell Size, usando o tamanho do canvas, e define o pivô (Bottom ou Custom). Se o canvas muda entre animações, ele precisa fatiar cada sheet de um jeito; se é igual, repete a configuração.

Fonte original vs arquivo exportado

Mantenha os dois, separados:

• Fonte (.aseprite, .kra, .psd): tem camadas, tags, slices, guias. É o que você edita. Fica fora da pasta que vai para o jogo e entra no controle de versão (Git com LFS, ou um serviço de sincronização com histórico).
• Exportado (.png + .json): é o que o jogo usa. Sempre gerado a partir do fonte, nunca editado à mão.

Regra de ouro: se alguém precisa corrigir um pixel, corrige no fonte e exporta de novo. PNG editado direto sai de sincronia com o fonte, e a próxima exportação apaga a correção sem ninguém perceber.

Erros comuns: espaço no nome, versões finais_final2, escala diferente

• Espaço e acento no nome. Herói Correndo.png quebra script, caminho e importação em alguns sistemas.
• Versão no nome do arquivo. heroi_final_final2_agora_vai.png. O programador não sabe qual usar, e o código aponta para o nome antigo.
• Escala diferente entre personagens. O inimigo desenhado a 2x e reduzido fica com pixel de tamanho diferente do herói.
• Canvas diferente por animação. O personagem treme na troca de idle para corrida.
• Camada de esboço exportada. Linha de rascunho a 10% de opacidade aparecendo no jogo.
• Trim ligado sem combinar. Cada frame com um tamanho, e o importador desalinhando tudo.
• Entrega sem LEIAME. Ninguém sabe o tamanho do tile, o pivô nem o padrão de nome.

Checklist de entrega

Antes de mandar cada pacote, confira:

• nomes no padrão, minúsculas, sem espaço nem acento;
• mesmo canvas e mesmo pivô em todas as animações de cada personagem;
• tags com o nome das ações, no vocabulário combinado;
• camadas de guia e esboço ocultas na exportação;
• PNG + JSON no formato combinado (Hash ou Array);
• pasta exportado/ espelhando a estrutura do jogo;
• fonte salvo e versionado fora da pasta do jogo;
• LEIAME.txt com tamanho de tile, canvas, pivô e padrão de nome;
• você mesmo importou uma sheet na engine e viu a animação rodar.

O último item é o que separa a entrega boa da excelente. Se você nunca fez isso, o post sobre exportar sprite sheet do Aseprite para o Godot mostra o caminho completo, e vale fazer uma vez com um personagem de teste antes do próximo pacote.