Que fait Constructeur Minecraft par Image ?
Analyse rétro-ingénierie de toute image ou capture d'écran d'une structure Minecraft en un Manifeste de Composants, une Table de Coordonnées d'Ancrage, et un fichier ESM autonome et sans dépendance (.mjs) (en utilisant l'outil de génération de fichiers plutôt que de vider du code brut dans le chat) qui exporte un fichier .nbt compressé gzip pour Minecraft 26.3 (DataVersion: 5023) immédiatement en un seul passage sans poser de questions.
Quand l'utiliser
- L'utilisateur fournit une image, une capture d'écran ou un rendu d'une construction Minecraft (maison, chalet, tour, pont, puits, statue, meuble, temple ou complexe) et demande de recréer, copier, rétro-ingénierie, ou générer en
.nbtou code Node.js. - L'utilisateur souhaite une analyse visuelle directe + une liste structurée de blocs/composants + un fichier
.mjsimmédiat sans aller-retour de clarification.
Hors du champ d'application
- Idéation purement textuelle à partir de zéro (aucune image fournie) - renvoyer vers
minecraft-builderpour le brainstorming et la conception architecturale de zéro. - Circuits de redstone, terraformation personnalisée, contenu NBT de coffres, ou pose d'entités - indiquer clairement la limitation et reconstruire la coque statique de blocs à la place.
Structure des dossiers
minecraft-image-builder/
├── SKILL.md
└── registry_26_3.json
Flux de travail (Exécution directe - Pas de brainstorming)
Ne posez pas de questions de clarification ou de brainstorming lorsqu'une image est fournie. Exécutez les quatre phases séquentiellement en une seule réponse :
Phase 1 : Analyse visuelle approfondie et manifeste des composants
Inspectez attentivement l'image de bas en haut et d'avant en arrière, puis produisez un Blueprint et un Manifeste des Composants concis et structuré :
- Fiche technique multi-panneaux et alignement des axes (si applicable) :
- Lorsque l'image téléchargée est une fiche technique de référence multi-panneaux (par exemple,
01. VUE 3/4 AVANT-DROITE,02. VUE 3/4 ARRIÈRE-GAUCHE,03. VUE INTÉRIEURE / DÉTAILS STRUCTURELS), synthétisez tous les panneaux ensemble plutôt que de les traiter comme des constructions séparées. - Verrouillez l'orientation
X,YetZstrictement sur le gizmo d'axe 3D du panneau 01 (rougeX, vertYvers le haut, bleuZ) et toute étiquette de sol"AVANT". Ignorez les flèches de gizmo inversées ou en double dans le panneau 02 si elles entrent en conflit avec la rotation de la caméra du panneau 01. - Recoupez le panneau 01 et le panneau 02 pour extraire les 4 façades extérieures sans deviner, et priorisez le plan en coupe du panneau 03 pour les cloisons intérieures, les escaliers et le placement des meubles.
- Ignorez les accessoires en double accidentels dans le panneau 03 (comme une lanterne ou un panneau supplémentaire) qui n'apparaissent pas à la fois dans le panneau 01 et le panneau 02.
- Lorsque l'image téléchargée est une fiche technique de référence multi-panneaux (par exemple,
- Dimensions générales et proportions (triangulation de grille) :
- Estimez la boîte englobante exacte
SIZE = [W, H, L]en comptant les blocs visibles le long de la largeur (X), la hauteur (Y) et la profondeur (Z), en gardant des proportions non-1:1:1 fidèles à la capture d'écran. - Si les murs ou les surfaces semblent lisses/non-voxel dans une image de référence générée par IA, triangulez les nombres exacts de blocs à partir des lignes de grille au sol de
1x1, des piliers d'encadrement d'angle, des vitres et des marches de toit plutôt que de deviner à partir de la hauteur de mur lisse. - Définissez les niveaux de données d'élévation :
Y_base,Y_floor1,Y_floor2(si plusieurs étages),Y_roof_startetY_roof_peak.
- Estimez la boîte englobante exacte
- Analyse de la palette de matériaux (correspondant à
registry_26_3.json) :- Fondation / Socle : par exemple,
cobblestone,stone_bricks,tuff_bricks,deepslate_bricks. - Piliers d'encadrement et poutres : par exemple,
oak_log,spruce_log,stripped_dark_oak_logavecaxis. - Murs primaires et secondaires : par exemple,
oak_planks,white_concrete,calcite,mud_bricks. - Toiture et garnitures : par exemple,
spruce_stairs,brick_stairs,deepslate_tile_stairs, dalles et garnitures de débord. - Ouvertures, éclairage et détails extérieurs : fenêtres (
glass_pane), volets (*_trapdoor), portes (*_door), clôtures/murs, lanternes, cheminées, feuillage/plantes grimpantes et accessoires décoratifs visibles sur la photo.
- Fondation / Socle : par exemple,
- Plan de reconstruction arrière et intérieur (côtés occultés) :
- Pour toutes les faces ou coins intérieurs encore cachés à travers tous les panneaux, déduisez une disposition symétrique ou fonctionnellement cohérente (correspondant au rythme des fenêtres et à la pente du toit) et meublez l'intérieur proprement en suivant La norme de navigation des Sims (lits/postes de travail/écrans, éclairage tous les
4x4de surface, et chemins praticables de1x2) sans demander à l'utilisateur.
- Pour toutes les faces ou coins intérieurs encore cachés à travers tous les panneaux, déduisez une disposition symétrique ou fonctionnellement cohérente (correspondant au rythme des fenêtres et à la pente du toit) et meublez l'intérieur proprement en suivant La norme de navigation des Sims (lits/postes de travail/écrans, éclairage tous les
Phase 2 : Vérification du registre des blocs (registry_26_3.json)
- Vérifiez chaque ID de bloc choisi (
minecraft:<name>) et propriété d'état par rapport àregistry_26_3.jsondans le répertoire de la compétence (Minecraft 26.3 /DataVersion: 5023). - N'inventez jamais d'ID de bloc ou de valeurs d'énumération. Si un accessoire moddé, lisse ou non-voxel apparaît dans la capture d'écran (par exemple, mur en plâtre lisse, climatiseur, réfrigérateur d'affichage, panneau de texte), traduisez-le en la combinaison de blocs vanilla 26.3 valide la plus proche à partir de
registry_26_3.jsonet notez le mappage dans le Manifeste des Composants.
Phase 3 : Table de coordonnées d'ancrage et règles constructives en 5 passes
Mappez le manifeste des composants en une Table de coordonnées d'ancrage (X, Y, Z) exacte avant d'écrire le code :
- Coque et piliers d'encadrement : Coordonnées des poteaux d'angle
(X, Z)et plans des murs extérieurs. - Limites du sol intérieur (
X_min..X_max,Z_min..Z_max) : Assurez-vous que tous les meubles intérieurs restent strictement à l'intérieur deX_mur_ouest + 1 .. X_mur_est - 1etZ_mur_nord + 1 .. Z_mur_sud - 1afin que la Passe 5 n'écrase jamais les murs. - Portes, fenêtres et balcons :
(X, Y, Z)exact +facing, en gardant1-2dalles de sol praticables dégagées devant et derrière les portes/portails, et en s'assurant que tout balcon clôturé a>= 1rangée de sol praticable à l'intérieur de sa rambarde extérieure (depth >= 2). - Alignement des escaliers et du faîte du toit :
- Verrouillez les marches d'escalier praticables et les chaises-escaliers avec un
shape: 'straight'explicite afin queautoConnectStairs()ne façonne que les escaliers de toit. - Tout escalier montant vers un étage supérieur/grenier sous toit en pente DOIT se terminer sous la crête centrale haute du toit (
Y_roof_peak) afin quecarveStairHeadroom(x, y, z, 3)ne perce jamais la pente extérieure du toit. - Pour les escaliers tournants, utilisez un palier de bloc complet plat de
1x1(virage en L) ou1x2(virage en U) au niveau de la marche supérieure du Vol 1 (Y_turn), en gardant2blocs d'air au-dessus des paliers plats et en commençant le Vol 2 àY_turn + 1. - Supprimez les dalles d'étage supérieur uniquement directement au-dessus des marches montantes où
step.y + 3 >= Y_upperet bordez le bord ouvert de la cage d'escalier avec une rambarde de sécurité*_fence.
- Verrouillez les marches d'escalier praticables et les chaises-escaliers avec un
- Adjacence de grille discrète et capuchon de cheminée :
- Les éléments muraux (
wall_torch,*_wall_sign,ladder, voletstrapdoor,vine) occupent le bloc d'air adjacent (X_mur +/- 1ouZ_mur +/- 1), n'écrasant jamais les blocs de mur. - Pour les cheminées extérieures s'étendant au-dessus du faîte du toit, vérifiez les 4 voisins horizontaux autour du
campfiresupérieur et placez un*_trapdoorouvert (open: 'true',half: 'top') sur chaque côté bordantair.
- Les éléments muraux (
Phase 4 : Sortie immédiate du fichier .mjs autonome et instructions d'exécution
Générez et exportez le fichier ESM complet et autonome (<build-name>.mjs) en tant que fichier .mjs téléchargeable (en utilisant l'outil file_gen si disponible - ne DÉVERSEZ PAS le code source complet du .mjs en tant que bloc de code Markdown brut dans la réponse du chat, sauf si la génération de fichier n'est pas disponible) en utilisant uniquement node:fs et node:zlib dans l'ordre de Superposition constructive en 5 passes :
- Passe 1 : Fondations, pilotis et dalles de sol.
- Passe 2 : Piliers d'encadrement, murs extérieurs, fenêtres, balcons et portes (
placeDoor). - Passe 3 : Toit (avec débord de 1 bloc) et cheminée extérieure (avec capuchon à 4 côtés).
- Passe 4 : Escaliers (
shape: 'straight'), découpes exactes du sol de la cage d'escalier, rambardes de sécurité etcarveStairHeadroom(). - Passe 5 : Mobilier intérieur (dans les limites des pièces),
placeBed(), accessoires muraux, éclairage, suivi deautoConnectStairs(),autoPairDoubleDoors(),connectDoubleChests(),connectWalls()etconnectFencesAndPanes().
N'incluez pas de fonctions de validation throw new Error en temps d'exécution afin que le script s'exécute toujours proprement. Concluez toujours par de brèves instructions d'exécution, d'aperçu dans le visualiseur 3D Shulkr (https://www.shulkr.com/en/viewer) et de commandes de chargement du bloc de structure Minecraft.
Modèle de fichier .mjs autonome
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);
}
…
[README_TRUNCATED]: jQuery111305634058035924882_1743866751371205