CommunityCodierung & Entwicklunggithub.com

Minecraft-Builder-Img

Analysiert ein hochgeladenes Bild oder einen Screenshot eines Minecraft-Baus, ermittelt dessen genaue Maße, Blockpalette, Dachprofil, Fassadentiefe und verdeckte Rückseite/Innenräume in einem detaillierten Komponenten-Manifest und einer Koordinaten-Anker-Tabelle und erstellt sofort eine herunterladbare, eigenständige, null-Abhängigkeiten Node.js-Datei (.mjs), die eine Vanilla-Minecraft-.nbt-Strukturdatei (Minecraft 26.3 / DataVersion 5023) generiert – ohne Rückfragen.

Was ist Minecraft-Builder-Img?

Der Skill **minecraft-builder-img** dient der visuellen Analyse und Nachbildung von Minecraft-Strukturen aus Bildern oder Screenshots. Er ist besonders nützlich, wenn ein Benutzer ein Bild eines Bauwerks (Haus, Statue, Möbelstück, Monument etc.) hochlädt und eine exakte, sofort verwendbare .nbt-Datei oder einen JavaScript-Generator erhalten möchte. Der Skill vermeidet Rückfragen und arbeitet in einem einzigen Durchlauf: Er erstellt ein detailliertes Komponenten-Manifest (Maße, Materialien, Dachform, Innenaufteilung), verifiziert alle Block-IDs gegen die aktuelle Minecraft 26.3 Block-Registry, erstellt eine Koordinaten-Anker-Tabelle und generiert schließlich eine eigenständige ESM-Datei (.mjs) mit 5-Pass-Konstruktionslogik. Der Skill unterstützt die Analyse von mehrtafeligen technischen Referenzblättern und kann verdeckte Rückseiten und Innenräume symmetrisch oder funktional rekonstruieren.

Funktioniert mit✓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 Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Minecraft Image Builder

Dekonstruieren Sie jedes hochgeladene Bild oder jeden Screenshot einer Minecraft-Struktur in ein exaktes Komponenten-Manifest, eine Koordinaten-Anker-Tabelle und eine herunterladbare, eigenständige, null-Abhängigkeiten ESM-Datei (.mjs) (unter Verwendung des Dateigenerierungs-Tools, anstatt rohe Codeblöcke in den Chat zu werfen), die eine gzip-komprimierte Vanilla-.nbt-Datei für Minecraft 26.3 (DataVersion: 5023) sofort in einem einzigen Durchlauf ohne Rückfragen exportiert.

Wann verwenden

  • Der Benutzer stellt ein Bild, einen Screenshot oder eine Darstellung eines Minecraft-Baus (Haus, Hütte, Turm, Brücke, Brunnen, Statue, Möbel, Tempel oder Gebäudekomplex) bereit und bittet darum, diesen in .nbt oder Node.js-Code nachzubilden, zu kopieren, zu dekonstruieren oder zu generieren.
  • Der Benutzer möchte eine direkte visuelle Aufschlüsselung + strukturierte Block-/Komponentenliste + sofortige .mjs-Datei als Ausgabe ohne Hin- und Her-Rückfragen.

Nicht im Fokus

  • Reine Text-Ideation aus dem Nichts (kein Bild bereitgestellt) – leiten Sie an minecraft-builder für Brainstorming und architektonischen Entwurf von Grund auf weiter.
  • Redstone-Schaltungen, benutzerdefiniertes Gelände/Terraforming, Kisten-NBT-Inhalte oder Entitäten-Posing – geben Sie die Einschränkung klar an und rekonstruieren Sie stattdessen die statische Blockschale.

Ordnerstruktur

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

Arbeitsablauf (Direkte Ausführung – Kein Brainstorming)

Stellen Sie keine klärenden Fragen oder Brainstorming-Fragen, wenn ein Bild bereitgestellt wird. Führen Sie alle vier Phasen nacheinander in einer einzigen Antwort aus:

Phase 1: Tiefgehende visuelle Aufschlüsselung & Komponenten-Manifest

