Construtor de Imagens Minecraft

Analise uma imagem ou captura de tela de uma construção do Minecraft, faça engenharia reversa de suas dimensões exatas, paleta de blocos, perfil do telhado, profundidade da fachada e layout oculto dos fundos/interior para um Manifesto de Componentes e Tabela de Âncoras de Coordenadas detalhados, e gere imediatamente um arquivo gerador Node.js (.mjs) autônomo e sem dependências que exporta um arquivo .nbt vanilla do Minecraft (Minecraft 26.3 / DataVersion 5023) sem fazer perguntas.

O que é Construtor de Imagens Minecraft?

Esta skill, Construtor de Imagens Minecraft, permite que um agente de IA analise qualquer imagem ou captura de tela de uma construção do Minecraft (como casas, estátuas ou pontes) e reconstrua-a digitalmente em um arquivo .nbt funcional. Quando um usuário fornece uma imagem, a skill executa quatro fases principais sem fazer perguntas: uma análise visual detalhada para criar um Manifesto de Componentes (incluindo dimensões, paleta de blocos e planos para os fundos e interior ocultos), verificação de blocos contra um registro específico (Minecraft 26.3), criação de uma Tabela de Âncoras de Coordenadas para posicionamento preciso dos blocos e geração de um arquivo .mjs autônomo e sem dependências. Este arquivo JavaScript usa apenas os módulos 'node:fs' e 'node:zlib' e segue uma ordem de 5 passagens para construir a estrutura do zero, garantindo que todos os componentes, desde fundações até móveis internos, estejam no lugar correto. O arquivo .mjs resultante pode ser executado para gerar um arquivo .nbt compactado, pronto para ser usado no Minecraft, e a skill suporta plataformas como Claude Code e Cursor, focando em usuários que desejam recriar construções a partir de imagens sem discussão.

Funciona com✓Claude Code~Codex CLI~Cursor
Part ofMobile
npx skills add https://github.com/marvaproject/minecraft-structure-builder/tree/HEAD/minecraft-builder-img

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

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

Documentação

O que Construtor de Imagens Minecraft faz?

Faça engenharia reversa de qualquer imagem ou captura de tela de uma estrutura do Minecraft para um Manifesto de Componentes, Tabela de Âncoras de Coordenadas e um arquivo ESM (.mjs) autônomo, sem dependências e baixável (usando a ferramenta de geração de arquivos em vez de despejar blocos de código bruto no chat) que exporta um arquivo .nbt compactado com gzip para Minecraft 26.3 (DataVersion: 5023) imediatamente em uma única passagem, sem fazer perguntas.

Quando Usar

  • O usuário fornece uma imagem, captura de tela ou renderização de uma construção do Minecraft (casa, chalé, torre, ponte, poço, estátua, mobília, templo ou complexo) e pede para recriar, copiar, fazer engenharia reversa ou gerar em .nbt ou código Node.js.
  • O usuário quer uma análise visual direta + lista estruturada de blocos/componentes + saída imediata de arquivo .mjs sem idas e voltas para esclarecimentos.

Fora do Escopo

  • Ideação apenas por texto do zero (nenhuma imagem fornecida) - delegar a minecraft-builder para brainstorming e design arquitetônico do zero.
  • Circuitos de redstone, terreno/terraformagem personalizada, conteúdos NBT de baús ou posicionamento de entidades - declarar a limitação claramente e reconstruir a casca de blocos estática.

Layout da Pasta

minecraft-image-builder/
├── SKILL.md
└── registry_26_3.json

Fluxo de Trabalho (Execução Direta - Sem Brainstorming)

Não faça perguntas esclarecedoras ou de brainstorming quando uma imagem for fornecida. Execute todas as quatro fases sequencialmente em uma única resposta:

Fase 1: Análise Visual Profunda e Manifesto de Componentes

