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
.nbtoder 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-builderfü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:
- 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,YundZstreng am 3D-XYZ-Achsen-Gizmo von Tafel 01 (rotX, grünYnach oben, blauZ) 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.
- Wenn das hochgeladene Bild eine mehrtafelige technische Referenztafel ist (z. B.
- 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_startundY_roof_peak.
- Schätzen Sie den exakten Begrenzungsrahmen
- 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_logmitaxis. - 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.
- Fundament / Sockel: z. B.
- 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
4x4Bereiche und begehbare1x2Pfade), ohne den Benutzer zu fragen.
- 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
Phase 2: Block-Registry-Überprüfung (registry_26_3.json)
- Überprüfen Sie jede ausgewählte Block-ID (
minecraft:<name>) und jeden Zustandseigenschaft gegenregistry_26_3.jsonim 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.jsonund 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:
- Hülle & Rahmenpfeiler: Eckpfeiler-Koordinaten
(X, Z)und Außenwandebenen. - Innenraumboden-Grenzen (
X_min..X_max,Z_min..Z_max): Stellen Sie sicher, dass alle Innenmöbel streng innerhalb vonX_wall_west + 1 .. X_wall_east - 1undZ_wall_north + 1 .. Z_wall_south - 1bleiben, sodass Durchlauf 5 niemals Wände überschreibt. - Türen, Fenster & Balkone: Exakte
(X, Y, Z)+facing, halten Sie1-2begehbare Bodenfliesen vor und hinter Türen/Toren frei, und stellen Sie sicher, dass jeder eingezäunte Balkon innerhalb seines äußeren Geländers>= 1begehbare Bodenreihe hat (depth >= 2). - Treppenhäuser & Dachfirst-Ausrichtung:
- Sperren Sie begehbare Treppenstufen und Treppensitzplätze mit explizitem
shape: 'straight', sodassautoConnectStairs()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, damitcarveStairHeadroom(x, y, z, 3)niemals die äußere Dachschräge durchschlägt. - Verwenden Sie für Wendeltreppen einen flachen
1x1(L-Wendel) oder1x2(U-Wendel) Vollblock-Absatz, der bündig mit der obersten Stufe von Flug 1 (Y_turn) abschließt, halten Sie2Blöcke Luft über flachen Absätzen und beginnen Sie Flug 2 beiY_turn + 1. - Entfernen Sie obere Bodenfliesen nur direkt über aufsteigenden Stufen, wo
step.y + 3 >= Y_uppergilt, und grenzen Sie die offene Treppenhauskante mit einem*_fence-Sicherheitsgeländer ab.
- Sperren Sie begehbare Treppenstufen und Treppensitzplätze mit explizitem
- Diskrete Gitter-Nachbarschaft & Schornsteinkappe:
- Wandmontierte Gegenstände (
wall_torch,*_wall_sign,ladder,trapdoor-Fensterläden,vine) belegen den benachbarten Luftblock (X_wall +/- 1oderZ_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
campfireund platzieren Sie offene*_trapdoor(open: 'true',half: 'top') auf jeder Seite, die anairgrenzt.
- Wandmontierte Gegenstände (
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 undcarveStairHeadroom(). - Durchlauf 5: Innenmöbel (innerhalb der Raumgrenzen),
placeBed(), wandmontierte Anbauteile, Beleuchtung, gefolgt vonautoConnectStairs(),autoPairDoubleDoors(),connectDoubleChests(),connectWalls()undconnectFencesAndPanes().
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]