Untersuchen Sie das Bild sorgfältig von unten nach oben und von vorne nach hinten, und geben Sie dann ein prägnantes, strukturiertes Blaupausen- & Komponenten-Manifest aus:

  1. Mehrtafeliges technisches Datenblatt & Achsenausrichtung (falls zutreffend):
    • Wenn das hochgeladene Bild eine mehrtafelige technische Referenztafel ist (z. B. 01. VORDERE-RECHTS 3/4 ANSICHT, 02. HINTERE-LINKE 3/4 ANSICHT, 03. INNENANSICHT / STRUKTURELLE DETAILANSICHT), synthetisieren Sie alle Tafeln zusammen, anstatt sie als separate Bauten zu behandeln.
    • Sperren Sie die Ausrichtung von X, Y und Z streng am 3D-XYZ-Achsen-Gizmo von Tafel 01 (rot X, grün Y nach oben, blau Z) und an allen "VORNE"-Bodenmarkierungen. Ignorieren Sie gespiegelte oder doppelte Gizmo-Pfeile in Tafel 02, wenn diese mit der Kamerarotation von Tafel 01 kollidieren.
    • Vergleichen Sie Tafel 01 und Tafel 02, um alle 4 Außenfassaden ohne Raten zu extrahieren, und priorisieren Sie das Schnittbild-Layout von Tafel 03 für Innentrennwände, Treppenhäuser und Möbelplatzierung.
    • Ignorieren Sie versehentliche doppelte Requisiten in Tafel 03 (wie eine zusätzliche Laterne oder ein Schild), die nicht sowohl in Tafel 01 als auch in Tafel 02 vorkommen.
  2. Gesamtabmessungen & Proportionen (Gitter-Triangulation):
    • Schätzen Sie den exakten Begrenzungsrahmen SIZE = [W, H, L], indem Sie sichtbare Blöcke entlang der Breite (X), Höhe (Y) und Tiefe (Z) zählen, wobei die Proportionen naturgetreu zum Screenshot bleiben.
    • Wenn Wände oder Oberflächen in einem KI-generierten Referenzbild glatt/nicht-voxel erscheinen, triangulieren Sie die exakte Blockanzahl aus den 1x1-Bodenrasterlinien, Eckrahmenpfeilern, Fensterscheiben und Dachtreppen, anstatt aus der glatten Wandhöhe zu raten.
    • Definieren Sie die Höhendatumsstufen: Y_base, Y_floor1, Y_floor2 (falls mehrstöckig), Y_roof_start und Y_roof_peak.
  3. Materialpaletten-Aufschlüsselung (abgeglichen mit registry_26_3.json):
    • Fundament / Sockel: z. B. cobblestone, stone_bricks, tuff_bricks, deepslate_bricks.
    • Rahmenpfeiler & Balken: z. B. oak_log, spruce_log, stripped_dark_oak_log mit axis.
    • Primäre & Sekundäre Wände: z. B. oak_planks, white_concrete, calcite, mud_bricks.
    • Dachdeckung & Verkleidung: z. B. spruce_stairs, brick_stairs, deepslate_tile_stairs, Platten und Überhangverkleidungen.
    • Öffnungen, Beleuchtung & Außendetails: Fenster (glass_pane), Fensterläden (*_trapdoor), Türen (*_door), Zäune/Mauern, Laternen, Schornsteine, Blattwerk/Ranken und dekorative Requisiten, die im Bild sichtbar sind.
  4. Plan zur Rekonstruktion der Rückseite & des Innenraums (verdeckte Seiten):
    • Für alle Flächen oder Innenecken, die über alle Tafeln hinweg noch verborgen sind, leiten Sie ein symmetrisches oder funktional kohärentes Layout ab (passender Fensterrhythmus und Dachneigung) und möblieren Sie den Innenraum sauber nach dem Sims-Navigationsstandard (Betten/Arbeitsplätze/Displays, Beleuchtung alle 4x4 Bereiche und begehbare 1x2 Pfade), ohne den Benutzer zu fragen.

Phase 2: Block-Registry-Überprüfung (registry_26_3.json)

  • Überprüfen Sie jede ausgewählte Block-ID (minecraft:<name>) und jeden Zustandseigenschaft gegen registry_26_3.json im Skill-Verzeichnis (Minecraft 26.3 / DataVersion: 5023).
  • Erfinden Sie niemals Block-IDs oder Enumerationswerte. Wenn eine modifizierte, glatte oder nicht-voxel Requisite im Screenshot erscheint (z. B. glatte Putzwand, Klimaanlage, Kühlschrank, Textschild), übersetzen Sie sie in die nächstgelegene gültige Vanilla-26.3-Blockkombination aus registry_26_3.json und notieren Sie die Zuordnung im Komponenten-Manifest.

Phase 3: Koordinaten-Anker-Tabelle & 5-Pass-Konstruktionsregeln

