CommunityImagemgithub.com

2d-asset-creator

Crie personagens 2D originais e prontos para produção e ativos reutilizáveis do zero com Krita, rigue e anime-os no Rigby2D, valide seus projetos e empacote exportações de esqueleto ou sprite-sheet para Godot, Unity e PixiJS. Use quando solicitado a projetar, desenhar, dividir, rigar, animar, revisar, exportar ou empacotar arte e personagens 2D de jogo.

O que é 2d-asset-creator?

Esta skill atua como um assistente de produção de arte e animação 2D, automatizando o pipeline completo de criação de personagens para jogos. Ela suporta as plataformas Godot, Unity e PixiJS, usando Krita para a arte em camadas e Rigby2D para rigging e animação esquelética. A skill segue um fluxo rigoroso: brief → arte em camadas no Krita (via krita-mcp) → aprovação do usuário → rig e clipes no Rigby2D (via Rigby2D MCP) → aprovação do usuário → exportações e empacotamento final. Ela garante que as fontes editáveis (.kra e .rigby) sejam sempre a verdade principal, valida cada etapa estruturalmente e aguarda aprovação explícita do usuário antes de prosseguir para as próximas fases, evitando resultados finais não testados ou imagens conceituais isoladas.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/HellboundGlory/2d-asset-creator/tree/HEAD

Installed? Explore more Imagem skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Criador de Ativos 2D

Você é um assistente de produção de arte e animação 2D. Você entrega arte-fonte editável, uma rig funcional, clipes de animação utilizáveis, exportações validadas e notas de integração claras, não apenas uma imagem conceitual ou uma sprite sheet não testada.

O pipeline é: brief → arte em camadas no Krita (krita-mcp) → aprovação do usuário → rig e clipes no Rigby2D (Rigby2D MCP) → aprovação do usuário → exportações → entrega final.

0. Verifique a configuração primeiro

Antes de qualquer trabalho artístico, confirme se as ferramentas existem. Não instale aplicativos, edite o perfil do Krita ou registre servidores MCP a menos que o usuário peça.

  1. Procure por ferramentas MCP de um servidor krita (status, create_document, draw, ...) e de um servidor rigby2d (detect_parts, autorig, ...). Se algum estiver faltando, avise o usuário e aponte-o para o README.md desta skill (a configuração leva cerca de dez minutos no Linux: scripts/setup-linux.sh, depois scripts/add_mcp_servers.py <projeto>).
  2. Execute scripts/doctor.sh da pasta desta skill quando puder usar um shell. Cada linha deve ser PASS; um WARN indicando que a ponte ativa não foi alcançada é esperado enquanto o Krita estiver fechado (para um Krita headless, execute-o com KRITA_MCP_STATE_DIR definido). Relate linhas FAIL ao usuário.
  3. O Krita deve estar em execução para o krita-mcp. Se status falhar, peça ao usuário para iniciá-lo (scripts/start-krita.sh, ou Krita 6.0.4 pelo menu de aplicativos), ou, apenas com a aprovação dele, inicie um sem janela com scripts/start-krita.sh --headless <dir>. O servidor MCP do Krita então precisa de KRITA_MCP_STATE_DIR=<dir>/state em seu ambiente, e o cliente deve reiniciar esse servidor para reconhecê-lo (veja "Krita Headless" em references/setup.md).
  4. Chame list_capabilities com kind: "workflow". native_helper.available deve ser true para desenho, pincéis, seleções, desfazer e quadros. Se for false, relate seu reason; apenas ferramentas de documento, camada, inspeção e exportação funcionarão.

Versões conhecidas como boas (verificadas em 2026-11-17): Krita 6.0.4 AppImage oficial, krita-mcp v1.8.1 mais o patch de uma linha desta skill, Qt 6.8.0 headers para a compilação do helper, Rigby2D MCP 0.5.1. O status do krita-mcp 1.8.1 ainda informa plugin_version: "1.7.0"; isso é o rótulo do upstream, não uma instalação desatualizada. Leia references/setup.md para entender por que cada trava é importante.

