CommunityProgramación y desarrollogithub.com

Minecraft Image Builder

Analiza una imagen o captura de pantalla de una construcción de Minecraft, aplica ingeniería inversa para obtener sus dimensiones exactas, paleta de bloques, perfil de techo, profundidad de fachada y plano interior/trasero oculto, generando un Component Manifest, una Coordinate Anchor Table y un archivo Node.js (.mjs) descargable que exporta un archivo .nbt para Minecraft 26.3 (DataVersion 5023) sin hacer preguntas.

¿Qué es Minecraft Image Builder?

Minecraft Image Builder es una habilidad para agentes de IA (compatible con plataformas como Claude Code, Cursor o Codex) diseñada para procesar imágenes o capturas de pantalla de construcciones de Minecraft y generar automáticamente un archivo .nbt funcional, sin requerir entrada adicional del usuario. Cuando un usuario proporciona una imagen de una estructura (casa, estatua, mueble, etc.), el agente realiza un análisis visual profundo: deduce las dimensiones exactas (ancho, alto, profundidad), la paleta de materiales (usando el registro de bloques de Minecraft 26.3), el perfil del techo y los detalles de la fachada. Además, infiere la disposición de las paredes traseras y el interior, incluso si están ocultos, utilizando principios de simetría y navegación estándar. Luego, genera un Component Manifest detallado y una Coordinate Anchor Table, y produce un archivo Node.js (formato ESM, .mjs) autocontenido y sin dependencias que, al ejecutarse, crea un archivo .nbt comprimido con gzip, listo para cargar en Minecraft mediante un Structure Block. Todo el proceso se realiza en una sola pasada, sin preguntas de clarificación, lo que lo hace ideal para usuarios que desean una recreación rápida y precisa de una construcción a partir de una imagen.

Compatible con✓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 Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿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 .nbt o código Node.js.
  • El usuario desea un desglose visual directo + una lista estructurada de bloques/componentes + un archivo .mjs de salida inmediato sin idas y vueltas.

Fuera del alcance

  • Ideación solo textual desde cero (sin imagen proporcionada): delegar a minecraft-builder para 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:

  1. 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, Y y Z estrictamente al gizmo de ejes 3D del Panel 01 (rojo X, verde Y hacia arriba, azul Z) 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.
  2. 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_start y Y_roof_peak.
  3. 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_log con axis.
    • 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.
  4. 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 4x4 y caminos 1x2 transitables) sin preguntar al usuario.

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 con registry_26_3.json en 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.json y 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:

  1. Carcasa y pilares de marco: Coordenadas de los postes de las esquinas (X, Z) y planos de las paredes exteriores.
  2. Límites del piso interior (X_min..X_max, Z_min..Z_max): Asegúrate de que todos los muebles interiores permanezcan estrictamente dentro de X_wall_west + 1 .. X_wall_east - 1 y Z_wall_north + 1 .. Z_wall_south - 1 para que el Paso 5 nunca sobrescriba las paredes.
  3. Puertas, ventanas y balcones: Coordenadas exactas (X, Y, Z) + facing, manteniendo 1-2 casillas de piso transitables despejadas delante y detrás de puertas/portones, y asegurando que cualquier balcón con valla tenga >= 1 fila de piso transitable dentro de su baranda exterior (depth >= 2).
  4. 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 que autoConnectStairs() 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 que carveStairHeadroom(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) o 1x2 (giro en U) al mismo nivel que el escalón superior del Vuelo 1 (Y_turn), manteniendo 2 bloques de aire sobre los rellanos planos y comenzando el Vuelo 2 en Y_turn + 1.
    • Elimina las casillas del piso superior solo directamente sobre los escalones ascendentes donde step.y + 3 >= Y_upper y bordea el borde abierto del hueco de la escalera con una barandilla de seguridad *_fence.
  5. Adyacencia discreta de la cuadrícula y remate de la chimenea:
    • Los elementos montados en la pared (wall_torch, *_wall_sign, ladder, contraventanas trapdoor, vine) ocupan el bloque de aire adyacente (X_wall +/- 1 o Z_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 campfire superior y coloca *_trapdoor abiertos (open: 'true', half: 'top') en cada lado que linde con air.

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 y carveStairHeadroom().
  • Paso 5: Muebles interiores (dentro de los límites de la habitación), placeBed(), accesorios de pared, iluminación, seguido de autoConnectStairs(), autoPairDoubleDoors(), connectDoubleChests(), connectWalls() y connectFencesAndPanes().

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]

Individual skills in this repo

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

Skills relacionados