Ordnen Sie das Komponenten-Manifest vor dem Schreiben des Codes in eine exakte Koordinaten-Anker-Tabelle (X, Y, Z) ein:

  1. Hülle & Rahmenpfeiler: Eckpfeiler-Koordinaten (X, Z) und Außenwandebenen.
  2. Innenraumboden-Grenzen (X_min..X_max, Z_min..Z_max): Stellen Sie sicher, dass alle Innenmöbel streng innerhalb von X_wall_west + 1 .. X_wall_east - 1 und Z_wall_north + 1 .. Z_wall_south - 1 bleiben, sodass Durchlauf 5 niemals Wände überschreibt.
  3. Türen, Fenster & Balkone: Exakte (X, Y, Z) + facing, halten Sie 1-2 begehbare Bodenfliesen vor und hinter Türen/Toren frei, und stellen Sie sicher, dass jeder eingezäunte Balkon innerhalb seines äußeren Geländers >= 1 begehbare Bodenreihe hat (depth >= 2).
  4. Treppenhäuser & Dachfirst-Ausrichtung:
    • Sperren Sie begehbare Treppenstufen und Treppensitzplätze mit explizitem shape: 'straight', sodass autoConnectStairs() nur Dachtreppen formt.
    • Jedes Treppenhaus, das in ein oberes Stockwerk/Dachgeschoss mit Schrägdach aufsteigt, MUSS unter dem hohen mittleren Dachfirst (Y_roof_peak) enden, damit carveStairHeadroom(x, y, z, 3) niemals die äußere Dachschräge durchschlägt.
    • Verwenden Sie für Wendeltreppen einen flachen 1x1 (L-Wendel) oder 1x2 (U-Wendel) Vollblock-Absatz, der bündig mit der obersten Stufe von Flug 1 (Y_turn) abschließt, halten Sie 2 Blöcke Luft über flachen Absätzen und beginnen Sie Flug 2 bei Y_turn + 1.
    • Entfernen Sie obere Bodenfliesen nur direkt über aufsteigenden Stufen, wo step.y + 3 >= Y_upper gilt, und grenzen Sie die offene Treppenhauskante mit einem *_fence-Sicherheitsgeländer ab.
  5. Diskrete Gitter-Nachbarschaft & Schornsteinkappe:
    • Wandmontierte Gegenstände (wall_torch, *_wall_sign, ladder, trapdoor-Fensterläden, vine) belegen den benachbarten Luftblock (X_wall +/- 1 oder Z_wall +/- 1) und überschreiben niemals Wandblöcke.
    • Überprüfen Sie bei äußeren Schornsteinen, die über den Dachfirst hinausragen, alle 4 horizontalen Nachbarn um das obere campfire und platzieren Sie offene *_trapdoor (open: 'true', half: 'top') auf jeder Seite, die an air grenzt.

Phase 4: Sofortige eigenständige .mjs-Datei-Ausgabe & Ausführungsanweisungen

Generieren und exportieren Sie die vollständige, in sich geschlossene ESM-Datei (<build-name>.mjs) als herunterladbare .mjs-Datei (verwenden Sie das file_gen-Tool, falls verfügbar – geben Sie KEINEN vollständigen .mjs-Quellcode als rohen Markdown-Codeblock in der Chat-Antwort aus, es sei denn, die Dateigenerierung ist nicht verfügbar) unter ausschließlicher Verwendung von node:fs und node:zlib in der Reihenfolge des 5-Pass-Konstruktionsschichtung:

  • Durchlauf 1: Fundament, Pfähle und Bodenplatten.
  • Durchlauf 2: Rahmenpfeiler, Außenwände, Fenster, Balkone und Türen (placeDoor).
  • Durchlauf 3: Dach (mit 1-Block-Überhang) und Außenschornstein (mit 4-seitiger Kappe).
  • Durchlauf 4: Treppenhäuser (shape: 'straight'), exakte Treppenhaus-Bodenaussparungen, Sicherheitsgeländer und carveStairHeadroom().
  • Durchlauf 5: Innenmöbel (innerhalb der Raumgrenzen), placeBed(), wandmontierte Anbauteile, Beleuchtung, gefolgt von autoConnectStairs(), autoPairDoubleDoors(), connectDoubleChests(), connectWalls() und connectFencesAndPanes().

Fügen Sie keine Laufzeit-throw new Error-Validierungsfunktionen ein, damit das Skript immer sauber ausgeführt wird. Schließen Sie immer mit kurzen Befehlen zum Ausführen, zur Vorschau im Shulkr 3D Viewer (https://www.shulkr.com/en/viewer) und zum Laden im Minecraft-Strukturblock ab.

Eigenständige .mjs-Vorlage

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);
    }

…

[aus Platzgründen gekürzt]

Individual skills in this repo

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

Verwandte Skills