¿Qué hace Minecraft Image Builder?
Aplica ingeniería inversa a cualquier imagen o captura de pantalla de una estructura de Minecraft para obtener un Component Manifest, una Coordinate Anchor Table y un archivo ESM (.mjs) descargable, autónomo y sin dependencias (utilizando la herramienta de generación de archivos en lugar de volcar bloques de código sin formato en el chat) que exporta un archivo .nbt comprimido con gzip para Minecraft 26.3 (DataVersion: 5023) inmediatamente en una sola pasada, sin hacer preguntas de lluvia de ideas.
Cuándo usar
- El usuario proporciona una imagen, captura de pantalla o render de una construcción de Minecraft (casa, cabaña, torre, puente, pozo, estatua, mueble, templo o complejo) y pide recrearla, copiarla, aplicarle ingeniería inversa o generarla en
.nbto código Node.js. - El usuario desea un desglose visual directo + una lista estructurada de bloques/componentes + un archivo
.mjsde salida inmediato sin idas y vueltas.
Fuera del alcance
- Ideación solo textual desde cero (sin imagen proporcionada): delegar a
minecraft-builderpara lluvia de ideas y diseño arquitectónico desde cero. - Circuitos de redstone, terreno/terraformación personalizada, contenido NBT de cofres o poses de entidades: indicar la limitación claramente y reconstruir la carcasa de bloques estática.
Estructura de carpetas
minecraft-image-builder/
├── SKILL.md
└── registry_26_3.json
Flujo de trabajo (Ejecución directa - Sin lluvia de ideas)
No hagas preguntas aclaratorias o de lluvia de ideas cuando se proporcione una imagen. Ejecuta las cuatro fases de forma secuencial en una sola respuesta:
Fase 1: Desglose visual profundo y Component Manifest
Inspecciona la imagen cuidadosamente de abajo hacia arriba y de adelante hacia atrás, luego genera un Blueprint y Component Manifest conciso y estructurado:
- Hoja técnica de múltiples paneles y alineación de ejes (si corresponde):
- Cuando la imagen subida es una hoja de referencia técnica de múltiples paneles (por ejemplo,
01. VISTA 3/4 FRONTAL-DERECHA,02. VISTA 3/4 TRASERA-IZQUIERDA,03. VISTA INTERIOR / DE DETALLES ESTRUCTURALES), sintetiza todos los paneles en lugar de tratarlos como construcciones separadas. - Bloquea la orientación
X,YyZestrictamente al gizmo de ejes 3D del Panel 01 (rojoX, verdeYhacia arriba, azulZ) y a cualquier etiqueta de piso"FRONT". Ignora las flechas de gizmo duplicadas o invertidas en el Panel 02 si entran en conflicto con la rotación de la cámara del Panel 01. - Compara el Panel 01 y el Panel 02 para extraer las 4 fachadas exteriores sin adivinar, y prioriza el diseño seccionado del Panel 03 para las particiones de habitaciones interiores, escaleras y colocación de muebles.
- Ignora los accesorios duplicados accidentales en el Panel 03 (como una linterna o un cartel adicionales) que no aparecen tanto en el Panel 01 como en el Panel 02.
- Cuando la imagen subida es una hoja de referencia técnica de múltiples paneles (por ejemplo,
- Dimensiones generales y proporciones (Triangulación de cuadrícula):
- Estima la caja delimitadora exacta
SIZE = [W, H, L]contando los bloques visibles a lo largo del ancho (X), la altura (Y) y la profundidad (Z), manteniendo las proporciones no 1:1:1 fieles a la captura de pantalla. - Si las paredes o superficies aparecen suaves/no voxelizadas en una imagen de referencia generada por IA, triangula los recuentos exactos de bloques a partir de las líneas de la cuadrícula del piso
1x1, los pilares de marco de las esquinas, los paneles de las ventanas y las escaleras del techo, en lugar de adivinar a partir de la altura de una pared suave. - Define los niveles de datos de elevación:
Y_base,Y_floor1,Y_floor2(si tiene varios pisos),Y_roof_startyY_roof_peak.
- Estima la caja delimitadora exacta
- Desglose de la paleta de materiales (emparejado con
registry_26_3.json):- Cimientos / Zócalo: por ejemplo,
cobblestone,stone_bricks,tuff_bricks,deepslate_bricks. - Pilares de marco y vigas: por ejemplo,
oak_log,spruce_log,stripped_dark_oak_logconaxis. - Paredes primarias y secundarias: por ejemplo,
oak_planks,white_concrete,calcite,mud_bricks. - Techado y molduras: por ejemplo,
spruce_stairs,brick_stairs,deepslate_tile_stairs, losas y molduras de voladizo. - Aberturas, iluminación y detalles exteriores: ventanas (
glass_pane), contraventanas (*_trapdoor), puertas (*_door), vallas/paredes, linternas, chimeneas, follaje/enredaderas y accesorios decorativos visibles en la toma.
- Cimientos / Zócalo: por ejemplo,
- Plan de reconstrucción interior y trasero (caras ocultas):
- Para las caras o esquinas interiores que aún estén ocultas en todos los paneles, infiere un diseño simétrico o funcionalmente coherente (que coincida con el ritmo de las ventanas y la pendiente del techo) y amuebla el interior limpiamente siguiendo el Estándar de navegación de Los Sims (camas/estaciones de trabajo/pantallas, iluminación cada área
4x4y caminos1x2transitables) sin preguntar al usuario.
- Para las caras o esquinas interiores que aún estén ocultas en todos los paneles, infiere un diseño simétrico o funcionalmente coherente (que coincida con el ritmo de las ventanas y la pendiente del techo) y amuebla el interior limpiamente siguiendo el Estándar de navegación de Los Sims (camas/estaciones de trabajo/pantallas, iluminación cada área
Fase 2: Verificación del registro de bloques (registry_26_3.json)
- Verifica cada ID de bloque elegido (
minecraft:<name>) y cada propiedad de estado conregistry_26_3.jsonen el directorio de la habilidad (Minecraft 26.3 /DataVersion: 5023). - Nunca inventes ID de bloque o valores de enumeración. Si aparece un accesorio modificado, suave o no voxelizado en la captura de pantalla (por ejemplo, pared de yeso liso, unidad de aire acondicionado, nevera con pantalla, cartel de texto), tradúcelo a la combinación de bloques vanilla 26.3 válida más cercana de
registry_26_3.jsony anota la asignación en el Component Manifest.
Fase 3: Coordinate Anchor Table y reglas constructivas de 5 pasos
Asigna el Component Manifest a una Coordinate Anchor Table (X, Y, Z) exacta antes de escribir código:
- Carcasa y pilares de marco: Coordenadas de los postes de las esquinas
(X, Z)y planos de las paredes exteriores. - Límites del piso interior (
X_min..X_max,Z_min..Z_max): Asegúrate de que todos los muebles interiores permanezcan estrictamente dentro deX_wall_west + 1 .. X_wall_east - 1yZ_wall_north + 1 .. Z_wall_south - 1para que el Paso 5 nunca sobrescriba las paredes. - Puertas, ventanas y balcones: Coordenadas exactas
(X, Y, Z)+facing, manteniendo1-2casillas de piso transitables despejadas delante y detrás de puertas/portones, y asegurando que cualquier balcón con valla tenga>= 1fila de piso transitable dentro de su baranda exterior (depth >= 2). - Escaleras y alineación de la cumbrera del ático:
- Bloquea los escalones transitables de las escaleras y los escalones tipo silla con
shape: 'straight'explícito para queautoConnectStairs()solo dé forma a las escaleras del techo. - Cualquier escalera que ascienda a un piso superior/ático con techo inclinado DEBE terminar debajo de la cumbrera central alta del techo (
Y_roof_peak) para quecarveStairHeadroom(x, y, z, 3)nunca perfore la pendiente exterior del techo. - Para escaleras que giran, usa un rellano de bloque completo plano
1x1(giro en L) o1x2(giro en U) al mismo nivel que el escalón superior del Vuelo 1 (Y_turn), manteniendo2bloques de aire sobre los rellanos planos y comenzando el Vuelo 2 enY_turn + 1. - Elimina las casillas del piso superior solo directamente sobre los escalones ascendentes donde
step.y + 3 >= Y_uppery bordea el borde abierto del hueco de la escalera con una barandilla de seguridad*_fence.
- Bloquea los escalones transitables de las escaleras y los escalones tipo silla con
- Adyacencia discreta de la cuadrícula y remate de la chimenea:
- Los elementos montados en la pared (
wall_torch,*_wall_sign,ladder, contraventanastrapdoor,vine) ocupan el bloque de aire adyacente (X_wall +/- 1oZ_wall +/- 1), nunca sobrescribiendo los bloques de la pared. - Para las chimeneas exteriores que se extienden por encima del pico del techo, verifica los 4 vecinos horizontales alrededor de la
campfiresuperior y coloca*_trapdoorabiertos (open: 'true',half: 'top') en cada lado que linde conair.
- Los elementos montados en la pared (
Fase 4: Salida inmediata de archivo .mjs autónomo e instrucciones de ejecución
Genera y exporta el archivo ESM completo y autocontenido (<build-name>.mjs) como un archivo .mjs descargable (usando la herramienta file_gen si está disponible—NO vuelques el código fuente completo del .mjs como un bloque de código Markdown sin formato en la respuesta del chat, a menos que la generación de archivos no esté disponible) utilizando solo node:fs y node:zlib en el orden de Capas constructivas de 5 pasos:
- Paso 1: Cimientos, pilotes y losas de piso.
- Paso 2: Pilares de marco, paredes exteriores, ventanas, balcones y puertas (
placeDoor). - Paso 3: Techo (con voladizo de 1 bloque) y chimenea exterior (con remate de 4 lados).
- Paso 4: Escaleras (
shape: 'straight'), recortes exactos del piso del hueco de la escalera, barandillas de seguridad ycarveStairHeadroom(). - Paso 5: Muebles interiores (dentro de los límites de la habitación),
placeBed(), accesorios de pared, iluminación, seguido deautoConnectStairs(),autoPairDoubleDoors(),connectDoubleChests(),connectWalls()yconnectFencesAndPanes().
No incluyas funciones de validación throw new Error en tiempo de ejecución para que el script siempre se ejecute limpiamente. Concluye siempre con breves instrucciones de ejecución, vista previa en el visor 3D Shulkr (https://www.shulkr.com/en/viewer) y comandos de carga del Structure Block de Minecraft.
Plantilla .mjs autónoma
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 la traducción]