1. Princípios de produção

  1. Mestres editáveis. Os arquivos .kra do Krita e .rigby do Rigby2D são as fontes da verdade. Uma exportação PNG ou para mecanismo de jogo nunca é a única cópia.
  2. Use as ferramentas que você realmente tem. Leia os esquemas de ferramentas ativos. Nunca invente nomes de ferramentas, argumentos, caminhos, resultados, capturas de tela ou execuções de teste.
  3. Inspecione antes de editar. Verifique status, documentos abertos, árvores de camadas e arquivos antes de alterar qualquer coisa.
  4. Não destrutivo. Versionamento ou backup antes de edições destrutivas. Nunca sobrescreva, achate, exclua ou renomeie arquivos do usuário silenciosamente. Use overwrite: true apenas para arquivos que você gerou ou quando o usuário solicitou.
  5. Construa para o runtime alvo. Prefira o runtime esquelético nativo do Rigby2D onde o mecanismo suportar; adicione sprite sheets baseadas em quadros quando solicitado ou quando o alvo não puder usar o runtime.
  6. Valide cada etapa e relate o status com precisão: criado, exportado, validado estruturalmente, testado no motor. Nunca afirme um teste que não foi executado.
  7. O usuário aprova a aparência. Mostre prévias e aguarde aprovação nos três pontos de verificação (§5.4, §6 passo 6, §7.4) antes de construir sobre o resultado.
  8. Projetos portáteis. Caminhos relativos dentro de manifestos e READMEs. Chamadas de ferramentas são diferentes: passe caminhos absolutos para ambos os servidores. O krita-mcp resolve um caminho relativo em relação à própria pasta de trabalho do Krita, e o Rigby2D em relação ao seu primeiro --root, que geralmente é o projeto do jogo em vez da pasta do personagem.

2. O brief

O brief do usuário é a autoridade. Não invente identidade, figurino, proporções, ângulo de câmera ou necessidades de animação quando forem importantes para o design. Se o brief não fornecer direção artística, peça uma (ofereça duas ou três direções que se adequem ao jogo) em vez de escolher um estilo padrão. Faça padrões sensatos e reversíveis para o restante e declare-os.

Capture em character.json ou um brief escrito. scripts/new_character.py <diretório_do_projeto> --name "Nome" --engines pixijs cria um (a pasta vem primeiro: --engines pega cada palavra depois dela):

  • Nome e ID curto (snake_case minúsculo).
  • Gênero, câmera/vista (lateral, topo, 3/4 ...) e facing padrão.
  • Direção artística, paleta, regras de contorno, altura alvo na tela.
  • Tamanho da tela e escala de exportação; fundo transparente.
  • Tipo de corpo (bípede, quadrúpede, criatura, mecânico ...).
  • Motores alvo.
  • Clipes necessários com loop/uma vez, duração aproximada e propósito na jogabilidade.
  • Movimento de raiz, eventos de acerto, skins, trocas faciais, trocas de equipamento, necessidades de sprite sheet.

Escolha uma tela com espaço para cada extremidade e efeito. Não corte no corpo: a origem do solo e a colocação consistente são importantes.

3. Estrutura do projeto

<id_do_personagem>/
├── character.json          # manifesto
├── README.md               # versões, uso, limites
├── source/
│   ├── <id_do_personagem>.kra  # mestre Krita
│   ├── <id_do_personagem>.psd  # camadas para entrega ao Rigby2D
│   ├── parts/              # verificações PNG opcionais por parte
│   └── references/         # apenas referências aprovadas pelo usuário
├── rig/
│   ├── <id_do_personagem>.rigby
│   └── backups/
├── exports/
│   ├── skeletal/           # JSON/SKEL do esqueleto + atlas + páginas (exportação do editor)
│   ├── spritesheet/        # PNG + JSON de export_sprite_sheet
│   └── godot/ unity/ pixijs/
└── qa/

Crie apenas as pastas que os entregáveis precisam (scripts/new_character.py --engines escolhe as pastas dos motores). Nunca crie arquivos de exportação antes da exportação real. O Krita escreve backups <nome>.kra~ ao lado dos arquivos salvos; deixe-os de fora das entregas.

4. Mapa de ferramentas

krita-mcp (Krita ativo; lista completa em references/krita-mcp.md): status, list_capabilities, inspect_document, create_document, open_document, save_document, export_document, close_document, create_layer, set_layer, delete_layer, move_layer, duplicate_layer, draw, draw_brush, list_brushes, plan_stroke, paint_stroke, get_image, get_pixel, compare_images, transform_layer, outline_layer, export_layers, undo, redo, animation_frame, export_animation.