Inspecione a imagem cuidadosamente de baixo para cima e de frente para trás, depois produza um Blueprint e Manifesto de Componentes conciso e estruturado:

  1. Ficha Técnica Multipainel e Alinhamento de Eixos (Se Aplicável):
    • Quando a imagem carregada for uma ficha técnica de referência multipainel (ex.: 01. VISTA 3/4 FRENTE-DIREITA, 02. VISTA 3/4 TRASEIRA-ESQUERDA, 03. VISTA INTERIOR / DETALHES ESTRUTURAIS), sintetize todos os painéis em vez de tratá-los como construções separadas.
    • Fixe a orientação X, Y e Z estritamente ao gizmo de eixos XYZ 3D do Painel 01 (vermelho X, verde Y para cima, azul Z) e a qualquer rótulo de chão "FRENTE". Ignore setas de gizmo invertidas ou duplicadas no Painel 02 se entrarem em conflito com a rotação da câmera do Painel 01.
    • Cruze as informações do Painel 01 e Painel 02 para extrair todas as 4 fachadas externas sem adivinhar, e priorize o layout de corte do Painel 03 para divisórias internas, escadas e colocação de móveis.
    • Ignore adereços duplicados acidentais no Painel 03 (como uma lanterna ou placa extra) que não aparecem tanto no Painel 01 quanto no Painel 02.
  2. Dimensões Gerais e Proporções (Triangulação de Grade):
    • Estime a caixa delimitadora exata SIZE = [W, H, L] contando blocos visíveis ao longo da largura (X), altura (Y) e profundidade (Z), mantendo proporções não-1:1:1 fiéis à captura de tela.
    • Se paredes ou superfícies parecerem suaves/não-voxel em uma imagem de referência gerada por IA, triangule contagens exatas de blocos a partir das linhas de grade do chão 1x1, pilares de estrutura de canto, painéis de janela e escadas do telhado, em vez de adivinhar pela altura suave da parede.
    • Defina níveis de datum de elevação: Y_base, Y_floor1, Y_floor2 (se for vários andares), Y_roof_start e Y_roof_peak.
  3. Detalhamento da Paleta de Materiais (Correspondente a registry_26_3.json):
    • Fundação / Base: ex.: cobblestone, stone_bricks, tuff_bricks, deepslate_bricks.
    • Pilares e Vigas de Estrutura: ex.: oak_log, spruce_log, stripped_dark_oak_log com axis.
    • Paredes Primárias e Secundárias: ex.: oak_planks, white_concrete, calcite, mud_bricks.
    • Telhado e Acabamento: ex.: spruce_stairs, brick_stairs, deepslate_tile_stairs, lajes e acabamento de beirado.
    • Aberturas, Iluminação e Detalhes Externos: janelas (glass_pane), persianas (*_trapdoor), portas (*_door), cercas/paredes, lanternas, chaminés, folhagem/videiras e adereços decorativos visíveis na imagem.
  4. Plano de Reconstrução Traseira e Interior (Lados Ocultos):
    • Para quaisquer faces ou cantos internos ainda ocultos em todos os painéis, infira um layout simétrico ou funcionalmente coerente (combinando o ritmo das janelas e a inclinação do telhado) e mobílie o interior de forma limpa seguindo O Padrão de Navegação The Sims (camas/estações de trabalho/exibições, iluminação a cada área 4x4 e caminhos transitáveis 1x2) sem perguntar ao usuário.

Fase 2: Verificação do Registro de Blocos (registry_26_3.json)

  • Verifique cada ID de bloco escolhido (minecraft:<name>) e propriedade de estado em relação a registry_26_3.json no diretório da skill (Minecraft 26.3 / DataVersion: 5023).
  • Nunca invente IDs de blocos ou valores de enumeração. Se um adereço modificado, suave ou não-voxel aparecer na captura de tela (ex.: parede de gesso lisa, unidade de ar condicionado, geladeira de exposição, placa de texto), traduza-o para a combinação de blocos vanilla 26.3 mais próxima válida de registry_26_3.json e anote o mapeamento no Manifesto de Componentes.

Fase 3: Tabela de Âncoras de Coordenadas e Regras Construtivas de 5 Passagens

Mapeie o Manifesto de Componentes para uma Tabela de Âncoras de Coordenadas exata (X, Y, Z) antes de escrever o código:

  1. Casca e Pilares de Estrutura: Coordenadas dos postes de canto (X, Z) e planos de parede externa.
  2. Limites do Piso Interno (X_min..X_max, Z_min..Z_max): Garanta que todos os móveis internos permaneçam estritamente dentro de X_wall_west + 1 .. X_wall_east - 1 e Z_wall_north + 1 .. Z_wall_south - 1 para que a Passagem 5 nunca sobrescreva as paredes.
  3. Portas, Janelas e Varandas: Coordenadas exatas (X, Y, Z) + facing, mantendo 1-2 blocos de piso transitáveis livres na frente e atrás de portas/portões, e garantindo que qualquer varanda cercada tenha >= 1 fileira de piso transitável dentro de sua grade externa (depth >= 2).
  4. Alinhamento de Escadas e Cumeeira do Sótão:
    • Trave degraus de escada transitáveis e cadeiras de escada com shape: 'straight' explícito para que autoConnectStairs() molde apenas escadas de telhado.
    • Qualquer escada subindo para um andar superior/sótão com telhado inclinado DEVE terminar abaixo da cumeeira central alta do telhado (Y_roof_peak) para que carveStairHeadroom(x, y, z, 3) nunca perfure a inclinação externa do telhado.
    • Para escadas com giro, use um patamar de bloco cheio 1x1 (giro em L) ou 1x2 (giro em U) nivelado com o degrau superior do Voo 1 (Y_turn), mantendo 2 blocos de ar acima de patamares planos e começando o Voo 2 em Y_turn + 1.
    • Remova blocos de piso do andar superior apenas diretamente acima de degraus ascendentes onde step.y + 3 >= Y_upper e delimite a borda do poço da escada com um corrimão de segurança *_fence.
  5. Adjacência de Grade Discreta e Tampa de Chaminé:
    • Itens montados na parede (wall_torch, *_wall_sign, ladder, persianas trapdoor, vine) ocupam o bloco de ar adjacente (X_wall +/- 1 ou Z_wall +/- 1), nunca sobrescrevendo blocos de parede.
    • Para chaminés externas que se estendem acima do pico do telhado, verifique todos os 4 vizinhos horizontais ao redor do campfire superior e coloque *_trapdoor aberto (open: 'true', half: 'top') em cada lado que faz fronteira com air.

