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
.nbtou código Node.js. - O usuário quer uma análise visual direta + lista estruturada de blocos/componentes + saída imediata de arquivo
.mjssem idas e voltas para esclarecimentos.
Fora do Escopo
- Ideação apenas por texto do zero (nenhuma imagem fornecida) - delegar a
minecraft-builderpara 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:
- 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,YeZestritamente ao gizmo de eixos XYZ 3D do Painel 01 (vermelhoX, verdeYpara cima, azulZ) 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.
- Quando a imagem carregada for uma ficha técnica de referência multipainel (ex.:
- 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_starteY_roof_peak.
- Estime a caixa delimitadora exata
- 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_logcomaxis. - 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.
- Fundação / Base: ex.:
- 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
4x4e caminhos transitáveis1x2) sem perguntar ao usuário.
- 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
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 aregistry_26_3.jsonno 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.jsone 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:
- Casca e Pilares de Estrutura: Coordenadas dos postes de canto
(X, Z)e planos de parede externa. - Limites do Piso Interno (
X_min..X_max,Z_min..Z_max): Garanta que todos os móveis internos permaneçam estritamente dentro deX_wall_west + 1 .. X_wall_east - 1eZ_wall_north + 1 .. Z_wall_south - 1para que a Passagem 5 nunca sobrescreva as paredes. - Portas, Janelas e Varandas: Coordenadas exatas
(X, Y, Z)+facing, mantendo1-2blocos de piso transitáveis livres na frente e atrás de portas/portões, e garantindo que qualquer varanda cercada tenha>= 1fileira de piso transitável dentro de sua grade externa (depth >= 2). - 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 queautoConnectStairs()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 quecarveStairHeadroom(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) ou1x2(giro em U) nivelado com o degrau superior do Voo 1 (Y_turn), mantendo2blocos de ar acima de patamares planos e começando o Voo 2 emY_turn + 1. - Remova blocos de piso do andar superior apenas diretamente acima de degraus ascendentes onde
step.y + 3 >= Y_uppere delimite a borda do poço da escada com um corrimão de segurança*_fence.
- Trave degraus de escada transitáveis e cadeiras de escada com
- Adjacência de Grade Discreta e Tampa de Chaminé:
- Itens montados na parede (
wall_torch,*_wall_sign,ladder, persianastrapdoor,vine) ocupam o bloco de ar adjacente (X_wall +/- 1ouZ_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
campfiresuperior e coloque*_trapdooraberto (open: 'true',half: 'top') em cada lado que faz fronteira comair.
- Itens montados na parede (
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 ecarveStairHeadroom(). - Passagem 5: Móveis internos (dentro dos limites do cômodo),
placeBed(), fixações na parede, iluminação, seguido porautoConnectStairs(),autoPairDoubleDoors(),connectDoubleChests(),connectWalls()econnectFencesAndPanes().
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]