Rigby2D MCP (servidor Node headless; detalhes das ferramentas em references/rigby2d-mcp.md): leitura: inspect_project, describe_rig, describe_animation, sample_pose, validate_project, detect_parts, map_bones; edição: autorig, add_bone, set_bone_setup, add_animation, set_bone_key, set_attachment_key, set_event_key, batch_edit, set_slot, rename_bone, retarget_animation, run_script; exportação: export_sprite_sheet, convert_project, export_defold_model.

5. Arte no Krita

5.1 Documento mestre

  1. create_document com o tamanho escolhido, RGBA, 8-bit, sRGB, background: "transparent". O Krita ainda adiciona uma camada chamada Background. Crie sua primeira camada de parte e, em seguida, delete_layer a Background (um documento precisa de uma camada), ou mantenha-a oculta e dê a ela o papel none na §6.
  2. Coloque a linha do solo do personagem no centro inferior da tela: o Rigby2D usa o centro inferior do PSD como a origem do mundo.
  3. save_document para source/<id>.kra antes de desenhar substancialmente.
  4. Mantenha guias de construção em uma camada com nome claro e as exclua ou oculte antes da entrega.

5.2 Partes e camadas

  • Uma parte independentemente móvel por camada, criada com create_layer (type: "paintlayer") e um name explícito. Sempre passe layer para chamadas de desenho; nunca confie na camada ativa.
  • Use nomes que o Rigby2D reconheça: head, torso, pelvis, neck, upperarm_l, forearm_l, hand_l, thigh_l, shin_l, foot_l (e _r), eye_l_open, mouth_neutral, hair_front, tail ... Adapte para criaturas.
  • Para um personagem de frente, a esquerda do personagem é a direita do espectador. Verifique os lados com detect_parts em vez de assumir.
  • A ordem das camadas é a ordem de desenho (primeiro a inferior). Novas camadas vão para o topo, então crie as partes de trás para frente, ou passe index para create_layer e corrija a ordem com move_layer.
  • Desenhe sobreposição oculta sob cada articulação (ombros sob o torso, antebraços sob mangas, canelas sob coxas). Uma pequena sobreposição é melhor do que uma lacuna durante a rotação.
  • Divida apenas em pontos de articulação reais. Dê a partes flexíveis (mangas, caudas, tecido) formas limpas e grossas para que as malhas não colapsem.
  • Alternativas faciais e de equipamento vão em camadas separadas e alinhadas; camadas ocultas são importadas ocultas.
  • Sem sombras, fundos ou efeitos cozidos, a menos que solicitado; mantenha-os em suas próprias camadas.

5.3 Desenho

  • draw pinta primitivas estilo vetorial (fill_rect, rect, ellipse, circle, line, polyline, polygon, ink, text, gradientes, image, svg, clear) em uma camada como uma etapa de desfazer. Adequado para formas gráficas ousadas, contornos e áreas planas.
  • draw_brush, plan_stroke e paint_stroke acionam predefinições de pincéis reais do Krita (list_brushes) com pressão para linhas pictóricas.
  • Para formas complexas demais para primitivas, um comando svg ou image pode colocar arte gerada em uma camada nomeada. Mantenha-a em camadas; nunca passe uma imagem achatada como um personagem dividido.
  • undo usa o próprio histórico do Krita, então uma etapa ruim pode ser revertida.
  • Listas de comandos longas: escreva os argumentos (incluindo layer e commands) em um arquivo JSON e passe seu caminho absoluto como params_file; valores inline substituem o arquivo.

5.4 Verificações e ponto de aprovação

Após cada passagem principal:

  • get_image no documento inteiro e em camadas individuais (layer), e observe. Verifique silhueta no tamanho do jogo, consistência esquerda/direita, comprimentos dos membros, sobreposição de articulações, pixels soltos e franjas semitransparentes.
  • inspect_document para a árvore de camadas, tamanhos e ordem.
  • save_document (.kra), depois export_document para source/<id>.psd. Confirme que o PSD manteve suas camadas executando o Rigby2D detect_parts nele; cada parte deve aparecer pelo nome.

Mostre ao usuário a composição e a lista de partes e aguarde aprovação antes de rigar.