Fase 4: Saída Imediata de Arquivo .mjs Autônomo e Instruções de Execução

Gere e exporte o arquivo ESM completo e autocontido (<build-name>.mjs) como um arquivo .mjs baixável (usando a ferramenta file_gen se disponível — NÃO despeje o código-fonte .mjs completo como um bloco de código Markdown bruto na resposta do chat, a menos que a geração de arquivos não esteja disponível) usando apenas node:fs e node:zlib na ordem de Camadas Construtivas de 5 Passagens:

  • Passagem 1: Fundação, estacas e lajes de piso.
  • Passagem 2: Pilares de estrutura, paredes externas, janelas, varandas e portas (placeDoor).
  • Passagem 3: Telhado (com beirado de 1 bloco) e chaminé externa (com tampa de 4 lados).
  • Passagem 4: Escadas (shape: 'straight'), recortes exatos do piso do poço da escada, corrimãos de segurança e carveStairHeadroom().
  • Passagem 5: Móveis internos (dentro dos limites do cômodo), placeBed(), fixações na parede, iluminação, seguido por autoConnectStairs(), autoPairDoubleDoors(), connectDoubleChests(), connectWalls() e connectFencesAndPanes().

Não inclua funções de validação throw new Error em tempo de execução para que o script sempre execute de forma limpa. Conclua sempre com breves comandos de execução, pré-visualização no Shulkr 3D Viewer (https://www.shulkr.com/en/viewer) e carregamento no Bloco de Estrutura do Minecraft.

Modelo de .mjs Autônomo

import fs from 'node:fs';
import zlib from 'node:zlib';

class NbtWriter {
  constructor() { this.chunks = []; }
  u8(v) { const b = Buffer.alloc(1); b.writeUInt8(v); this.chunks.push(b); }
  i16(v) { const b = Buffer.alloc(2); b.writeInt16BE(v); this.chunks.push(b); }
  i32(v) { const b = Buffer.alloc(4); b.writeInt32BE(v); this.chunks.push(b); }
  str(s) { const buf = Buffer.from(s, 'utf8'); this.i16(buf.length); this.chunks.push(buf); }
  tagHeader(type, name) { this.u8(type); this.str(name); }
  tagInt(name, v) { this.tagHeader(3, name); this.i32(v); }
  tagString(name, v) { this.tagHeader(8, name); this.str(v); }
  tagListHeader(name, elemType, length) { this.tagHeader(9, name); this.u8(elemType); this.i32(length); }
  tagCompoundStart(name) { this.tagHeader(10, name); }
  tagEnd() { this.u8(0); }
  toBuffer() { return Buffer.concat(this.chunks); }
}

const SIZE = [11, 12, 13];
const palette = [];
const paletteMap = new Map();
const blockGrid = new Map();

const DIR_VEC = {
  north: [0, -1],
  south: [0, 1],
  west: [-1, 0],
  east: [1, 0],
};
const LEFT_OF = { north: 'west', west: 'south', south: 'east', east: 'north' };
const RIGHT_OF = { north: 'east', east: 'south', south: 'west', west: 'north' };

function getStateIndex(name, props = {}) {
  const keys = Object.keys(props).sort();
  const key = `${name}|${keys.map((k) => `${k}=${props[k]}`).join(',')}`;
  if (!paletteMap.has(key)) {
    paletteMap.set(key, palette.length);
    palette.push({ Name: name, Properties: props });
  }
  return paletteMap.get(key);
}

function setBlock(x, y, z, name, props = {}) {
  if (x < 0 || x >= SIZE[0] || y < 0 || y >= SIZE[1] || z < 0 || z >= SIZE[2]) return;
  const posKey = `${x},${y},${z}`;
  if (name === 'minecraft:air') {
    blockGrid.delete(posKey);
    return;
  }
  blockGrid.set(posKey, { pos: [x, y, z], name, props, state: getStateIndex(name, props) });
}

function fill(x1, y1, z1, x2, y2, z2, name, props = {}) {
  for (let x = Math.min(x1, x2); x <= Math.max(x1, x2); x++) {
    for (let y = Math.min(y1, y2); y <= Math.max(y1, y2); y++) {
      for (let z = Math.min(z1, z2); z <= Math.max(z1, z2); z++) {
        setBlock(x, y, z, name, props);
      }
    }
  }
}

function placeDoor(x, y, z, blockId, facing = 'south', hinge = 'left', open = 'false') {
  setBlock(x, y, z, blockId, { facing, half: 'lower', hinge, open, powered: 'false' });
  setBlock(x, y + 1, z, blockId, { facing, half: 'upper', hinge, open, powered: 'false' });
}

function placeBed(headX, y, headZ, blockId = 'minecraft:red_bed', facing = 'north') {
  const [dx, dz] = DIR_VEC[facing] ?? [0, -1];
  setBlock(headX, y, headZ, blockId, { facing, part: 'head', occupied: 'false' });
  setBlock(headX - dx, y, headZ - dz, blockId, { facing, part: 'foot', occupied: 'false' });
}

function carveStairHeadroom(x, y, z, height = 3) {
  for (let dy = 1; dy <= height; dy++) {
    setBlock(x, y + dy, z, 'minecraft:air');
  }
}

function autoConnectStairs(skipPositions = new Set()) {
  for (const b of blockGrid.values()) {
    if (!b.name.endsWith('_stairs')) continue;
    const [x, y, z] = b.pos;
    if (skipPositions.has(`${x},${y},${z}`)) continue;
    if (b.props.shape !== undefined) continue;
    const f = b.props.facing;
    const half = b.props.half ?? 'bottom';
    if (!f || !DIR_VEC[f]) continue;

    const getStairAt = (nx, ny, nz) => {
      const nb = blockGrid.get(`${nx},${ny},${nz}`);
      if (!nb || !nb.name.endsWith('_stairs')) return null;
      if ((nb.props.half ?? 'bottom') !== half) return null;
      return nb.props.facing;
    };

    const [fx, fz] = DIR_VEC[f];
    const [lx, lz] = DIR_VEC[LEFT_OF[f]];
    const [rx, rz] = DIR_VEC[RIGHT_OF[f]];
    const frontFacing = getStairAt(x + fx, y, z + fz);
    const backFacing = getStairAt(x - fx, y, z - fz);
    const leftFacing = getStairAt(x + lx, y, z + lz);
    const rightFacing = getStairAt(x + rx, y, z + rz);
    let shape = 'straight';

    if (frontFacing === LEFT_OF[f] && rightFacing !== f) shape = 'outer_left';
    else if (frontFacing === RIGHT_OF[f] && leftFacing !== f) shape = 'outer_right';
    else if (backFacing === LEFT_OF[f] && leftFacing !== f) shape = 'inner_left';
    else if (backFacing === RIGHT_OF[f] && rightFacing !== f) shape = 'inner_right';

    const nextProps = {
      ...b.props,
      half,
      shape,
      waterlogged: b.props.waterlogged ?? 'false',
    };
    b.props = nextProps;
    b.state = getStateIndex(b.name, nextProps);
  }
}

function autoPairDoubleDoors() {
  const paired = new Set();
  for (const b of blockGrid.values()) {
    if (!b.name.endsWith('_door') || b.name === 'minecraft:iron_door') continue;
    if (b.props.half !== 'lower') continue;
    const [x, y, z] = b.pos;
    const key = `${x},${y},${z}`;
    if (paired.has(key)) continue;

    const f = b.props.facing ?? 'south';
    if (!DIR_VEC[f]) continue;
    const [lx, lz] = DIR_VEC[LEFT_OF[f]];
    const viewerRightKey = `${x + lx},${y},${z + lz}`;
    const neighborLower = blockGrid.get(viewerRightKey);

    if (
      neighborLower &&
      !paired.has(viewerRightKey) &&
      neighborLower.name === b.name &&
      neighborLower.props.half === 'lower' &&
      (neighborLower.props.facing ?? 'south') === f
    ) {
      const setDoorHinge = (dx, dz, hinge) => {
        for (const dy of [0, 1]) {
          const halfBlock = blockGrid.get(`${dx},${y + dy},${dz}`);
          if (halfBlock && halfBlock.name === b.name) {
            halfBlock.props = { ...halfBlock.props, hinge };
            halfBlock.state = getStateIndex(halfBlock.name, halfBlock.props);
          }
        }
      };
      setDoorHinge(x, z, 'left');
      setDoorHinge(x + lx, z + lz, 'right');
      paired.add(key);
      paired.add(viewerRightKey);
    }

…

[truncado para tradução]

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Habilidades Relacionadas