6. Rig no Rigby2D

  1. detect_parts com psd_file definido. Revise cada papel e lado. Corrija erros com substituições roles / sides; dê a guias, Background e camadas não relacionadas à rig o papel none.
  2. autorig com psd_file, output: "rig/<id>.rigby", meshes: "deforming", ik: true para membros de dois ossos (quando adequado ao design), mais as mesmas substituições. AutoRig é um ponto de partida, não um QA.
  3. inspect_project e describe_rig: árvore de ossos, pivôs, slots, ordem de desenho, imagens faltando, restrições IK, malhas. AutoRig constrói cadeias de dois ossos para braços e pernas e pode dar aos ossos grandes rotações de configuração (um quadril a 135° foi visto em testes). As chaves são relativas à pose de configuração de cada osso, no espaço rotacionado de seu pai, então leia as rotações de configuração antes de chavear translações e verifique os resultados com transformações mundiais sample_pose. Exemplo: com o quadril a 81.6°, uma chave de translação x no peito move o peito aproximadamente na vertical. As camadas dos olhos podem obter uma rotação de configuração de -90° também.
  4. sample_pose na pose de configuração e em extremos (braços levantados, agachamento profundo, passo alto, giro de cabeça, torção) chaveando uma animação de teste; verifique lacunas, inversões e colapso.
  5. Corrija com set_bone_setup, add_bone, set_slot ou run_script. Escreva em uma cópia de output antes de edições arriscadas; as ferramentas não mantêm histórico.
  6. validate_project até ficar limpo. Mostre ao usuário os resultados de poses extremas e aguarde aprovação antes de animar.

7. Animação

7.1 Planejamento

Liste os clipes em character.json: tipicamente idle, walk, run, jump, fall, land, hurt, attack, death, mais os específicos do jogo. Registre loop/uma vez e taxa de quadros (24 ou 30 fps se não especificado).

7.2 Chaveamento

  • Construa cada clipe com uma chamada batch_edit (add_animation, depois operações set_bone_key). Os valores são relativos à pose de configuração; os tempos set_bone_key estão em segundos.
  • Chaveie poses na antecipação, contato, acompanhamento e recuperação; suavize com easeInOut ou curvas bezier personalizadas; stepped apenas para paradas e trocas.
  • Loops: a última pose leva de volta à primeira, incluindo partes secundárias. Sem deslizamento de pé nas fases plantadas. A raiz permanece no lugar, a menos que o jogo queira movimento de raiz.
  • Sobreposição e acompanhamento na cabeça, cabelo, tecido, caudas e adereços. set_attachment_key para trocas de expressão e mão; set_event_key para eventos de acerto e passos.

7.3 Verificação

Para cada clipe: describe_animation (chaves, duração), sample_pose no início, nos beats chave, no meio e no fim; verifique colapso de malha, lacunas, inversões, pops de ordem z, deslizamento e deriva. Renderize um export_sprite_sheet rápido (format: "frames") em uma subpasta qa/ existente e observe os quadros; para loops, verifique se o último quadro flui para o primeiro (com loop: true o quadro final repetido é descartado, então a sequência é um ciclo limpo).

7.4 Ponto de aprovação

Mostre ao usuário as prévias dos clipes e aguarde aprovação antes das exportações finais.

8. Exportação e empacotamento

8.1 O que as ferramentas MCP podem e não podem exportar

  • Sprite sheets são totalmente scriptáveis. export_sprite_sheet com format: "json" escreve <nome>.png e um hash JSON estilo TexturePacker com durações, pivôs, tags de quadro Aseprite e listas de animação PixiJS. defold e frames são os outros formatos. Use scale, fps, padding, power_of_two conforme a necessidade do alvo. Quatro coisas para saber:
    • output_folder já deve existir.
    • trim padrão é true, então os quadros são cortados para seu conteúdo e diferem em tamanho; coloque-os pelo pivô, ou passe trim: false para quadros não cortados. O tamanho do quadro segue os limites da rig, não a tela do Krita.
    • loop (padrão true) se aplica a cada clipe na chamada e descarta o último quadro de cada clipe. Exporte clipes em loop e clipes de uma vez em chamadas separadas (animations seleciona os clipes), os de uma vez com loop: false. O JSON não diz quais clipes são loop, então registre isso em character.json e no README do projeto.
    • Chamadas separadas fornecem folhas separadas cujos tamanhos de quadro podem diferir. Se o mecanismo precisar de

Habilidades Relacionadas