harness 修复前后对比

# Starting point for a Minecraft build generator. Copy into the workspace and fill in build(). # Everything that has to be right for the harness is already right here: bounds checked placement, # one seeded random source, and a byte reproducible export. from __future__ import annotations import argparse import gzip import io import random import sys from pathlib import Path from typing import Dict, Iterable, Optional, Tuple sys.path.insert(0, "/work/generator/MCIO") from mcio.nbt.nbt import File as NBTFile from mcio.nbt.tag import Compound, Int, Byte, String, List as NBTList, Double, Float, IntArray from mcio.schematic import load_schematic # noqa: E402 from mcio.sketch import LitematicCanvas, Material, parse_blockstate # noqa: E402 CONFIG = { "seed": 20260923, "size_xyz": (45, 40, 35), # width X, height Y, depth Z "minecraft_version": "1.21.1", "data_version": 3955, "output": "output.litematic", "name": "Amberstone Lodge", "author": "generator", "description": "Amberstone Lodge: furnished timber and plaster lodge, forge, four connected floors and custom pines", } Position = Tuple[int, int, int] class Build: """Hold a block volume and write it out as a Litematica schematic.""" def __init__(self, size_xyz: Tuple[int, int, int] = CONFIG["size_xyz"], seed: int = CONFIG["seed"]) -> None: """Create an empty volume with one seeded random source. Args: size_xyz (Tuple[int, int, int]): Volume size as width X, height Y, depth Z. seed (int): Seed for every random decision in this build. """ self.size_x, self.size_y, self.size_z = size_xyz self.rng = random.Random(seed) self.canvas = LitematicCanvas((self.size_y, self.size_z, self.size_x)) self.placed: Dict[Position, str] = {} def inside(self, x: int, y: int, z: int) -> bool: """Report whether a coordinate is inside the volume. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: bool: True when every axis is within range. """ return 0 <= x < self.size_x and 0 <= y < self.size_y and 0 <= z < self.size_z def put(self, x: int, y: int, z: int, block: str | Material, **properties: str) -> None: """Place one block, in XYZ order, with an immediate bounds check. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. block (str | Material): Namespaced block name, a full blockstate string, or a Material. **properties: Blockstate properties such as facing or half. Raises: AssertionError: When the coordinate is outside the volume, naming the coordinate. """ assert self.inside(x, y, z), f"out of bounds: (x={x}, y={y}, z={z}) in {self.size_x}x{self.size_y}x{self.size_z}" material = self.material(block, **properties) if isinstance(block, str) else block self.canvas.block((y, z, x), material) self.placed[(x, y, z)] = material.blockstate def material(self, name: str, **properties: str) -> Material: """Build a Material from a block name and its properties. Args: name (str): Namespaced block name, or a full blockstate string. **properties: Blockstate properties. Returns: Material: Material ready for placement. """ if "[" in name: return parse_blockstate(name) return self.canvas.material(name, **dict(sorted(properties.items()))) def box(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill an inclusive box. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive on both ends. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, block, **properties) def shell(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill only the faces of a box, leaving the inside empty. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): on_face = x in (x0, x1) or y in (y0, y1) or z in (z0, z1) if on_face: self.put(x, y, z, block, **properties) def texture(self, bounds: Tuple[int, int, int, int, int, int], palette: Iterable[str]) -> None: """Fill a box with a weighted mix of related blocks, so the surface is not flat. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. palette (Iterable[str]): Block names. Repeat a name to make it more common. """ choices = list(palette) x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, self.rng.choice(choices)) def get(self, x: int, y: int, z: int) -> Optional[str]: """Read back what was placed at a coordinate. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: Optional[str]: Blockstate string, or None when the cell is empty. """ return self.placed.get((x, y, z)) def build(self) -> "Build": """Reconstruct Amberstone Lodge with sealed rooms and circulation.""" self.tiles = [] self.entities = [] self.rooms = [(18, 4, 18), (31, 4, 18), (18, 10, 22), (31, 10, 18), (31, 17, 21), (31, 24, 20)] stone = ['minecraft:stone_bricks'] * 5 + ['minecraft:cobblestone'] * 2 + ['minecraft:andesite', 'minecraft:mossy_stone_bricks'] plaster = ['minecraft:yellow_terracotta'] + ['minecraft:smooth_sandstone'] * 6 + ['minecraft:sandstone'] * 2 roof = ['minecraft:deepslate_tiles'] * 6 + ['minecraft:deepslate_bricks'] * 3 + ['minecraft:polished_deepslate'] timber = ['minecraft:spruce_planks'] * 5 + ['minecraft:dark_oak_planks'] # An irregular landscaped island avoids a rectangular grass display base. for x in range(45): for z in range(35): if ((x - 22) / 23)**4 + ((z - 18) / 18)**4 < 1.05: self.put(x, 0, z, self.rng.choice(['minecraft:grass_block'] * 7 + ['minecraft:coarse_dirt', 'minecraft:podzol'])) self.texture((7, 1, 8, 40, 2, 30), stone) self.texture((8, 3, 9, 39, 3, 29), stone) for x in range(8, 40): for z in (9, 29): self.put(x, 3, z, 'minecraft:stone_brick_slab', type='top') # Wide stair approach and a meandering gravel/ochre path. for z, y in [(8, 2), (7, 1), (6, 0)]: for x in range(28, 35): self.put(x, y, z, 'minecraft:stone_brick_stairs', facing='south') for z in range(0, 7): mid = 31 + (z // 3) % 2 for x in range(mid - 3, mid + 4): if self.rng.random() > .13: self.put(x, 0, z, self.rng.choice(['minecraft:gravel', 'minecraft:coarse_dirt', 'minecraft:packed_mud', 'minecraft:andesite'])) # Lower wing, with stone service floor and timber framed living floor. for y in range(4, 16): pal = stone if y < 9 else plaster for x in range(10, 27): for z in (10, 27): self.put(x, y, z, self.rng.choice(pal)) for z in range(10, 28): for x in (10, 26): self.put(x, y, z, self.rng.choice(pal)) for y in (3, 9, 15): self.texture((10, y, 10, 26, y, 27), timber) # Tall wing: solid gable end walls close every space under the steep roof. for x in range(26, 38): top = 23 + 2 * min(x - 24, 39 - x) for y in range(4, top + 1): for z in (12, 28): self.put(x, y, z, self.rng.choice(stone if y < 9 else plaster)) for x in (26, 37): for y in range(4, 28): for z in range(12, 29): self.put(x, y, z, self.rng.choice(stone if y < 9 else plaster)) for y in (3, 9, 16, 23): self.texture((26, y, 12, 37, y, 28), timber) # Horizontal beams and upright framing continue around hidden facades. for y in (9, 15): for z in (10, 27): self.box((10, y, z, 26, y, z), 'minecraft:stripped_spruce_log', axis='x') for x in (10, 26): self.box((x, y, 10, x, y, 27), 'minecraft:stripped_spruce_log', axis='z') for x in (10, 15, 21, 26): for z in (10, 27): self.box((x, 4, z, x, 15, z), 'minecraft:stripped_spruce_log', axis='y') for z in (12, 28): for x in (26, 31, 37): top = 23 + 2 * min(x - 24, 39 - x) self.box((x, 9, z, x, top, z), 'minecraft:stripped_spruce_log', axis='y') for y in (9, 16, 23, 28, 32): for x in range(26, 38): if y <= 23 + 2 * min(x - 24, 39 - x): self.put(x, y, z, 'minecraft:stripped_spruce_log', axis='x') for x in (26, 37): for z in (12, 18, 23, 28): self.box((x, 9, z, x, 27, z), 'minecraft:stripped_spruce_log', axis='y') for y in (9, 16, 23, 27): self.box((x, y, 12, x, y, 28), 'minecraft:stripped_spruce_log', axis='z') # Low roof, broad eaves and a continuous deck. Ends meet the tower wall. for z in range(8, 30): y = 16 + min(z - 8, 29 - z) // 2 self.texture((8, y, z, 26, y, z), roof) for x in range(8, 27): self.put(x, y + 1, z, 'minecraft:deepslate_tile_stairs', facing='south' if z < 19 else 'north') # Seal the low attic behind the overhanging roof. for z in range(10, 28): top = 16 + min(z - 8, 29 - z) // 2 for y in range(16, top + 1): for x in (10, 26): self.put(x, y, z, 'minecraft:spruce_planks') if z in (10, 27): self.box((10, y, z, 26, y, z), 'minecraft:spruce_planks') # Very steep tower roof, two blocks of rise per column. for x in range(24, 40): y = 23 + 2 * min(x - 24, 39 - x) self.texture((x, y - 1, 10, x, y + 1, 30), roof) for z in range(10, 31): self.put(x, y + 1, z, 'minecraft:deepslate_tile_stairs', facing='east' if x < 32 else 'west') for z in (10, 30): self.put(x, y, z, 'minecraft:polished_deepslate') for z in range(10, 31): for x in (31, 32): self.put(x, 39, z, 'minecraft:deepslate_tile_slab', type='bottom') # Small glazed roof dormer and ladder-accessible reading nook. self.box((17, 18, 11, 22, 18, 15), 'minecraft:spruce_planks') self.shell((17, 19, 11, 22, 21, 15), 'minecraft:spruce_planks') self.box((18, 19, 12, 21, 21, 14), 'minecraft:air') self.texture((16, 22, 10, 23, 22, 16), roof) self.box((16, 23, 10, 23, 23, 10), 'minecraft:deepslate_tile_stairs', facing='south') self.box((16, 23, 11, 23, 23, 16), 'minecraft:deepslate_tile_slab', type='bottom') for yy in range(10, 21): self.put(22, yy, 14, 'minecraft:stripped_spruce_log', axis='y') self.put(21, yy, 14, 'minecraft:ladder', facing='west') self.put(18, 19, 14, 'minecraft:barrel', facing='up') self.put(18, 20, 14, 'minecraft:lantern') self.put(19, 19, 14, 'minecraft:bookshelf') # Glazed openings and outward shutters; no roof or furniture crosses these. self.windows = [] def window(x, y, z, side='north', w=2, h=3): for a in range(w): for b in range(h): p = (x + a, y + b, z) if side in ('north', 'south') else (x, y + b, z + a) self.put(*p, 'minecraft:glass') self.windows.append(p) if side in ('north', 'south'): dz = -1 if side == 'north' else 1 for xx in (x - 1, x + w): for yy in range(y, y + h): self.put(xx, yy, z + dz, 'minecraft:spruce_trapdoor', facing=side, half='bottom', open='true') self.box((x - 1, y - 1, z + dz, x + w, y - 1, z + dz), 'minecraft:spruce_slab', type='top') else: dx = -1 if side == 'west' else 1 for zz in (z - 1, z + w): for yy in range(y, y + h): self.put(x + dx, yy, zz, 'minecraft:spruce_trapdoor', facing=side, open='true') self.box((x + dx, y - 1, z - 1, x + dx, y - 1, z + w), 'minecraft:spruce_slab', type='top') window(18, 19, 11, w=4, h=2) for x in (12, 18, 23): window(x, 11, 10) window(x, 11, 27, 'south') for y in (11, 18, 25, 29): window(33, y, 12, w=2, h=2 if y == 29 else 3) for y in (5, 11, 18, 25): window(28, y, 28, 'south', w=2, h=2) for y in (5, 11, 18): window(37, y, 20, 'east', w=2, h=2) window(10, 11, 19, 'west', w=3) window(18, 5, 10, w=2, h=2) # Proper two-half entry doors and joined rooms at both shared levels. self.doors = [] def door(x, y, z): for half, dy in [('lower', 0), ('upper', 1)]: self.put(x, y + dy, z, 'minecraft:spruce_door', half=half, facing='north', hinge='left', open='false', powered='false') self.doors.append((x, y, z)) door(31, 4, 12) door(10, 4, 16) # Side door faces west. for dy, half in [(0, 'lower'), (1, 'upper')]: self.put(10, 4 + dy, 16, 'minecraft:spruce_door', half=half, facing='west', hinge='left', open='false', powered='false') for y in (4, 10): self.box((26, y, 18, 26, y + 2, 21), 'minecraft:air') self.box((30, 6, 11, 32, 6, 11), 'minecraft:spruce_slab', type='top') # Lower-wing stairs rise southwards, with a full-height open stairwell. for i in range(6): y, z = 4 + i, 18 + i self.box((12, y, z, 13, 12, z), 'minecraft:air') self.box((12, 3, z, 13, y - 1, z), 'minecraft:spruce_planks') for x in (12, 13): self.put(x, y, z, 'minecraft:spruce_stairs', facing='south') # A backed ladder gives continuous access to all tower rooms. for y in range(4, 26): self.put(36, y, 26, 'minecraft:ladder', facing='west') self.put(37, y, 26, 'minecraft:stripped_spruce_log', axis='y') # Parquet floor fields, inset within the timber borders. for x0, x1, z0, z1, y in [(11, 25, 11, 26, 3), (14, 25, 11, 26, 9), (27, 36, 13, 27, 3), (27, 36, 13, 27, 9), (27, 36, 13, 27, 16), (27, 36, 13, 27, 23)]: for xx in range(x0, x1 + 1): for zz in range(z0, z1 + 1): if 'ladder' not in (self.get(xx, y, zz) or ''): self.put(xx, y, zz, 'minecraft:stripped_spruce_log', axis='x' if (xx // 2 + zz // 2) % 2 else 'z') # Exposed ceiling beams, well above the circulation headroom. for yy in (8, 14): for zz in (14, 20, 25): self.box((11, yy, zz, 25, yy, zz), 'minecraft:dark_oak_log', axis='x') for yy in (8, 15, 22, 28): for zz in (15, 22): self.box((27, yy, zz, 36, yy, zz), 'minecraft:dark_oak_log', axis='x') for i in range(6): for yy in range(5 + i, 7 + i): self.box((12, yy, 18 + i, 13, yy, 18 + i), 'minecraft:air') for yy in range(10, 21): self.put(21, yy, 14, 'minecraft:ladder', facing='west') # Ground storage and entry. for x in (15, 16, 22, 23): self.put(x, 4, 25, 'minecraft:barrel', facing='north') self.put(x, 5, 25, 'minecraft:barrel', facing='north') self.put(20, 4, 25, 'minecraft:crafting_table') self.put(21, 4, 25, 'minecraft:chest', facing='north', type='single') self.put(17, 4, 13, 'minecraft:smithing_table') self.put(18, 4, 13, 'minecraft:blast_furnace', facing='south', lit='true') self.put(19, 4, 13, 'minecraft:barrel', facing='up') self.put(19, 5, 13, 'minecraft:lantern') self.box((28, 4, 15, 28, 4, 17), 'minecraft:spruce_stairs', facing='east') self.box((30, 4, 15, 32, 4, 21), 'minecraft:red_carpet') self.put(34, 4, 14, 'minecraft:barrel', facing='up') self.put(34, 5, 14, 'minecraft:potted_fern') self.put(35, 4, 23, 'minecraft:chest', facing='west', type='single') # Living floor: patterned carpet, dining trestle, sofas, kitchen and book wall. for x in range(16, 23): for z in range(15, 22): self.put(x, 10, z, 'minecraft:green_carpet' if (x + z) % 3 else 'minecraft:moss_carpet') self.box((18, 10, 17, 20, 10, 19), 'minecraft:dark_oak_planks') for x in (18, 20): self.put(x, 11, 18, 'minecraft:candle', candles='2', lit='true') for x in (17, 21): for z in (17, 19): self.put(x, 10, z, 'minecraft:spruce_stairs', facing='east' if x == 17 else 'west') for x in range(16, 24): self.put(x, 10, 25, 'minecraft:barrel', facing='up') for x in (17, 21): self.put(x, 11, 25, 'minecraft:potted_blue_orchid') self.put(19, 11, 25, 'minecraft:lantern') self.box((23, 10, 12, 24, 10, 14), 'minecraft:dark_oak_stairs', facing='west') self.box((27, 10, 15, 27, 13, 17), 'minecraft:bookshelf') self.box((28, 10, 24, 32, 10, 24), 'minecraft:dark_oak_stairs', facing='north') self.put(29, 10, 21, 'minecraft:barrel', facing='up') self.put(29, 11, 21, 'minecraft:flower_pot') # Bedroom: raised green double bed, bedside storage and striped curtains. self.box((28, 17, 16, 32, 17, 19), 'minecraft:spruce_planks') for x in (29, 30): self.put(x, 18, 17, 'minecraft:green_bed', part='head', facing='north', occupied='false') self.put(x, 18, 18, 'minecraft:green_bed', part='foot', facing='north', occupied='false') for x in (28, 31): self.put(x, 18, 17, 'minecraft:barrel', facing='up') self.put(x, 19, 17, 'minecraft:lantern' if x == 28 else 'minecraft:potted_blue_orchid') for x in range(28, 33): self.put(x, 17, 20, 'minecraft:spruce_stairs', facing='north') self.box((28, 17, 16, 32, 20, 16), 'minecraft:spruce_planks') self.box((28, 21, 16, 32, 21, 16), 'minecraft:barrel', facing='south') self.box((29, 20, 16, 31, 20, 16), 'minecraft:bookshelf') for x in (32, 35): self.put(x, 20, 13, 'minecraft:white_wall_banner', facing='south') self.tiles.append(self.tile('banner', x, 20, 13, patterns=NBTList[Compound]([Compound({'pattern': String('minecraft:stripe_left'), 'color': String('green')}), Compound({'pattern': String('minecraft:stripe_right'), 'color': String('green')}), Compound({'pattern': String('minecraft:stripe_center'), 'color': String('green')})]))) self.box((33, 17, 13, 35, 17, 13), 'minecraft:dark_oak_stairs', facing='south') self.put(34, 17, 24, 'minecraft:chest', facing='north', type='single') self.box((29, 17, 22, 33, 17, 24), 'minecraft:green_carpet') # Attic study: sloped ceiling, desk, open book and shelves. self.box((28, 24, 15, 28, 26, 19), 'minecraft:bookshelf') self.box((29, 24, 15, 33, 24, 15), 'minecraft:barrel', facing='south') self.put(31, 25, 15, 'minecraft:lectern', facing='south', has_book='true') book = Compound({'id': String('minecraft:written_book'), 'count': Int(1), 'components': Compound({'minecraft:written_book_content': Compound({'title': String('Amberstone Ledger'), 'author': String('The Lodgekeeper'), 'generation': Int(0), 'resolved': Byte(1), 'pages': NBTList[Compound]([Compound({'raw': String('{"text":"Amberstone Lodge\\nProvisions, ore and woodland notes."}')})])})})}) self.tiles.append(self.tile('lectern', 31, 25, 15, Book=book, Page=Int(0))) self.put(33, 25, 15, 'minecraft:candle', candles='3', lit='true') self.put(29, 25, 15, 'minecraft:potted_fern') self.put(31, 24, 17, 'minecraft:spruce_stairs', facing='north') self.box((30, 24, 20, 33, 24, 23), 'minecraft:red_carpet') self.put(34, 24, 24, 'minecraft:chest', facing='north', type='single') self.put(28, 24, 24, 'minecraft:barrel', facing='up') # Central stone chimney breast, independent of the windows and ladder. for y in range(4, 31): self.put(35, y, 18, self.rng.choice(stone)) for y in (4, 10, 17, 24): self.put(35, y, 19, 'minecraft:smoker', facing='south', lit='true') # Greenery climbs the chimney breast in the living hall. self.put(34, 10, 20, 'minecraft:barrel', facing='up') self.put(34, 11, 20, 'minecraft:potted_azalea_bush') for yy in range(11, 15): self.put(35, yy, 17, 'minecraft:vine', south='true') # Lamps mounted on solid pedestals near each floor. for x, y, z in [(23, 4, 16), (15, 4, 23), (33, 4, 23), (33, 10, 16), (15, 10, 14), (24, 10, 23), (33, 17, 21), (30, 24, 25)]: self.put(x, y, z, 'minecraft:barrel', facing='up') self.put(x, y + 1, z, 'minecraft:lantern') # Small belongings make each room group usable, with clear walkways. self.put(15, 6, 25, 'minecraft:potted_fern') self.put(16, 6, 25, 'minecraft:candle', candles='2', lit='true') self.box((19, 4, 18, 21, 4, 21), 'minecraft:brown_carpet') self.put(16, 10, 24, 'minecraft:chest', facing='north', type='single') self.put(34, 10, 24, 'minecraft:chest', facing='north', type='single') self.put(33, 10, 24, 'minecraft:barrel', facing='up') self.put(33, 11, 24, 'minecraft:candle', candles='2', lit='true') self.box((30, 10, 19, 32, 10, 20), 'minecraft:red_carpet') self.put(34, 17, 23, 'minecraft:barrel', facing='up') self.put(34, 18, 23, 'minecraft:candle', candles='2', lit='true') # Item frames on solid interior walls, with deterministic entity UUIDs. for i, (x, y, z) in enumerate([(22, 6, 26), (22, 12, 26), (30, 6, 27), (30, 12, 27), (30, 20, 27), (30, 26, 27)]): self.entities.append(Compound({'id': String('minecraft:item_frame'), 'Pos': NBTList[Double]([Double(x + .5), Double(y + .5), Double(z + .96875)]), 'TileX': Int(x), 'TileY': Int(y), 'TileZ': Int(z), 'Facing': Byte(2), 'Rotation': NBTList[Float]([Float(180), Float(0)]), 'Motion': NBTList[Double]([Double(0)] * 3), 'UUID': IntArray([2026, 923, 100, i]), 'Item': Compound({'id': String(['minecraft:iron_axe', 'minecraft:bread', 'minecraft:compass', 'minecraft:clock', 'minecraft:feather', 'minecraft:map'][i]), 'count': Int(1)}), 'ItemRotation': Byte(0)})) # Covered blacksmith courtyard at the left, with working forge and chimney. self.texture((2, 1, 12, 9, 2, 23), stone) self.texture((2, 3, 12, 9, 3, 23), stone) for x, z in [(2, 12), (2, 23), (9, 12), (9, 23)]: self.box((x, 4, z, x, 8, z), 'minecraft:stripped_spruce_log', axis='y') for x in range(1, 10): y = 8 + (x // 4) self.texture((x, y, 11, x, y, 24), roof) self.box((3, 4, 20, 6, 4, 22), 'minecraft:stone_bricks') self.put(4, 5, 21, 'minecraft:campfire', lit='true', facing='north') self.box((3, 5, 22, 6, 8, 22), 'minecraft:stone_bricks') for x in (3, 6): self.box((x, 5, 20, x, 7, 21), 'minecraft:stone_bricks') self.box((3, 8, 20, 6, 8, 22), 'minecraft:stone_bricks') self.texture((4, 9, 21, 5, 20, 22), stone) self.box((3, 21, 20, 6, 21, 23), 'minecraft:stone_brick_slab', type='bottom') self.put(4, 22, 21, 'minecraft:cobblestone_wall') self.put(5, 22, 22, 'minecraft:cobblestone_wall') self.put(5, 4, 16, 'minecraft:anvil', facing='east') self.put(8, 4, 18, 'minecraft:blast_furnace', facing='west', lit='true') self.put(8, 4, 19, 'minecraft:smithing_table') self.put(3, 4, 13, 'minecraft:barrel', facing='up') self.put(4, 4, 13, 'minecraft:chest', facing='south', type='single') self.put(3, 5, 13, 'minecraft:lantern') # Terrace edge and lamps. for x, z in [(9, 9), (38, 9), (39, 28), (8, 28)]: self.put(x, 4, z, 'minecraft:stone_brick_wall') self.put(x, 5, z, 'minecraft:lantern') # Wall sconces attach with a full timber bracket. for x, y, z in [(29, 6, 11), (36, 6, 11), (11, 13, 9), (25, 13, 9), (38, 20, 17)]: self.put(x, y, z, 'minecraft:spruce_planks') self.put(x, y + 1, z, 'minecraft:lantern') # Climbing leaves and vines adhere to the visible stone and timber pier. for y in range(4, 18): x = 27 if y < 12 else 28 if self.get(x, y, 11) is None: self.put(x, y, 11, 'minecraft:vine', south='true') for x, y, z in [(27, 4, 11), (28, 4, 11), (27, 7, 11), (27, 10, 11), (28, 13, 11), (27, 15, 11)]: if self.get(x, y, 12) and 'glass' not in self.get(x, y, 12): self.put(x, y, z, 'minecraft:oak_leaves', persistent='true') # Handmade pine silhouettes, bare trunks and stepped whorls. for tx, tz, height in [(5, 29, 24), (3, 6, 16), (42, 26, 18)]: self.box((tx, 1, tz, tx, height, tz), 'minecraft:spruce_log', axis='y') for y in range(5, height, 3): radius = max(1, round(4 * (1 - y / height))) for dx, dz in [(1, 0), (-1, 0), (0, 1), (0, -1)]: for step in range(1, max(2, radius)): xx, zz = tx + dx * step, tz + dz * step if self.inside(xx, y, zz): self.put(xx, y, zz, 'minecraft:spruce_log', axis='x' if dx else 'z') for dx in range(-radius, radius + 1): for dz in range(-radius, radius + 1): if abs(dx) + abs(dz) <= radius + 1 and (dx or dz): xx, zz = tx + dx, tz + dz if self.inside(xx, y + 1, zz): self.put(xx, y + 1, zz, 'minecraft:spruce_leaves', persistent='true') if abs(dx) + abs(dz) >= radius and not self.get(xx, y, zz): self.put(xx, y, zz, 'minecraft:spruce_leaves', persistent='true') for dx, dz in [(1, 0), (-1, 0), (0, 1), (0, -1)]: self.put(tx + dx, y + 2, tz + dz, 'minecraft:spruce_leaves', persistent='true') self.put(tx, height + 1, tz, 'minecraft:spruce_leaves', persistent='true') for x in range(45): for z in range(35): if self.get(x, 0, z) == 'minecraft:grass_block' and not self.get(x, 1, z) and self.rng.random() < .14: self.put(x, 1, z, self.rng.choice(['minecraft:fern'] * 4 + ['minecraft:short_grass', 'minecraft:poppy', 'minecraft:dandelion'])) return self def tile(self, kind, x, y, z, **extra): """Create a positioned vanilla block entity.""" return Compound({'id': String('minecraft:' + kind), 'x': Int(x), 'y': Int(y), 'z': Int(z), **extra}) def export(self, path: Path) -> Path: """Write the schematic so that two runs produce identical bytes. Args: path (Path): Destination .litematic path. Returns: Path: The path written. """ schematic = self.canvas.to_litematica( name=CONFIG["name"], author=CONFIG["author"], description=CONFIG["description"], minecraft_data_version=CONFIG["data_version"], ) # The metadata otherwise records the current wall clock, which changes the bytes on every run. schematic.metadata.time_created = 0 schematic.metadata.time_modified = 0 path.parent.mkdir(parents=True, exist_ok=True) nbt = schematic.write_to_nbt() region = next(iter(nbt["Regions"].values())) region["TileEntities"] = NBTList[Compound](self.tiles) region["Entities"] = NBTList[Compound](self.entities) buffer = io.BytesIO() NBTFile(nbt).write(buffer) path.write_bytes(gzip.compress(buffer.getvalue(), mtime=0)) return path def verify(self, path: Path) -> Dict[str, object]: """Reload the written file and confirm it matches what was placed. Args: path (Path): Schematic to reload. Returns: Dict[str, object]: Size, block count and palette size of the reloaded file. Raises: AssertionError: When a reloaded cell differs from what was placed. """ loaded = load_schematic(path) size_y, size_z, size_x = loaded.size_yzx assert (size_x, size_y, size_z) == (self.size_x, self.size_y, self.size_z), "size changed on reload" ids = loaded.read_flat(0, loaded.volume).reshape(loaded.size_yzx) for (x, y, z), state in self.placed.items(): assert loaded.palette[int(ids[y, z, x])] == state, f"cell (x={x}, y={y}, z={z}) changed on reload" return { "size_xyz": [size_x, size_y, size_z], "placed_blocks": len(self.placed), "palette_states": len(loaded.palette), } def main() -> None: """Generate the build, export it, and verify the exported file.""" parser = argparse.ArgumentParser(description="Generate a Minecraft schematic.") parser.add_argument("--output", type=Path, default=Path(CONFIG["output"])) parser.add_argument("--seed", type=int, default=CONFIG["seed"]) args = parser.parse_args() build = Build(seed=args.seed).build() path = build.export(args.output) report = build.verify(path) print(f"wrote {path}: {report}") if __name__ == "__main__": main()

# Crop the exported schematic for repeatable room inspections. from pathlib import Path from generate import LitematicCanvas, load_schematic, parse_blockstate ROOM_CROPS = { 'bedroom_detail': (26, 16, 12, 37, 21, 28), 'study_detail': (26, 23, 12, 37, 27, 28), 'workshop_detail': (2, 3, 12, 10, 7, 23), 'ground_detail': (10, 3, 10, 37, 7, 28), } def main(): """Export geometry crops for visual checking, never as final deliverables.""" loaded = load_schematic(Path('output.litematic')) ids = loaded.read_flat(0, loaded.volume).reshape(loaded.size_yzx) for name, (x0, y0, z0, x1, y1, z1) in ROOM_CROPS.items(): canvas = LitematicCanvas((y1 - y0 + 1, z1 - z0 + 1, x1 - x0 + 1)) for y in range(y0, y1 + 1): for z in range(z0, z1 + 1): for x in range(x0, x1 + 1): state = loaded.palette[int(ids[y, z, x])] canvas.block((y - y0, z - z0, x - x0), parse_blockstate(state)) canvas.save(Path('previews') / f'{name}.litematic', name=name) if __name__ == '__main__': main()

// Starting point for rendering a build. Copy into the workspace and edit VIEWS. // Lighting, camera framing and background are already tuned; run it as is to get a first look. import fs from 'node:fs'; import path from 'node:path'; import { createRequire } from 'node:module'; import { createRenderScene, renderLitematicWithMetadata } from '/work/generator/MCRender/src/headless/index.ts'; const RENDER_ROOT = '/work/generator/MCRender'; const requireRenderer = createRequire(path.join(RENDER_ROOT, 'package.json')); const { PNG } = requireRenderer('pngjs'); // vite-node passes script arguments after a bare "--", so drop it before reading them. const argv = process.argv.slice(2).filter(entry => entry !== '--'); const INPUT = argv[0] ?? 'output.litematic'; const OUT_DIR = argv[1] ?? 'previews'; const SIZE = Number(process.env.RENDER_SIZE ?? 512); // Tuned defaults. Ambient near 0.72 keeps shaded faces readable, and a light direction with a // dominant +Y term plus a small +X/+Z tilt separates roof, wall and ground planes. const LIGHT_DIRECTION = [0.08, 0.28, 0.15]; const AMBIENT = 0.72; const BACKGROUND = [47, 52, 59, 255]; const VIEWS = [ { name: 'front', azimuth: 210, elevation: 18, radius: 3.3 }, { name: 'rear', azimuth: 35, elevation: 22, radius: 3.3 }, { name: 'side', azimuth: 120, elevation: 14, radius: 3.3 }, { name: 'top', azimuth: 210, elevation: 62, radius: 3.4 }, ]; // Resolve every path while the working directory is still the caller's. const absoluteInput = path.resolve(INPUT); const absoluteOutDir = path.resolve(OUT_DIR); fs.mkdirSync(absoluteOutDir, { recursive: true }); // The renderer looks for its resource cache relative to the working directory, so move there first, // and only then create the scene. process.chdir(RENDER_ROOT); const scene = createRenderScene({ width: SIZE, height: SIZE }); for (const view of VIEWS) { const result = renderLitematicWithMetadata(absoluteInput, { width: SIZE, height: SIZE, fov_deg: 30, radius: view.radius, nRandomAzimuths: 0, azimuthInit: 0, elevationInit: 0, azimuthsDeltas: [view.azimuth], elevationsDeltas: [view.elevation], ambientIntensities: [AMBIENT], lightDirections: [LIGHT_DIRECTION], mirror: [false], layout: [[0]], limit: 512, seed: 0, opaque: false, }, scene); // Flatten onto an opaque background so shaded faces keep their contrast. for (let i = 0; i < result.png.data.length; i += 4) { const alpha = result.png.data[i + 3] / 255; for (let channel = 0; channel < 3; channel++) { result.png.data[i + channel] = Math.round(result.png.data[i + channel] * alpha + BACKGROUND[channel] * (1 - alpha)); } result.png.data[i + 3] = 255; } const target = path.join(absoluteOutDir, `${view.name}.png`); fs.writeFileSync(target, PNG.sync.write(result.png)); console.log(`wrote ${target} (${SIZE}x${SIZE}, azimuth ${view.azimuth}, elevation ${view.elevation})`); }

# Validate the exported lodge, including circulation, support and saved NBT. import sys from collections import deque from pathlib import Path import pytest ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) from generate import Build, CONFIG, load_schematic from mcio.nbt.nbt import load @pytest.fixture(scope='module') def data(): """Read the actual deliverable and its planned layout.""" build = Build().build() schematic = load_schematic(ROOT / 'output.litematic') ids = schematic.read_flat(0, schematic.volume).reshape(schematic.size_yzx) states = {(x, y, z): schematic.palette[int(ids[y, z, x])] for y in range(40) for z in range(35) for x in range(45)} return build, states, load(ROOT / 'output.litematic') def name(state): return state.split('[')[0].removeprefix('minecraft:') def props(state): return dict(p.split('=') for p in state.split('[')[1].rstrip(']').split(',')) if '[' in state else {} def test_export_and_version(data): b, cells, nbt = data assert int(nbt['MinecraftDataVersion']) == 3955 assert len(nbt['Regions']) == 1 assert b.verify(ROOT / 'output.litematic')['placed_blocks'] > 9500 assert tuple(map(int, nbt['Metadata']['EnclosingSize'].values())) == (45, 40, 35) assert len({name(s) for s in cells.values()}) > 55 def test_doors_and_beds(data): _, cells, _ = data doors = beds = 0 delta = {'north': (0, -1), 'south': (0, 1), 'west': (-1, 0), 'east': (1, 0)} for (x, y, z), state in cells.items(): n, p = name(state), props(state) if n.endswith('_door'): other = cells[x, y + (1 if p['half'] == 'lower' else -1), z] q = props(other) assert name(other) == n and p['half'] != q['half'] assert all(p[k] == q[k] for k in ('facing', 'hinge', 'open', 'powered')) if p['half'] == 'lower': assert name(cells[x, y - 1, z]) != 'air' doors += 1 if n.endswith('_bed'): dx, dz = delta[p['facing']] sign = 1 if p['part'] == 'foot' else -1 other = cells[x + sign * dx, y, z + sign * dz] q = props(other) assert name(other) == n and q['part'] != p['part'] and q['facing'] == p['facing'] assert name(cells[x, y - 1, z]) != 'air' beds += 1 assert doors == 2 and beds == 4 def test_sealed_envelope(data): b, cells, _ = data # Flood only actual air from all six volume faces. Closed doors/glass block entry. outside = set() todo = deque() for p, s in cells.items(): x, y, z = p if name(s) == 'air' and (x in (0, 44) or y in (0, 39) or z in (0, 34)): outside.add(p) todo.append(p) while todo: x, y, z = todo.popleft() for dx, dy, dz in ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)): p = (x + dx, y + dy, z + dz) if p not in outside and name(cells.get(p, 'void')) == 'air': outside.add(p) todo.append(p) # Check every air voxel in occupied volumes, rather than only room centres. for (x, y, z), s in cells.items(): interior = (11 <= x <= 25 and 11 <= z <= 26 and 4 <= y <= 14) or (27 <= x <= 36 and 13 <= z <= 27 and 4 <= y < 23 + 2 * min(x - 24, 39 - x)) if interior and name(s) == 'air': assert (x, y, z) not in outside, f'Leak reaches {(x,y,z)}' def test_walkable_routes_and_ladder_clearance(data): b, cells, _ = data def passable(p): n = name(cells.get(p, 'void')) return n in ('air', 'ladder') or n.endswith(('_carpet', '_door', '_wall_banner')) def support(p): return p in cells and not passable(p) or name(cells.get(p, 'void')) == 'ladder' def stand(p): x, y, z = p return passable(p) and passable((x, y + 1, z)) and (support((x, y - 1, z)) or name(cells[p]) == 'ladder') start = (31, 4, 12) assert stand(start) seen = {start} q = deque([start]) while q: x, y, z = q.popleft() for dx, dz in ((1, 0), (-1, 0), (0, 1), (0, -1)): for dy in (-1, 0, 1): p = x + dx, y + dy, z + dz if p not in seen and stand(p): # On a one-block rise, the current column must also clear the head. if dy == 1 and not passable((x, y + 2, z)): continue seen.add(p) q.append(p) if name(cells[x, y, z]) == 'ladder': for dy in (-1, 1): p = x, y + dy, z if p not in seen and stand(p): seen.add(p) q.append(p) for p in b.rooms + [(36, 24, 26), (29, 18, 20), (31, 24, 18), (5, 4, 15), (20, 19, 14)]: assert p in seen, f'Unreachable: {p}' for y in range(4, 26): assert name(cells[36, y, 26]) == 'ladder' assert name(cells[37, y, 26]) == 'stripped_spruce_log' if y not in (9, 16, 23): assert passable((35, y, 26)) def test_openings_and_nearby_lights(data): b, cells, _ = data for p in b.windows: assert name(cells[p]) == 'glass', f'Obstructed window: {p}' x, y, z = p dx, dz = (1, 0) if x in (10, 37) else (0, 1) for sign in (-1, 1): neighbor = name(cells[x + sign * dx, y, z + sign * dz]) assert neighbor in ('air', 'white_wall_banner'), (p, neighbor) lights = [p for p, s in cells.items() if name(s) == 'lantern' or props(s).get('lit') == 'true'] for room in b.rooms: x, y, z = room assert any(abs(x - a) + abs(z - c) <= 8 and 0 <= h - y <= 3 for a, h, c in lights), room def test_decoration_support_and_nbt(data): _, cells, nbt = data def solid(p): n = name(cells.get(p, 'air')) return n not in ('air', 'vine', 'ladder', 'lantern', 'fern', 'short_grass', 'poppy', 'dandelion') and not n.endswith(('_carpet', '_wall_banner', '_trapdoor', '_stairs', '_slab')) for (x, y, z), s in cells.items(): n, p = name(s), props(s) if n in ('lantern', 'candle', 'flower_pot', 'lectern', 'fern', 'short_grass', 'poppy', 'dandelion') or n.startswith('potted_') or n.endswith('_carpet'): # Fence and wall tops also support lanterns. below = name(cells.get((x, y - 1, z), 'air')) assert solid((x, y - 1, z)) or below.endswith(('_wall', '_fence')), (x, y, z, n, below) if n == 'white_wall_banner': assert solid((x, y, z - 1)) if n == 'vine': assert any(p.get(k) == 'true' and solid((x + dx, y, z + dz)) for k, dx, dz in [('north', 0, -1), ('south', 0, 1), ('east', 1, 0), ('west', -1, 0)]), (x, y, z) region = next(iter(nbt['Regions'].values())) banners = [t for t in region['TileEntities'] if str(t['id']) == 'minecraft:banner'] assert len(banners) == 2 assert all(len(t['patterns']) == 3 and all(str(p['color']) == 'green' for p in t['patterns']) for t in banners) lecterns = [t for t in region['TileEntities'] if str(t['id']) == 'minecraft:lectern'] assert len(lecterns) == 1 and lecterns[0]['Book']['components']['minecraft:written_book_content']['pages'] assert len(region['Entities']) == 6 for e in region['Entities']: x, y, z = (int(e[k]) for k in ('TileX', 'TileY', 'TileZ')) assert solid((x, y, z + 1)) assert int(e['Item']['count']) == 1 def test_reproducible(data): build, _, _ = data from tempfile import TemporaryDirectory with TemporaryDirectory(dir=ROOT / 'test') as temp: tmp_path = Path(temp) a = build.export(tmp_path / 'a.litematic').read_bytes() b = Build().build().export(tmp_path / 'b.litematic').read_bytes() assert a == b == (ROOT / 'output.litematic').read_bytes() def test_valid_vanilla_states(data): import json authority = json.loads(Path('/work/generator/MCRender/resources/1.21.1-blocks.json').read_text()) _, cells, _ = data for state in set(cells.values()): n, p = name(state), props(state) assert n in authority, n allowed = authority[n][0] for key, value in p.items(): assert key in allowed and value in allowed[key], state def test_roof_join_forge_and_pines(data): _, cells, _ = data roof = {p for p, s in cells.items() if 'deepslate' in name(s)} start = (8, 16, 8) seen = {start} todo = deque([start]) while todo: x, y, z = todo.popleft() for dx, dy, dz in ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)): p = (x + dx, y + dy, z + dz) if p in roof and p not in seen: seen.add(p) todo.append(p) assert (31, 38, 20) in seen, 'Lower roof must physically join tower roof' assert name(cells[4, 5, 21]) == 'campfire' assert props(cells[4, 5, 21])['lit'] == 'true' assert name(cells[5, 4, 16]) == 'anvil' for x, z, height in ((5, 29, 24), (3, 6, 16), (42, 26, 18)): assert all(name(cells[x, y, z]) == 'spruce_log' for y in range(1, height + 1)) assert name(cells[x, height + 1, z]) == 'spruce_leaves' assert sum(1 for (a, h, c), s in cells.items() if abs(a - x) <= 4 and abs(c - z) <= 4 and h > 4 and name(s) == 'spruce_leaves') > 60

# Starting point for a Minecraft build generator. Copy into the workspace and fill in build(). # Everything that has to be right for the harness is already right here: bounds checked placement, # one seeded random source, and a byte reproducible export. from __future__ import annotations import argparse import random import sys from pathlib import Path from typing import Dict, Iterable, Optional, Tuple sys.path.insert(0, "/work/generator/MCIO") from mcio.schematic import load_schematic # noqa: E402 from mcio.sketch import LitematicCanvas, Material, parse_blockstate # noqa: E402 CONFIG = { "seed": 20260923, "size_xyz": (45, 40, 35), # width X, height Y, depth Z "minecraft_version": "1.21.1", "data_version": 3955, "output": "output.litematic", "name": "Amberstone Lodge", "author": "generator", "description": "Four furnished levels, timber gables, forge and hand-built pines. Java 1.21.1.", } Position = Tuple[int, int, int] class Build: """Hold a block volume and write it out as a Litematica schematic.""" def __init__(self, size_xyz: Tuple[int, int, int] = CONFIG["size_xyz"], seed: int = CONFIG["seed"]) -> None: """Create an empty volume with one seeded random source. Args: size_xyz (Tuple[int, int, int]): Volume size as width X, height Y, depth Z. seed (int): Seed for every random decision in this build. """ self.size_x, self.size_y, self.size_z = size_xyz self.rng = random.Random(seed) self.canvas = LitematicCanvas((self.size_y, self.size_z, self.size_x)) self.placed: Dict[Position, str] = {} def inside(self, x: int, y: int, z: int) -> bool: """Report whether a coordinate is inside the volume. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: bool: True when every axis is within range. """ return 0 <= x < self.size_x and 0 <= y < self.size_y and 0 <= z < self.size_z def put(self, x: int, y: int, z: int, block: str | Material, **properties: str) -> None: """Place one block, in XYZ order, with an immediate bounds check. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. block (str | Material): Namespaced block name, a full blockstate string, or a Material. **properties: Blockstate properties such as facing or half. Raises: AssertionError: When the coordinate is outside the volume, naming the coordinate. """ assert self.inside(x, y, z), f"out of bounds: (x={x}, y={y}, z={z}) in {self.size_x}x{self.size_y}x{self.size_z}" material = self.material(block, **properties) if isinstance(block, str) else block self.canvas.block((y, z, x), material) self.placed[(x, y, z)] = material.blockstate def material(self, name: str, **properties: str) -> Material: """Build a Material from a block name and its properties. Args: name (str): Namespaced block name, or a full blockstate string. **properties: Blockstate properties. Returns: Material: Material ready for placement. """ if "[" in name: return parse_blockstate(name) return self.canvas.material(name, **dict(sorted(properties.items()))) def box(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill an inclusive box. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive on both ends. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, block, **properties) def shell(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill only the faces of a box, leaving the inside empty. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): on_face = x in (x0, x1) or y in (y0, y1) or z in (z0, z1) if on_face: self.put(x, y, z, block, **properties) def texture(self, bounds: Tuple[int, int, int, int, int, int], palette: Iterable[str]) -> None: """Fill a box with a weighted mix of related blocks, so the surface is not flat. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. palette (Iterable[str]): Block names. Repeat a name to make it more common. """ choices = list(palette) x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, self.rng.choice(choices)) def get(self, x: int, y: int, z: int) -> Optional[str]: """Read back what was placed at a coordinate. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: Optional[str]: Blockstate string, or None when the cell is empty. """ return self.placed.get((x, y, z)) def block(self, x, y, z, name, **props): """Place a vanilla block using its short name.""" self.put(x, y, z, 'minecraft:' + name, **props) def fill(self, bounds, name, **props): """Fill a box with a vanilla block.""" self.box(bounds, 'minecraft:' + name, **props) def mix(self, bounds, names): """Texture a surface with a seeded palette.""" self.texture(bounds, ['minecraft:' + n for n in names]) def door(self, x, y, z, facing='north'): """Place both matching halves of a door.""" for half, dy in [('lower', 0), ('upper', 1)]: self.block(x, y + dy, z, 'spruce_door', half=half, facing=facing, hinge='left', open='false', powered='false') def tile(self, x, y, z, kind, **tags): """Register block entity data for export.""" from mcio.nbt.tag import Compound, Int, String self.tiles.append(Compound(dict(id=String('minecraft:' + kind), x=Int(x), y=Int(y), z=Int(z), **tags))) def frame(self, x, y, z, item): """Hang an item frame on the north face of a solid block.""" from mcio.nbt.tag import Compound, Int, String, Byte, Double, List as NBTList, IntArray self.entities.append(Compound({'id': String('minecraft:item_frame'), 'Pos': NBTList[Double]([x + .5, y + .5, z + .96875]), 'TileX': Int(x), 'TileY': Int(y), 'TileZ': Int(z), 'Facing': Byte(2), 'ItemRotation': Byte(0), 'ItemDropChance': __import__('mcio.nbt.tag', fromlist=['Float']).Float(1), 'UUID': IntArray([0, 0, 0, len(self.entities) + 1]), 'Item': Compound({'id': String('minecraft:' + item), 'count': Int(1)})})) def window(self, x, y, z, axis='x', width=3, height=3): """Glaze a framed opening and add exterior shutters.""" for d in range(width): for dy in range(height): self.block(x + (d if axis == 'x' else 0), y + dy, z + (d if axis == 'z' else 0), 'glass') if axis == 'x': for xx in (x - 1, x + width): self.fill((xx, y, z - 1, xx, y + height - 1, z - 1), 'spruce_trapdoor', facing='east' if xx < x else 'west', half='bottom', open='true', powered='false', waterlogged='false') self.fill((x - 1, y - 1, z - 1, x + width, y - 1, z - 1), 'spruce_planks') else: self.fill((x + 1, y - 1, z - 1, x + 1, y - 1, z + width), 'spruce_planks') self.windows.append((x, y, z, axis, width, height)) def lamp(self, x, y, z): """Set a lantern on a timber pedestal.""" self.block(x, y - 1, z, 'spruce_fence') self.block(x, y, z, 'lantern', hanging='false', waterlogged='false') def pine(self, x, z, height): """Build an irregular pine with exposed trunk and stepped boughs.""" self.fill((x, 1, z, x, height, z), 'spruce_log', axis='y') for y in range(5, height, 3): radius = max(1, min(3, int((height - y) / 5))) for dx, dz in [(1, 0), (-1, 0), (0, 1), (0, -1)]: for d in range(1, radius + 1): self.block(x + dx * d, y, z + dz * d, 'spruce_log', axis='x' if dx else 'z') for dx in range(-radius, radius + 1): for dz in range(-radius, radius + 1): if abs(dx) + abs(dz) <= radius + 1 and (dx or dz): if not self.get(x + dx, y, z + dz): self.block(x + dx, y, z + dz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') self.block(x + dx, y + 1, z + dz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') if abs(dx) + abs(dz) < radius: self.block(x + dx, y + 2, z + dz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') self.block(x, height + 1, z, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') def build(self): """Construct Amberstone Lodge with four furnished and connected levels.""" from mcio.nbt.tag import Compound, Int, String, List as NBTList self.tiles, self.entities, self.windows = [], [], [] stone = ['stone_bricks'] * 7 + ['cobblestone'] * 2 + ['mossy_stone_bricks'] plaster = ['sandstone'] * 8 + ['smooth_sandstone'] * 4 + ['end_stone'] timber = ['spruce_planks'] * 9 + ['dark_oak_planks'] roof = ['deepslate_tiles'] * 9 + ['deepslate_bricks'] * 3 + ['cobbled_deepslate'] # Irregular terrain edge preserves the reference's isolated diorama silhouette. for x in range(1, 44): for z in range(2, 33): if ((x - 22) / 23)**6 + ((z - 18) / 17)**6 < 1: self.block(x, 0, z, self.rng.choice(['grass_block'] * 9 + ['moss_block', 'coarse_dirt'])) self.mix((5, 1, 7, 40, 2, 29), stone) self.mix((7, 3, 8, 39, 3, 28), stone) for x in range(7, 40): for z in (7, 29): self.block(x, 3, z, 'stone_brick_slab', type='bottom', waterlogged='false') # Front stair and the broken ochre / stone path. for z, y in [(4, 0), (5, 1), (6, 2)]: self.fill((27, y, z, 32, y, z), 'stone_brick_stairs', facing='south', half='bottom', shape='straight', waterlogged='false') for z in range(0, 5): for x in range(24 + (z % 2), 34): self.block(x, 0, z, self.rng.choice(['dirt_path', 'coarse_dirt', 'gravel', 'andesite'])) # Main wall boxes, floor plates, and exposed timber frame. for x0, x1, z0, z1, top, floors in [(9, 25, 10, 26, 16, [3, 10]), (25, 37, 10, 27, 26, [3, 10, 17, 24])]: for y in range(4, top + 1): palette = stone if y < 10 else plaster for z in (z0, z1): self.mix((x0, y, z, x1, y, z), palette) for x in (x0, x1): self.mix((x, y, z0, x, y, z1), palette) for fy in floors: self.mix((x0, fy, z0, x1, fy, z1), timber if fy > 3 else stone) for x in (x0, x1): for z in (z0, z1): self.fill((x, 4, z, x, top, z), 'spruce_log', axis='y') for y in [9, 10, 16, 17, 23, 24, 26]: if y <= top: for z in (z0, z1): self.fill((x0, y, z, x1, y, z), 'spruce_log', axis='x') for x in (x0, x1): self.fill((x, y, z0, x, y, z1), 'spruce_log', axis='z') for x in range(x0 + 4, x1, 5): for z in (z0, z1): self.fill((x, 10, z, x, top, z), 'stripped_spruce_log', axis='y') # Low gable, broad eaves and fully closed roof shell. for x in range(7, 26): ry = 17 + (9 - abs(x - 17)) // 2 for z in range(8, 29): self.mix((x, ry, z, x, ry, z), roof) if z in (8, 28): self.block(x, ry + 1, z, 'deepslate_tile_slab', type='bottom', waterlogged='false') if 9 <= x <= 25: for z in (10, 26): for y in range(17, ry): self.block(x, y, z, 'sandstone') # A shallow, glazed dormer interrupts the broad low roof. self.fill((14, 19, 9, 20, 21, 13), 'spruce_planks') self.fill((15, 19, 10, 19, 20, 12), 'air') self.fill((15, 20, 9, 19, 20, 9), 'glass') for xx in range(13, 22): self.fill((xx, 22, 8, xx, 22, 14), 'deepslate_tiles') self.block(xx, 22, 7, 'deepslate_tile_stairs', facing='south', half='bottom', shape='straight', waterlogged='false') # Tall roof rises two blocks per column, with stair caps and deep bargeboards. for x in range(23, 40): ry = 24 + 2 * (8 - abs(x - 31)) ry = min(37, ry) for z in range(8, 30): self.mix((x, ry - 1, z, x, ry, z), roof) self.block(x, ry + 1, z, 'deepslate_tile_stairs', facing='east' if x < 31 else 'west', half='bottom', shape='straight', waterlogged='false') if 25 <= x <= 37: for z in (10, 27): for y in range(27, ry - 1): self.block(x, y, z, 'sandstone' if (x + y) % 7 else 'smooth_sandstone') if ry > 28: self.fill((x, ry - 2, 9, x, ry - 2, 9), 'spruce_log', axis='x') self.fill((31, 27, 10, 31, 36, 10), 'spruce_log', axis='y') self.fill((31, 27, 27, 31, 36, 27), 'spruce_log', axis='y') # Decorative ridge finials stay within the 40-block volume. for z in (9, 28): self.block(31, 39, z, 'spruce_fence') # Exposed joists define warm coffered ceilings beneath each floor. for y in (9, 16, 23): for z in (14, 21): self.fill((26, y, z, 36, y, z), 'spruce_log', axis='x') for z in (14, 22): self.fill((10, 9, z, 24, 9, z), 'spruce_log', axis='x') # Shared wall passages are cut after both envelopes are complete. for y in (4, 11): self.fill((25, y, 17, 25, y + 2, 19), 'air') self.door(29, 4, 10) self.fill((28, 6, 9, 30, 6, 9), 'spruce_stairs', facing='south', half='top', shape='straight', waterlogged='false') for x in (27, 32): self.lamp(x, 6, 9) self.block(x, 5, 9, 'spruce_planks') # Glazing and shutters on all four reconstructed elevations. for x, y in [(12, 5), (19, 5), (11, 12), (19, 12), (28, 12), (28, 19), (30, 28)]: self.window(x, y, 10, width=2 if y == 28 else 3, height=2 if y in (5, 28) else 3) for y in (5, 12, 19, 26): self.window(37, y, 15, axis='z', width=3, height=2 if y in (5, 26) else 3) for x, y, z, width, height in [(12, 12, 26, 3, 2), (19, 12, 26, 2, 3), (28, 12, 27, 3, 3), (28, 19, 27, 3, 3), (30, 28, 27, 3, 3)]: # Rear sills are independent so shutters face outwards. for xx in range(x, x + width): self.fill((xx, y, z, xx, y + height - 1, z), 'glass') self.fill((x - 1, y - 1, z + 1, x + width, y - 1, z + 1), 'spruce_planks') self.windows.append((x, y, z, 'x', width, height)) # Continuous ladder core has two-block clear exits at every floor. self.fill((35, 4, 26, 35, 27, 26), 'spruce_planks') self.fill((35, 4, 25, 35, 27, 25), 'air') for y in range(4, 26): self.block(35, y, 25, 'ladder', facing='north', waterlogged='false') # Library access ladder stays below the lower roof shell. self.fill((23, 11, 24, 23, 16, 24), 'spruce_planks') for y in range(11, 16): self.block(23, y, 23, 'ladder', facing='north', waterlogged='false') # Ground entrance hall, cobbled workshop and a fitted storage wall. for x in (27, 31, 33): self.block(x, 4, 26, 'barrel', facing='north', open='false') self.block(x, 5, 26, 'barrel', facing='north', open='false') self.frame(31, 5, 25, 'iron_pickaxe') for x in (11, 13, 15, 17): self.block(x, 4, 25, 'barrel', facing='north', open='false') self.block(x, 5, 25, 'chest', facing='north', type='single', waterlogged='false') self.fill((11, 4, 12, 11, 4, 17), 'spruce_planks') self.block(11, 4, 14, 'crafting_table') self.block(11, 5, 12, 'potted_fern') self.block(13, 4, 14, 'stonecutter', facing='east') self.block(17, 4, 14, 'anvil', facing='north') for p in [(12, 5, 20), (21, 5, 12), (27, 5, 22), (34, 5, 13)]: self.lamp(*p) self.fill((28, 4, 12, 30, 4, 20), 'red_carpet') # Living and dining: long timber table, chairs, fireplace, pantry. self.fill((13, 11, 16, 18, 11, 19), 'green_carpet') for x in range(14, 18): self.block(x, 11, 17, 'spruce_fence') self.block(x, 12, 17, 'spruce_slab', type='top', waterlogged='false') for z, facing in [(15, 'south'), (19, 'north')]: self.block(x, 11, z, 'dark_oak_stairs', facing=facing, half='bottom', shape='straight', waterlogged='false') for x in (14, 17): self.block(x, 13, 17, 'white_candle', candles='3', lit='true', waterlogged='false') for x in range(10, 15): self.block(x, 11, 25, 'barrel', facing='north', open='false') self.block(x, 14, 25, 'barrel', facing='north', open='false') self.block(11, 12, 25, 'potted_fern') self.frame(13, 14, 24, 'bread') self.fill((21, 11, 25, 22, 14, 25), 'bookshelf') for p in [(11, 12, 12), (21, 12, 20), (18, 12, 24), (27, 12, 22), (34, 12, 13)]: self.lamp(*p) # A stone chimney breast with a lit hearth warms the library hall. self.mix((26, 11, 21, 26, 16, 23), stone) self.block(27, 12, 22, 'air') self.block(27, 11, 22, 'campfire', lit='true', signal_fire='false', facing='east', waterlogged='false') self.block(27, 11, 21, 'stone_bricks') self.block(27, 11, 23, 'stone_bricks') self.fill((27, 13, 21, 27, 13, 23), 'stone_bricks') self.fill((27, 14, 21, 27, 16, 23), 'stone_bricks') # Hallway nook and library cabinets, glazed partition door. self.fill((26, 11, 13, 26, 14, 15), 'bookshelf') self.fill((30, 11, 22, 32, 11, 22), 'dark_oak_stairs', facing='south', half='bottom', shape='straight', waterlogged='false') self.fill((28, 11, 14, 30, 11, 19), 'red_carpet') self.fill((32, 11, 11, 32, 14, 14), 'glass') self.fill((32, 11, 13, 32, 12, 13), 'air') for half, dy in [('lower', 0), ('upper', 1)]: self.block(32, 11 + dy, 13, 'oak_door', half=half, facing='west', hinge='left', open='false', powered='false') self.fill((36, 11, 20, 36, 14, 23), 'bookshelf') self.block(33, 11, 19, 'barrel', facing='up', open='false') self.block(33, 12, 19, 'potted_azalea_bush') for y in range(12, 16): self.block(36, y, 26, 'vine', south='true', north='false', west='false', east='false', up='false') # Bedroom raised dais, double green bed, headboard and overhead cabinets. self.fill((27, 18, 20, 31, 18, 24), 'spruce_planks') self.fill((27, 18, 19, 31, 18, 19), 'spruce_stairs', facing='south', half='bottom', shape='straight', waterlogged='false') for x in (28, 29): for z, part in [(22, 'foot'), (23, 'head')]: self.block(x, 19, z, 'green_bed', facing='south', part=part, occupied='false') self.fill((27, 19, 24, 31, 20, 24), 'dark_oak_planks') self.fill((27, 22, 24, 31, 22, 24), 'barrel', facing='north', open='false') self.fill((28, 21, 24, 30, 21, 24), 'bookshelf') for x in (27, 31): self.block(x, 19, 22, 'barrel', facing='up', open='false') self.block(x, 20, 22, 'lantern', hanging='false', waterlogged='false') self.fill((27, 18, 11, 31, 18, 11), 'dark_oak_planks') self.fill((28, 19, 11, 30, 19, 11), 'white_carpet') for x in (27, 31): self.block(x, 20, 11, 'white_wall_banner', facing='south') self.tile(x, 20, 11, 'banner', patterns=NBTList[Compound]([Compound({'color': String('green'), 'pattern': String('minecraft:stripe_left')}), Compound({'color': String('green'), 'pattern': String('minecraft:stripe_right')}), Compound({'color': String('green'), 'pattern': String('minecraft:stripe_center')})])) self.block(32, 18, 11, 'barrel', facing='south', open='false') self.block(32, 19, 11, 'potted_blue_orchid') self.fill((28, 18, 14, 31, 18, 17), 'green_carpet') for p in [(34, 19, 14), (33, 19, 23)]: self.lamp(*p) # Bedroom dressers, travel trunks and the low paneled bed footboard. for z in range(14, 18): self.block(26, 18, z, 'barrel', facing='east', open='false') self.block(26, 19, 14, 'potted_fern') self.block(26, 19, 17, 'white_candle', candles='2', lit='true', waterlogged='false') for z in (21, 23): self.block(36, 18, z, 'chest', facing='west', type='single', waterlogged='false') for x in (27, 30): self.block(x, 19, 21, 'dark_oak_planks') for x in (28, 29): self.block(x, 19, 21, 'dark_oak_trapdoor', facing='north', half='bottom', open='true', powered='false', waterlogged='false') # Attic study, open book lectern, map frames, archives and candles. self.fill((27, 25, 18, 27, 28, 23), 'bookshelf') self.fill((29, 25, 26, 32, 26, 26), 'barrel', facing='north', open='false') self.frame(30, 26, 25, 'map') self.fill((29, 25, 14, 32, 25, 14), 'dark_oak_planks') self.block(30, 26, 14, 'lectern', facing='south', has_book='true', powered='false') self.tile(30, 26, 14, 'lectern', Book=Compound({'id': String('minecraft:written_book'), 'count': Int(1), 'components': Compound({'minecraft:written_book_content': Compound({'title': String('Amberstone Journal'), 'author': String('The Lodge Keeper'), 'pages': NBTList[String]([String('{"text":"Pines, iron and a warm hearth. Welcome to Amberstone Lodge."}')]), 'resolved': __import__('mcio.nbt.tag', fromlist=['Byte']).Byte(1)})})}), Page=Int(0)) self.block(32, 26, 14, 'white_candle', candles='3', lit='true', waterlogged='false') self.block(29, 26, 14, 'potted_fern') self.block(30, 25, 16, 'spruce_stairs', facing='north', half='bottom', shape='straight', waterlogged='false') self.fill((30, 25, 18, 33, 25, 21), 'green_carpet') for p in [(28, 26, 12), (33, 26, 23)]: self.lamp(*p) # Forge canopy and stone chimney outside the lower wing. for x in (3, 8): for z in (12, 22): self.fill((x, 1, z, x, 8, z), 'spruce_log', axis='y') self.block(x, 9, z, 'spruce_planks') for x in range(2, 10): ry = 8 + x // 4 self.fill((x, ry, 11, x, ry, 23), 'deepslate_tile_slab', type='top', waterlogged='false') self.mix((3, 1, 12, 8, 3, 22), stone) self.mix((6, 4, 19, 8, 22, 21), ['cobblestone'] * 5 + ['andesite', 'stone_bricks']) self.fill((6, 23, 19, 8, 23, 21), 'stone_brick_slab', type='bottom', waterlogged='false') self.block(7, 23, 20, 'campfire', lit='true', signal_fire='true', facing='north', waterlogged='false') self.block(7, 4, 19, 'blast_furnace', facing='north', lit='true') self.tile(7, 4, 19, 'blast_furnace', BurnTime=__import__('mcio.nbt.tag', fromlist=['Short']).Short(32000), CookTime=__import__('mcio.nbt.tag', fromlist=['Short']).Short(0), CookTimeTotal=__import__('mcio.nbt.tag', fromlist=['Short']).Short(200)) self.block(6, 4, 17, 'magma_block') self.block(6, 5, 17, 'campfire', lit='true', signal_fire='false', facing='north', waterlogged='false') self.block(4, 4, 15, 'anvil', facing='north') self.block(8, 4, 13, 'barrel', facing='up', open='false') self.block(8, 5, 13, 'lantern', hanging='false', waterlogged='false') self.block(4, 4, 21, 'chest', facing='north', type='single', waterlogged='false') # Climbing ivy on the tall facade, kept away from all glazing. for y in range(4, 18): self.block(36, y, 9, 'vine', south='true', north='false', west='false', east='false', up='false') if y % 3 != 0: self.block(35, y, 9, 'vine', south='true', north='false', west='false', east='false', up='false') for x, z in [(8, 28), (39, 24), (38, 8), (9, 7)]: self.block(x, 3, z, 'stone_bricks') self.block(x, 4, z, 'moss_block') self.block(x, 5, z, 'azalea') self.pine(5, 29, 25) self.pine(17, 31, 30) # Scattered flowers only where the ground is exposed. for x in range(2, 43): for z in range(3, 33): if self.get(x, 0, z) == 'minecraft:grass_block' and not self.get(x, 1, z) and self.rng.random() < .10: self.block(x, 1, z, self.rng.choice(['short_grass', 'fern', 'poppy', 'dandelion'])) # Useful provisions make the furnished lodge ready to inhabit. from mcio.nbt.tag import Byte for x, y, z, kind, item, count in [(4, 4, 21, 'chest', 'iron_ingot', 24), (11, 4, 25, 'barrel', 'coal', 32), (12, 11, 25, 'barrel', 'bread', 16), (36, 18, 21, 'chest', 'emerald', 6)]: self.tile(x, y, z, kind, Items=NBTList[Compound]([Compound({'Slot': Byte(0), 'id': String('minecraft:' + item), 'count': Int(count)})])) return self def export(self, path: Path) -> Path: """Write the schematic so that two runs produce identical bytes. Args: path (Path): Destination .litematic path. Returns: Path: The path written. """ schematic = self.canvas.to_litematica( name=CONFIG["name"], author=CONFIG["author"], description=CONFIG["description"], minecraft_data_version=CONFIG["data_version"], ) # The metadata otherwise records the current wall clock, which changes the bytes on every run. schematic.metadata.time_created = 0 schematic.metadata.time_modified = 0 path.parent.mkdir(parents=True, exist_ok=True) from mcio.nbt.nbt import File as NBTFile from mcio.nbt.tag import List as NBTList, Compound nbt = schematic.write_to_nbt() region = next(iter(nbt['Regions'].values())) region['TileEntities'] = NBTList[Compound](self.tiles) region['Entities'] = NBTList[Compound](self.entities) NBTFile(nbt).save(path) return path def verify(self, path: Path) -> Dict[str, object]: """Reload the written file and confirm it matches what was placed. Args: path (Path): Schematic to reload. Returns: Dict[str, object]: Size, block count and palette size of the reloaded file. Raises: AssertionError: When a reloaded cell differs from what was placed. """ loaded = load_schematic(path) size_y, size_z, size_x = loaded.size_yzx assert (size_x, size_y, size_z) == (self.size_x, self.size_y, self.size_z), "size changed on reload" ids = loaded.read_flat(0, loaded.volume).reshape(loaded.size_yzx) for (x, y, z), state in self.placed.items(): assert loaded.palette[int(ids[y, z, x])] == state, f"cell (x={x}, y={y}, z={z}) changed on reload" return { "size_xyz": [size_x, size_y, size_z], "placed_blocks": len(self.placed), "palette_states": len(loaded.palette), } def main() -> None: """Generate the build, export it, and verify the exported file.""" parser = argparse.ArgumentParser(description="Generate a Minecraft schematic.") parser.add_argument("--output", type=Path, default=Path(CONFIG["output"])) parser.add_argument("--seed", type=int, default=CONFIG["seed"]) args = parser.parse_args() build = Build(seed=args.seed).build() path = build.export(args.output) report = build.verify(path) print(f"wrote {path}: {report}") if __name__ == "__main__": main()

# Create deterministic interior cutaways from the final exported schematic for visual review. from pathlib import Path import sys sys.path.insert(0, '/work/generator/MCIO') from mcio.schematic import load_schematic from mcio.sketch import LitematicCanvas, parse_blockstate ROOT = Path(__file__).resolve().parent VIEWS = { 'ground_cutaway': (9, 3, 10, 37, 8, 27), 'living_cutaway': (9, 10, 10, 37, 15, 27), 'bedroom_cutaway': (25, 17, 10, 37, 22, 27), 'study_cutaway': (25, 24, 10, 37, 29, 27), } def main(): """Export cropped geometry with the two near walls removed for visibility.""" (ROOT / 'previews').mkdir(exist_ok=True) source = load_schematic(ROOT / 'output.litematic') ids = source.read_flat(0, source.volume).reshape(source.size_yzx) for name, (x0, y0, z0, x1, y1, z1) in VIEWS.items(): canvas = LitematicCanvas((y1 - y0 + 1, z1 - z0 + 1, x1 - x0 + 1)) for x in range(x0, x1 + 1): for y in range(y0, y1 + 1): for z in range(z0, z1 + 1): if (z == z0 or x == x0) and y > y0 + 1: continue canvas.block((y - y0, z - z0, x - x0), parse_blockstate(source.palette[int(ids[y, z, x])])) schematic = canvas.to_litematica(name=name, minecraft_data_version=3955) schematic.metadata.time_created = 0 schematic.metadata.time_modified = 0 schematic.save(ROOT / 'previews' / (name + '.litematic')) if __name__ == '__main__': main()

// Starting point for rendering a build. Copy into the workspace and edit VIEWS. // Lighting, camera framing and background are already tuned; run it as is to get a first look. import fs from 'node:fs'; import path from 'node:path'; import { createRequire } from 'node:module'; import { createRenderScene, renderLitematicWithMetadata } from '/work/generator/MCRender/src/headless/index.ts'; const RENDER_ROOT = '/work/generator/MCRender'; const requireRenderer = createRequire(path.join(RENDER_ROOT, 'package.json')); const { PNG } = requireRenderer('pngjs'); // vite-node passes script arguments after a bare "--", so drop it before reading them. const argv = process.argv.slice(2).filter(entry => entry !== '--'); const INPUT = argv[0] ?? 'output.litematic'; const OUT_DIR = argv[1] ?? 'previews'; const SIZE = Number(process.env.RENDER_SIZE ?? 800); // Tuned defaults. Ambient near 0.72 keeps shaded faces readable, and a light direction with a // dominant +Y term plus a small +X/+Z tilt separates roof, wall and ground planes. const LIGHT_DIRECTION = [0.08, 0.28, 0.15]; const AMBIENT = 0.72; const BACKGROUND = [47, 52, 59, 255]; const VIEWS = [ { name: 'front_left', azimuth: 150, elevation: 18, radius: 3.3 }, { name: 'front', azimuth: 210, elevation: 18, radius: 3.3 }, { name: 'rear', azimuth: 35, elevation: 22, radius: 3.3 }, { name: 'side', azimuth: 120, elevation: 14, radius: 3.3 }, { name: 'top', azimuth: 210, elevation: 62, radius: 3.4 }, ]; // Resolve every path while the working directory is still the caller's. const absoluteInput = path.resolve(INPUT); const absoluteOutDir = path.resolve(OUT_DIR); fs.mkdirSync(absoluteOutDir, { recursive: true }); // The renderer looks for its resource cache relative to the working directory, so move there first, // and only then create the scene. process.chdir(RENDER_ROOT); const scene = createRenderScene({ width: SIZE, height: SIZE }); for (const view of VIEWS) { const result = renderLitematicWithMetadata(absoluteInput, { width: SIZE, height: SIZE, fov_deg: 30, radius: view.radius, nRandomAzimuths: 0, azimuthInit: 0, elevationInit: 0, azimuthsDeltas: [view.azimuth], elevationsDeltas: [view.elevation], ambientIntensities: [AMBIENT], lightDirections: [LIGHT_DIRECTION], mirror: [false], layout: [[0]], limit: 512, seed: 0, opaque: false, }, scene); // Flatten onto an opaque background so shaded faces keep their contrast. for (let i = 0; i < result.png.data.length; i += 4) { const alpha = result.png.data[i + 3] / 255; for (let channel = 0; channel < 3; channel++) { result.png.data[i + channel] = Math.round(result.png.data[i + channel] * alpha + BACKGROUND[channel] * (1 - alpha)); } result.png.data[i + 3] = 255; } const target = path.join(absoluteOutDir, `${view.name}.png`); fs.writeFileSync(target, PNG.sync.write(result.png)); console.log(`wrote ${target} (${SIZE}x${SIZE}, azimuth ${view.azimuth}, elevation ${view.elevation})`); }

# Validate the exported lodge geometry, navigation, entities and deterministic regeneration. from collections import deque from pathlib import Path import json import sys import pytest from tempfile import TemporaryDirectory ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) from generate import Build, CONFIG from mcio.schematic import load_schematic from mcio.nbt.nbt import File as NBTFile @pytest.fixture(scope='module') def world(): """Load the actual delivered schematic into a coordinate dictionary.""" model = load_schematic(ROOT / 'output.litematic') ids = model.read_flat(0, model.volume).reshape(model.size_yzx) result = {} for y in range(40): for z in range(35): for x in range(45): state = model.palette[int(ids[y, z, x])] name, _, props = state.partition('[') result[x, y, z] = (name.removeprefix('minecraft:'), (dict(p.split('=') for p in props.rstrip(']').split(',')) if props else {})) return result def name(world, p): """Read the block name, treating outside the volume as air.""" return world.get(p, ('air', {}))[0] def passable(world, p, doors=True): """Check player clearance, allowing operable doors and thin floor decorations.""" n = name(world, p) return n in ('air', 'ladder', 'vine') or n.endswith('_carpet') or (doors and n.endswith('_door')) def solid(world, p): """Check a full block suitable for support or envelope sealing.""" n = name(world, p) return not (n in ('air', 'ladder', 'vine', 'lantern', 'campfire', 'short_grass', 'fern', 'poppy', 'dandelion', 'azalea') or n.startswith('potted_') or any(n.endswith(s) for s in ('_carpet', '_banner', '_candle', '_trapdoor', '_fence', '_slab', '_stairs', '_bed'))) def test_format_states_and_roundtrip(world): """Require one Java 1.21.1 region, valid vanilla states and preserved placements.""" raw = NBTFile.load_regardless_of_gzipped(ROOT / 'output.litematic') assert int(raw['MinecraftDataVersion']) == 3955 assert len(raw['Regions']) == 1 assert len(world) == 45 * 40 * 35 specs = json.loads(Path('/work/generator/MCRender/resources/1.21.1-blocks.json').read_text()) for block, props in world.values(): assert block in specs, block for key, value in props.items(): assert key in specs[block][0] and value in specs[block][0][key], (block, key, value) Build().build().verify(ROOT / 'output.litematic') def test_doors_and_beds(world): """Inspect every door half and every bed part, including supporting blocks.""" doors = beds = 0 offsets = {'north': (0, -1), 'south': (0, 1), 'east': (1, 0), 'west': (-1, 0)} for (x, y, z), (n, p) in world.items(): if n.endswith('_door'): dy = 1 if p['half'] == 'lower' else -1 other, q = world[x, y + dy, z] assert other == n and q['half'] != p['half'] assert all(p[k] == q[k] for k in ('facing', 'hinge', 'open', 'powered')) if dy == 1: doors += 1 assert solid(world, (x, y - 1, z)) if n.endswith('_bed'): dx, dz = offsets[p['facing']] sign = 1 if p['part'] == 'foot' else -1 other, q = world[x + sign * dx, y, z + sign * dz] assert other == n and q['part'] != p['part'] and q['facing'] == p['facing'] assert solid(world, (x, y - 1, z)) beds += p['part'] == 'head' assert doors >= 2 and beds == 2 def test_all_rooms_reachable_with_headroom(world): """Flood walkable feet positions with two-block clearance and real ladder transitions.""" def node(p): x, y, z = p if not (0 <= x < 45 and 1 <= y < 39 and 0 <= z < 35): return False support = name(world, (x, y - 1, z)) return passable(world, p) and passable(world, (x, y + 1, z)) and (name(world, p) == 'ladder' or solid(world, (x, y - 1, z)) or support.endswith('_stairs') or support.endswith('_slab')) start = (29, 4, 9) assert node(start) seen, queue = {start}, deque([start]) while queue: x, y, z = queue.popleft() candidates = [(x + dx, y + dy, z + dz) for dx, dz in [(1, 0), (-1, 0), (0, 1), (0, -1)] for dy in (-1, 0, 1)] for dy in (-1, 1): p = (x, y + dy, z) if name(world, (x, y, z)) == 'ladder' or name(world, p) == 'ladder': candidates.append(p) for p in candidates: if p not in seen and node(p): # Stepping up also needs clearance above the departure position. if p[1] > y and not passable(world, (x, y + 2, z)): continue seen.add(p) queue.append(p) targets = [(29, 4, 12), (18, 4, 20), (29, 11, 18), (18, 11, 21), (30, 18, 16), (30, 25, 20), (30, 19, 23), (23, 15, 23)] assert all(p in seen for p in targets), [p for p in targets if p not in seen] # Each level's exit and landing retains headroom. for y in (4, 11, 18, 25): assert (35, y, 25) in seen and (34, y, 25) in seen def test_envelope_separates_rooms_from_sky(world): """Flood outside through non-full blocks and require indoor air to remain sealed.""" def blocked(p): return solid(world, p) queue = deque() outside = set() for p in world: x, y, z = p if (x in (0, 44) or y in (0, 39) or z in (0, 34)) and not blocked(p): queue.append(p) outside.add(p) while queue: x, y, z = queue.popleft() for dx, dy, dz in [(1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)]: p = x + dx, y + dy, z + dz if p in world and p not in outside and not blocked(p): outside.add(p) queue.append(p) interior = [] for x0, x1, z0, z1, bottom, top in [(10, 24, 11, 25, 4, 16), (26, 36, 11, 26, 4, 26)]: for x in range(x0, x1 + 1): for y in range(bottom, top + 1): for z in range(z0, z1 + 1): if name(world, (x, y, z)) == 'air': interior.append((x, y, z)) for x in range(26, 37): roof_y = min(37, 24 + 2 * (8 - abs(x - 31))) for y in range(27, roof_y - 1): for z in range(11, 27): if name(world, (x, y, z)) == 'air': interior.append((x, y, z)) for x in range(10, 25): roof_y = 17 + (9 - abs(x - 17)) // 2 for y in range(17, roof_y): for z in range(11, 26): if name(world, (x, y, z)) == 'air': interior.append((x, y, z)) assert interior assert not (set(interior) & outside), list(set(interior) & outside)[:15] # Gable lofts and ridge air receive the same check. for p in [(17, 19, 18), (31, 33, 18), (16, 20, 11)]: assert p not in outside, p def test_decorations_supported_and_openings_clear(world): """Check every fragile decoration's floor or attachment, plus window volume.""" backing = {'north': (0, 1), 'south': (0, -1), 'east': (-1, 0), 'west': (1, 0)} for (x, y, z), (n, p) in world.items(): below = name(world, (x, y - 1, z)) if n == 'lantern' or n.endswith('_candle') or n.startswith('potted_') or n.endswith('_carpet') or n in ('chest', 'barrel', 'anvil', 'lectern', 'campfire', 'azalea'): assert below != 'air' or (n == 'barrel' and any(solid(world, (x + dx, y, z + dz)) for dx, dz in backing.values())), (n, x, y, z) if n == 'ladder' or n.endswith('_wall_banner'): dx, dz = backing[p['facing']] assert solid(world, (x + dx, y, z + dz)), (n, x, y, z) if n == 'vine': attached = False for direction, (dx, dz) in {'north': (0, -1), 'south': (0, 1), 'east': (1, 0), 'west': (-1, 0)}.items(): if p.get(direction) == 'true' and solid(world, (x + dx, y, z + dz)): attached = True assert attached, (n, x, y, z) if n.endswith('_trapdoor') and p['open'] == 'true': assert any(solid(world, (x + dx, y, z + dz)) for dx, dz in backing.values()), (n, x, y, z) for x, y, z, axis, width, height in Build().build().windows: for d in range(width): for dy in range(height): p = (x + (d if axis == 'x' else 0), y + dy, z + (d if axis == 'z' else 0)) assert name(world, p) == 'glass', p inward = (p[0] - 1, p[1], p[2]) if axis == 'z' else (p[0], p[1], p[2] + (1 if z == 10 else -1)) assert passable(world, inward) or name(world, inward).endswith('_wall_banner'), (p, inward, name(world, inward)) for y in (4, 5): for z in (9, 11): assert passable(world, (29, y, z)), (29, y, z) def test_furnishings_lights_and_nbt(world): """Verify nearby light at all room floors, striped curtains, frames and the open book.""" lights = [p for p, (n, props) in world.items() if n == 'lantern' or props.get('lit') == 'true'] for room in [(17, 4, 18), (30, 4, 18), (17, 11, 18), (30, 11, 18), (30, 18, 18), (30, 25, 18)]: assert min(sum(abs(a - b) for a, b in zip(room, p)) for p in lights) <= 8 raw = NBTFile.load_regardless_of_gzipped(ROOT / 'output.litematic') region = next(iter(raw['Regions'].values())) banners = [t for t in region['TileEntities'] if str(t['id']) == 'minecraft:banner'] assert len(banners) == 2 for t in banners: assert len(t['patterns']) == 3 assert all(str(p['color']) == 'green' for p in t['patterns']) books = [t for t in region['TileEntities'] if str(t['id']) == 'minecraft:lectern'] assert books and books[0]['Book']['components']['minecraft:written_book_content']['pages'] assert len(region['Entities']) >= 3 for e in region['Entities']: p = int(e['TileX']), int(e['TileY']), int(e['TileZ']) + 1 assert solid(world, p) assert str(e['Item']['id']).startswith('minecraft:') required = {'barrel', 'chest', 'green_carpet', 'white_candle', 'lectern', 'bookshelf', 'green_bed', 'anvil', 'blast_furnace'} assert required <= {n for n, _ in world.values()} @pytest.fixture def tmp_path(): """Keep test artifacts local and clean them when the test finishes.""" with TemporaryDirectory(dir=ROOT / 'test') as directory: yield Path(directory) def test_byte_reproducible(tmp_path): """Two fresh seeded builds must reproduce the delivered bytes exactly.""" expected = (ROOT / 'output.litematic').read_bytes() for i in range(2): p = tmp_path / f'rerun_{i}.litematic' Build().build().export(p) assert p.read_bytes() == expected

# Starting point for a Minecraft build generator. Copy into the workspace and fill in build(). # Everything that has to be right for the harness is already right here: bounds checked placement, # one seeded random source, and a byte reproducible export. from __future__ import annotations import argparse import gzip import io import random import sys from pathlib import Path from typing import Dict, Iterable, Optional, Tuple sys.path.insert(0, "/work/generator/MCIO") from mcio.schematic import load_schematic # noqa: E402 from mcio.nbt.nbt import File as NBTFile from mcio.nbt.tag import Compound, Int, String, Byte, Float, Double, IntArray, List as NBTList from mcio.sketch import LitematicCanvas, Material, parse_blockstate # noqa: E402 CONFIG = { "seed": 20260923, "size_xyz": (45, 40, 35), # width X, height Y, depth Z "minecraft_version": "1.21.1", "data_version": 3955, "output": "output.litematic", "name": "Amberstone Lodge", "author": "generator", "description": "Amber plaster and timber alpine lodge; furnished connected floors, forge, pine garden.", } Position = Tuple[int, int, int] class CanvasBuild: """Hold a block volume and write it out as a Litematica schematic.""" def __init__(self, size_xyz: Tuple[int, int, int] = CONFIG["size_xyz"], seed: int = CONFIG["seed"]) -> None: """Create an empty volume with one seeded random source. Args: size_xyz (Tuple[int, int, int]): Volume size as width X, height Y, depth Z. seed (int): Seed for every random decision in this build. """ self.size_x, self.size_y, self.size_z = size_xyz self.rng = random.Random(seed) self.canvas = LitematicCanvas((self.size_y, self.size_z, self.size_x)) self.placed: Dict[Position, str] = {} def inside(self, x: int, y: int, z: int) -> bool: """Report whether a coordinate is inside the volume. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: bool: True when every axis is within range. """ return 0 <= x < self.size_x and 0 <= y < self.size_y and 0 <= z < self.size_z def put(self, x: int, y: int, z: int, block: str | Material, **properties: str) -> None: """Place one block, in XYZ order, with an immediate bounds check. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. block (str | Material): Namespaced block name, a full blockstate string, or a Material. **properties: Blockstate properties such as facing or half. Raises: AssertionError: When the coordinate is outside the volume, naming the coordinate. """ assert self.inside(x, y, z), f"out of bounds: (x={x}, y={y}, z={z}) in {self.size_x}x{self.size_y}x{self.size_z}" material = self.material(block, **properties) if isinstance(block, str) else block self.canvas.block((y, z, x), material) self.placed[(x, y, z)] = material.blockstate def material(self, name: str, **properties: str) -> Material: """Build a Material from a block name and its properties. Args: name (str): Namespaced block name, or a full blockstate string. **properties: Blockstate properties. Returns: Material: Material ready for placement. """ if "[" in name: return parse_blockstate(name) return self.canvas.material(name, **dict(sorted(properties.items()))) def box(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill an inclusive box. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive on both ends. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, block, **properties) def shell(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill only the faces of a box, leaving the inside empty. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): on_face = x in (x0, x1) or y in (y0, y1) or z in (z0, z1) if on_face: self.put(x, y, z, block, **properties) def texture(self, bounds: Tuple[int, int, int, int, int, int], palette: Iterable[str]) -> None: """Fill a box with a weighted mix of related blocks, so the surface is not flat. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. palette (Iterable[str]): Block names. Repeat a name to make it more common. """ choices = list(palette) x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, self.rng.choice(choices)) def get(self, x: int, y: int, z: int) -> Optional[str]: """Read back what was placed at a coordinate. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: Optional[str]: Blockstate string, or None when the cell is empty. """ return self.placed.get((x, y, z)) def export(self, path: Path) -> Path: """Write the schematic so that two runs produce identical bytes. Args: path (Path): Destination .litematic path. Returns: Path: The path written. """ schematic = self.canvas.to_litematica( name=CONFIG["name"], author=CONFIG["author"], description=CONFIG["description"], minecraft_data_version=CONFIG["data_version"], ) # The metadata otherwise records the current wall clock, which changes the bytes on every run. schematic.metadata.time_created = 0 schematic.metadata.time_modified = 0 path.parent.mkdir(parents=True, exist_ok=True) schematic.save(path) return path def verify(self, path: Path) -> Dict[str, object]: """Reload the written file and confirm it matches what was placed. Args: path (Path): Schematic to reload. Returns: Dict[str, object]: Size, block count and palette size of the reloaded file. Raises: AssertionError: When a reloaded cell differs from what was placed. """ loaded = load_schematic(path) size_y, size_z, size_x = loaded.size_yzx assert (size_x, size_y, size_z) == (self.size_x, self.size_y, self.size_z), "size changed on reload" ids = loaded.read_flat(0, loaded.volume).reshape(loaded.size_yzx) for (x, y, z), state in self.placed.items(): assert loaded.palette[int(ids[y, z, x])] == state, f"cell (x={x}, y={y}, z={z}) changed on reload" return { "size_xyz": [size_x, size_y, size_z], "placed_blocks": len(self.placed), "palette_states": len(loaded.palette), } STONE = ["stone_bricks"] * 6 + ["cobblestone"] * 2 + ["andesite", "mossy_stone_bricks"] PAVING = ["stone_bricks"] * 5 + ["andesite", "cobblestone", "mossy_stone_bricks"] PLASTER = ["yellow_terracotta"] * 2 + ["smooth_sandstone"] * 6 + ["sandstone"] WOOD = ["spruce_planks"] * 7 + ["dark_oak_planks", "oak_planks"] ROOF = ["deepslate_tiles"] * 7 + ["deepslate_bricks"] * 2 + ["cobbled_deepslate"] class Build(CanvasBuild): """Construct Amberstone Lodge and preserve its decorative NBT.""" def __init__(self, *args, **kwargs): """Initialize the canvas and inspection records.""" super().__init__(*args, **kwargs) self.tile_entities = [] self.entities = [] self.windows = [] self.rooms = { 'entrance': (30, 4, 12), 'workshop': (15, 4, 15), 'living': (16, 10, 14), 'dining': (30, 10, 15), 'bedroom': (32, 17, 18), 'attic_study': (31, 24, 18), 'low_loft': (17, 17, 18), } def p(self, x, y, z, block, **props): """Place a vanilla block using its short name.""" self.put(x, y, z, 'minecraft:' + block, **props) def fill(self, bounds, block, **props): """Fill a box using a short block name.""" self.box(bounds, 'minecraft:' + block, **props) def mix(self, bounds, palette): """Texture a box using short block names.""" self.texture(bounds, ['minecraft:' + b for b in palette]) def beam(self, bounds, axis='y'): """Place a continuous dark timber beam.""" self.fill(bounds, 'spruce_log', axis=axis) def stair(self, x, y, z, facing, kind='spruce', half='bottom'): """Place a consistently specified stair.""" self.p(x, y, z, kind + '_stairs', facing=facing, half=half, shape='straight', waterlogged='false') def trap(self, x, y, z, facing='north', opened=True, half='bottom'): """Place timber shutters and cabinet fronts.""" self.p(x, y, z, 'spruce_trapdoor', facing=facing, half=half, open=str(opened).lower(), powered='false', waterlogged='false') def door(self, x, y, z, facing='north', hinge='left'): """Place a complete closed glass-paneled oak door.""" for half, dy in [('lower', 0), ('upper', 1)]: self.p(x, y + dy, z, 'oak_door', facing=facing, hinge=hinge, half=half, open='false', powered='false') def lantern(self, x, y, z, hanging=False): """Place a lantern; callers supply its bearing block or chain.""" self.p(x, y, z, 'lantern', hanging=str(hanging).lower(), waterlogged='false') def pendant(self, x, floor, z, ceiling): """Suspend a lantern near the room floor from a ceiling.""" for y in range(floor + 4, ceiling): self.p(x, y, z, 'chain', axis='y', waterlogged='false') self.lantern(x, floor + 3, z, True) def candle(self, x, y, z, color='white', count=3): """Place a lit candle cluster.""" self.p(x, y, z, color + '_candle', candles=str(count), lit='true', waterlogged='false') def chest(self, x, y, z, facing='north'): """Place a single chest with opening clearance.""" self.p(x, y, z, 'chest', facing=facing, type='single', waterlogged='false') def barrel(self, x, y, z, facing='north'): """Place a usable barrel cabinet.""" self.p(x, y, z, 'barrel', facing=facing, open='false') def tile(self, x, y, z, kind, **data): """Record a block entity at region-relative coordinates.""" self.tile_entities.append(Compound({'id': String('minecraft:' + kind), 'x': Int(x), 'y': Int(y), 'z': Int(z), **data})) def curtain(self, x, y, z, facing): """Hang white curtains carrying three green vertical stripes.""" self.p(x, y, z, 'white_wall_banner', facing=facing) self.tile(x, y, z, 'banner', patterns=NBTList[Compound]([Compound({'pattern': String('minecraft:' + pattern), 'color': String('green')}) for pattern in ('stripe_left', 'stripe_center', 'stripe_right')])) def frame(self, x, y, z, facing, item): """Attach a deterministic item frame to the adjacent wall.""" dx, dz, code, yaw = {'north': (0, -1, 2, 180), 'south': (0, 1, 3, 0), 'west': (-1, 0, 4, 90), 'east': (1, 0, 5, 270)}[facing] self.entities.append(Compound({ 'id': String('minecraft:item_frame'), 'Facing': Byte(code), 'TileX': Int(x), 'TileY': Int(y), 'TileZ': Int(z), 'Pos': NBTList[Double]([Double(x + .5 - dx * .46875), Double(y + .5), Double(z + .5 - dz * .46875)]), 'Rotation': NBTList[Float]([Float(yaw), Float(0)]), 'Motion': NBTList[Double]([Double(0), Double(0), Double(0)]), 'UUID': IntArray([20260923, x, y, z]), 'Fixed': Byte(0), 'Invisible': Byte(0), 'ItemRotation': Byte(0), 'ItemDropChance': Float(1), 'Item': Compound({ 'id': String('minecraft:' + item), 'count': Int(1) }), })) def window(self, axis, plane, a0, a1, y0, y1): """Insert sealed glass, projecting sills, and attached shutters.""" outward = -1 if (axis == 'z' and plane == 9) or (axis == 'x' and plane == 10) else 1 face = ('north' if outward < 0 else 'south') if axis == 'z' else ('west' if outward < 0 else 'east') def pos(a, y, offset=0): return (a, y, plane + offset) if axis == 'z' else (plane + offset, y, a) for a in range(a0, a1 + 1): for y in range(y0, y1 + 1): xyz = pos(a, y) self.p(*xyz, 'light_gray_stained_glass') self.windows.append((xyz, pos(a, y, outward), pos(a, y, -outward))) self.p(*pos(a, y0 - 1, outward), 'spruce_planks') self.stair(*pos(a, y1 + 1, outward), face, half='top') for a in (a0 - 1, a1 + 1): for y in range(y0, y1 + 1): self.trap(*pos(a, y, outward), face) def terrain(self): """Build an irregular grass island, paved terrace, steps, and path.""" for x in range(45): for z in range(35): edge = min(x, 44 - x, z, 34 - z) if edge > 0 or self.rng.random() < .65: self.p(x, 0, z, self.rng.choice(['grass_block'] * 8 + ['moss_block', 'coarse_dirt'])) for x in range(2, 42): for z in range(6, 31): if (x < 4 or x > 39) and (z < 8 or z > 28): continue self.mix((x, 1, z, x, 2, z), STONE) self.p(x, 3, z, self.rng.choice(PAVING)) for z, y in [(3, 1), (4, 2), (5, 3)]: for x in range(27, 33): self.fill((x, 0, z, x, y - 1, z), 'stone_bricks') self.stair(x, y, z, 'south', 'stone_brick') for z in range(0, 4): center = 29 + (2 - z) // 2 for x in range(center - 3, center + 4): if abs(x - center) < 3 or self.rng.random() < .65: self.p(x, 0, z, self.rng.choice(['dirt_path', 'coarse_dirt', 'gravel', 'granite'])) for x in list(range(3, 26)) + list(range(34, 40)): if x % 4 == 0: self.p(x, 4, 6, 'stone_brick_wall', up='true', east='low', west='low', north='none', south='none', waterlogged='false') for x, z in [(3, 8), (39, 8), (3, 28), (39, 28), (26, 6), (33, 6)]: self.p(x, 4, z, 'chiseled_stone_bricks') self.lantern(x, 5, z) for x in range(1, 44): for z in (2, 32, 33): if 25 <= x <= 35 and z < 6: continue if self.get(x, 0, z) and self.rng.random() < .28: self.p(x, 1, z, self.rng.choice(['short_grass', 'fern', 'poppy', 'dandelion'])) def walls(self): """Frame the stone ground floor and amber plaster upper walls.""" for x0, x1, top in [(10, 25, 16), (25, 37, 22)]: for x in range(x0, x1 + 1): for z in range(9, 28): if x in (x0, x1) or z in (9, 27): for y in range(4, top + 1): self.p(x, y, z, self.rng.choice(STONE if y < 9 else PLASTER)) for y in (3, 9): self.mix((x0, y, 9, x1, y, 27), WOOD if y == 9 else PAVING) for y in (9, 16): for z in (9, 27): self.beam((x0, y, z, x1, y, z), 'x') for x in (x0, x1): self.beam((x, y, 9, x, y, 27), 'z') for x in (x0, x1): for z in (9, 15, 21, 27): self.beam((x, 4, z, x, top, z)) for z in (9, 27): for x in range(x0, x1 + 1, 5): self.beam((x, 4, z, x, min(top, 16), z)) for y in (16, 23): self.mix((25, y, 9, 37, y, 27), WOOD) self.mix((10, 16, 9, 24, 16, 27), WOOD) for z in (9, 27): for x in (25, 28, 34, 37): self.beam((x, 16, z, x, 22, z)) self.beam((25, 22, z, 37, 22, z), 'x') # Wide internal portals join the two masses on the shared wall. for y in (4, 10): for z0 in (12, 23): self.fill((25, y, z0, 25, y + 3, z0 + 2), 'air') # Ground-floor double entrance, with a glass transom above it. for x, hinge in ((29, 'left'), (30, 'right')): self.door(x, 4, 9, hinge=hinge) self.p(x, 6, 9, 'light_gray_stained_glass') for x in (28, 31): self.beam((x, 4, 8, x, 7, 8)) self.beam((28, 7, 8, 31, 7, 8), 'x') # Rear garden door makes the hidden elevation useful as well. self.door(29, 4, 27, 'south') @staticmethod def low_roof_y(z): """Return the lower wing roof profile.""" return 17 + (10 - abs(z - 18)) // 2 @staticmethod def high_roof_y(x): """Return the steep gable profile including flared eaves.""" return {22: 20, 23: 21, 24: 22, 25: 24, 26: 26, 27: 28, 28: 30, 29: 32, 30: 34, 31: 36, 32: 34, 33: 32, 34: 30, 35: 28, 36: 26, 37: 24, 38: 22, 39: 21, 40: 20}[x] def roofs(self): """Close both pitched roofs with full-block weather skins and stair trim.""" for x in range(9, 26): for z in range(7, 30): top = self.low_roof_y(z) for y in range(top, top + 2): self.p(x, y, z, self.rng.choice(ROOF)) if z != 18: self.stair(x, top + 2, z, 'south' if z < 18 else 'north', 'deepslate_tile') else: self.p(x, top + 2, z, 'deepslate_tile_slab', type='bottom', waterlogged='false') # End gable seals the lower roof's loft; its rear is reconstructed consistently. for x in (10, 25): for z in range(9, 28): for y in range(17, self.low_roof_y(z)): self.p(x, y, z, self.rng.choice(PLASTER)) for x in range(22, 41): roof_y = self.high_roof_y(x) for z in range(7, 30): # The western roof meets and covers the lower wing roof continuously. for y in range(roof_y, roof_y + 2): self.p(x, y, z, self.rng.choice(ROOF)) if x != 31: self.stair(x, roof_y + 2, z, 'east' if x < 31 else 'west', 'deepslate_tile') else: self.p(x, roof_y + 2, z, 'deepslate_tile_slab', type='bottom', waterlogged='false') # Solid triangular front and rear gables under the roof profile. if 25 <= x <= 37: for z in (9, 27): for y in range(23, roof_y): self.p(x, y, z, self.rng.choice(PLASTER)) if roof_y > 24: self.beam((x, roof_y - 1, z, x, roof_y - 1, z)) for z in (9, 27): self.beam((31, 23, z, 31, 35, z)) for y, xa, xb in [(24, 26, 36), (30, 29, 33)]: self.beam((xa, y, z, xb, y, z), 'x') # Ridge finials repeat the reference silhouette without exceeding the region. for z in (7, 29): self.p(31, 38, z, 'deepslate_tiles') self.p(31, 39, z, 'spruce_fence', north='false', south='false', east='false', west='false', waterlogged='false') # Shallow front dormer on the low roof. self.fill((15, 19, 7, 20, 21, 10), 'spruce_planks') for x in range(16, 20): self.p(x, 20, 7, 'light_gray_stained_glass') self.beam((15, 19, 7, 20, 19, 7), 'x') for x in range(14, 22): for z in range(6, 12): self.p(x, 22, z, 'deepslate_tiles') self.stair(x, 23, z, 'south', 'deepslate_tile') def openings(self): """Place framed windows after structural work to preserve their openings.""" for z in (9, 27): for a, b in [(13, 14), (20, 21), (33, 34)]: self.window('z', z, a, b, 5, 6) for a, b in ([(12, 14), (19, 21), (29, 32)] if z == 9 else [(22, 23), (29, 32)]): self.window('z', z, a, b, 11, 13) self.window('z', z, 30, 32, 18, 21) self.window('z', z, 30, 32, 26, 29) for x in (10, 37): for z in ((12,) if x == 10 else (12, 22)): self.window('x', x, z, z + 2, 11, 13) self.window('x', x, 23, 24, 5, 6) self.window('x', 37, 12, 14, 18, 20) # Exterior brackets each carry one lantern and attach directly to a beam. for x, y, z in [(11, 7, 8), (24, 7, 8), (27, 7, 8), (36, 7, 8), (27, 14, 8), (35, 14, 8), (27, 7, 28), (35, 7, 28)]: self.p(x, y, z, 'spruce_planks') self.lantern(x, y - 1, z, True) def circulation(self): """Install generous stairs plus wall ladders connecting all four floors.""" # Two-wide main stair climbs south from the workshop into the living room. for i in range(6): z, y = 17 + i, 4 + i self.fill((21, y, z, 22, y + 3, z), 'air') for x in (21, 22): self.fill((x, 4, z, x, y - 1, z), 'spruce_planks') if y > 4 else None self.stair(x, y, z, 'south') self.fill((21, 9, 20, 22, 9, 22), 'air') # Restore the upper treads after opening the floor. for i in range(3, 6): for x in (21, 22): self.stair(x, 4 + i, 17 + i, 'south') self.fill((21, 10, 23, 22, 12, 24), 'air') # Ladder in a timber-lined rear stair hall, with landing exits on every level. self.beam((34, 4, 25, 34, 27, 25)) for y in range(4, 25): self.p(34, y, 24, 'ladder', facing='north', waterlogged='false') if y in (9, 16, 23): self.p(34, y + 1, 24, 'ladder', facing='north', waterlogged='false') # Dedicated ladder reaches the furnished low loft through its ceiling. self.beam((23, 10, 19, 23, 21, 19)) for y in range(10, 18): self.p(23, y, 18, 'ladder', facing='north', waterlogged='false') # Clear central landing approach, leaving one complete roofed envelope. for y in (4, 10, 17, 24): self.fill((33, y, 22, 35, y + 1, 23), 'air') def smithy(self): """Build the covered forge, lit hearth, masonry chimney, tools and stock.""" for x, z in ((3, 12), (3, 25), (9, 12), (9, 25)): self.beam((x, 4, z, x, 9, z)) for z in (12, 25): self.beam((3, 9, z, 10, 9, z), 'x') for x in range(2, 11): y = 7 + (x - 2) // 5 for z in range(11, 27): self.p(x, y + 1, z, self.rng.choice(ROOF)) self.stair(x, y + 2, z, 'east', 'deepslate_tile') # Forge is wholly outside the main sealed envelope, opening west. self.mix((7, 4, 18, 9, 7, 22), STONE) self.fill((7, 5, 19, 8, 6, 21), 'air') for z in range(19, 22): self.p(8, 5, z, 'campfire', facing='west', lit='true', signal_fire='false', waterlogged='false') self.p(7, 5, 20, 'iron_bars', north='true', south='true', east='false', west='false', waterlogged='false') self.mix((8, 8, 19, 9, 24, 21), ['cobblestone', 'stone_bricks', 'andesite']) self.fill((7, 23, 18, 9, 23, 22), 'stone_brick_slab', type='top', waterlogged='false') self.fill((8, 25, 19, 9, 25, 21), 'stone_brick_slab', type='bottom', waterlogged='false') for z in (19, 21): self.p(8, 24, z, 'cobblestone_wall', up='true', north='none', south='none', west='none', east='none', waterlogged='false') self.p(5, 4, 17, 'smooth_stone') self.p(5, 5, 17, 'anvil', facing='north') self.p(5, 4, 20, 'smithing_table') self.barrel(4, 4, 24) self.barrel(5, 4, 24) self.chest(6, 4, 24) self.p(4, 4, 14, 'water_cauldron', level='3') self.p(8, 4, 14, 'blast_furnace', facing='west', lit='true') self.lantern(3, 7, 13, True) self.frame(7, 7, 17, 'north', 'iron_pickaxe') def pine(self, x, z, height): """Grow a hand-built pine with tiered radial timber branches.""" base = 1 self.beam((x, base, z, x, height, z)) for y in range(5, height - 1, 3): radius = max(1, (height - y) // 5) for dx, dz in ((1, 0), (-1, 0), (0, 1), (0, -1)): for r in range(1, radius + 1): xx, zz = x + dx * r, z + dz * r if self.inside(xx, y, zz): self.p(xx, y, zz, 'spruce_log', axis='x' if dx else 'z') for dx in range(-radius - 1, radius + 2): for dz in range(-radius - 1, radius + 2): if abs(dx) + abs(dz) > radius + 1 or (dx == 0 and dz == 0): continue xx, zz = x + dx, z + dz if self.inside(xx, y + 1, zz): self.p(xx, y + 1, zz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') if abs(dx) + abs(dz) <= radius: self.p(xx, y + 2, zz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') self.p(x, height + 1, z, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') def furniture(self): """Furnish every level with purposeful room layouts.""" # Entrance hall: red runner, chest bench, tall book wall and potted greenery. self.fill((28, 4, 11, 30, 4, 18), 'red_carpet') for z in range(11, 20): self.barrel(36, 4, z, 'west') for z in (11, 12, 16, 17, 18): self.fill((36, 5, z, 36, 7, z), 'bookshelf') self.trap(35, 7, z, 'west') self.p(36, 5, 14, 'potted_fern') self.candle(36, 5, 15) self.chest(26, 4, 18, 'east') self.stair(26, 4, 19, 'west', 'dark_oak') self.stair(26, 4, 20, 'west', 'dark_oak') self.frame(26, 6, 20, 'east', 'clock') for x, z in [(28, 13), (32, 20)]: self.pendant(x, 3, z, 9) # Workshop and stores, with clear main stair and portals. for x in range(11, 18): self.barrel(x, 4, 26) if x % 2 and x != 13: self.barrel(x, 5, 26) for x in (12, 15, 18): self.chest(x, 4, 11, 'south') self.p(11, 4, 18, 'crafting_table') self.p(11, 4, 19, 'stonecutter', facing='east') self.p(11, 4, 20, 'smithing_table') self.fill((12, 4, 18, 14, 4, 18), 'spruce_planks') self.candle(13, 5, 18) self.p(14, 5, 18, 'potted_dead_bush') self.frame(12, 6, 26, 'north', 'iron_axe') self.beam((12, 6, 27, 12, 6, 27)) for x, z in [(15, 14), (17, 23)]: self.pendant(x, 3, z, 9) # Living room: green carpet, chairs, low table and stone chimney breast. self.fill((14, 10, 13, 18, 10, 18), 'green_carpet') for z in range(14, 18): self.stair(12, 10, z, 'west', 'dark_oak') for x in range(15, 19): self.stair(x, 10, 20, 'south', 'dark_oak') self.fill((15, 10, 15, 17, 10, 16), 'dark_oak_planks') self.candle(16, 11, 15) self.p(17, 11, 16, 'potted_red_tulip') self.mix((11, 10, 24, 14, 15, 26), ['stone_bricks', 'andesite', 'cobblestone']) self.fill((12, 10, 24, 13, 11, 24), 'air') for x in (12, 13): self.p(x, 10, 25, 'campfire', facing='north', lit='true', signal_fire='false', waterlogged='false') self.p(x, 10, 24, 'iron_bars', east='true', west='true', north='false', south='false', waterlogged='false') for x in range(17, 21): self.barrel(x, 10, 26) self.fill((x, 11, 26, x, 13, 26), 'bookshelf') self.p(18, 14, 26, 'potted_fern') for x, z in [(17, 12), (18, 23)]: self.pendant(x, 9, z, 16) self.frame(11, 14, 19, 'east', 'painting') # Dining floor in the tower: kitchen dressers, stove and long refectory table. for z in range(11, 19): self.barrel(26, 10, z, 'east') self.p(26, 11, 12, 'potted_dandelion') self.candle(26, 11, 15) self.p(26, 11, 17, 'smoker', facing='east', lit='true') self.fill((29, 10, 17, 31, 10, 20), 'dark_oak_planks') for z in (17, 19): self.stair(28, 10, z, 'west', 'dark_oak') self.stair(32, 10, z, 'east', 'dark_oak') self.candle(30, 11, 18) self.p(30, 11, 20, 'potted_azure_bluet') for z in (12, 20): self.pendant(33, 9, z, 16) # Bedroom's raised green double bed, headboard and stepped dais. self.fill((27, 17, 17, 31, 17, 20), 'dark_oak_planks') for x in range(27, 32): self.stair(x, 17, 16, 'south', 'dark_oak') for x in (28, 29): self.p(x, 18, 18, 'green_bed', facing='south', part='foot', occupied='false') self.p(x, 18, 19, 'green_bed', facing='south', part='head', occupied='false') self.fill((27, 18, 20, 31, 19, 20), 'dark_oak_planks') for x in (27, 30): self.barrel(x, 18, 19) self.lantern(x, 19, 19) self.fill((28, 20, 20, 30, 20, 20), 'bookshelf') self.fill((27, 21, 20, 31, 21, 20), 'spruce_slab', type='top', waterlogged='false') # Cabinets sit against a wall, shelf plants have full supporting blocks. for z in range(11, 16): self.barrel(26, 17, z, 'east') self.barrel(26, 20, z, 'east') self.p(26, 18, 11, 'potted_blue_orchid') self.candle(26, 18, 15) self.fill((30, 17, 11, 32, 17, 11), 'dark_oak_planks') self.fill((30, 18, 11, 32, 18, 11), 'white_carpet') for x in (29, 33): self.curtain(x, 21, 10, 'south') for z in (11, 15): self.curtain(36, 21, z, 'west') self.fill((32, 17, 13, 34, 17, 18), 'green_carpet') self.chest(36, 17, 19, 'west') self.frame(26, 19, 16, 'east', 'compass') self.pendant(33, 16, 16, 23) self.pendant(29, 16, 24, 23) # Attic study: oak writing desk, readable lectern, candle and library. self.fill((28, 24, 12, 28, 26, 18), 'bookshelf') self.fill((29, 24, 12, 33, 24, 12), 'dark_oak_planks') self.p(31, 25, 12, 'lectern', facing='south', has_book='true', powered='false') self.tile(31, 25, 12, 'lectern', Page=Int(0), Book=Compound({'id': String('minecraft:written_book'), 'count': Int(1), 'components': Compound({'minecraft:written_book_content': Compound({'title': Compound({'raw': String('Amberstone Ledger')}), 'author': String('The Lodgekeeper'), 'generation': Int(0), 'resolved': Byte(1), 'pages': NBTList[Compound]([Compound({'raw': String('{"text":"Amberstone Lodge\\n\\nPine resin, iron stock, and winter stores.\\n\\nThe mountain road is open."}')})])})})})) self.candle(29, 25, 12) self.p(33, 25, 12, 'potted_fern') self.stair(31, 24, 14, 'south', 'dark_oak') self.fill((30, 24, 16, 32, 24, 20), 'green_carpet') for z in (19, 20, 21): self.barrel(28, 24, z, 'east') self.chest(29, 24, 25) self.chest(31, 24, 25) self.p(30, 25, 25, 'lantern', hanging='false', waterlogged='false') self.p(30, 24, 25, 'spruce_planks') self.fill((31, 28, 17, 31, 35, 17), 'chain', axis='y', waterlogged='false') self.lantern(31, 27, 17, True) self.frame(30, 25, 26, 'north', 'map') # Furnished low loft, reached by the second ladder. for x in (12, 14, 16): self.barrel(x, 17, 20) self.chest(x, 18, 20) self.fill((13, 17, 16, 17, 17, 16), 'spruce_planks') self.candle(15, 18, 16) self.p(17, 18, 16, 'potted_fern') self.stair(15, 17, 18, 'south', 'spruce') self.p(19, 17, 18, 'spruce_planks') self.lantern(19, 18, 18) def greenery(self): """Add supported climbing vines and pines behind the smithy.""" self.pine(5, 30, 20) self.pine(17, 31, 28) # Each vine segment attaches directly to a solid facade block. for x, max_y in ((26, 15), (27, 12), (35, 9), (36, 13)): for y in range(4, max_y + 1): if self.get(x, y, 8) is None and self.get(x, y, 9) and 'glass' not in self.get(x, y, 9): self.p(x, y, 8, 'vine', south='true', north='false', east='false', west='false', up='false') for x, z in ((24, 7), (35, 7), (38, 26)): self.p(x, 4, z, 'moss_block') self.p(x, 5, z, 'azalea') # Hall plants trail from the bookshelf wall; no foliage blocks the corridor. for z in (17, 18): for y in (5, 6): if self.get(35, y, z) is None: self.p(35, y, z, 'vine', east='true', west='false', north='false', south='false', up='false') def build(self): """Construct the complete lodge in a deterministic placement order.""" self.terrain() self.walls() self.roofs() self.openings() self.smithy() self.furniture() self.circulation() self.greenery() return self def export(self, path: Path) -> Path: """Export one region with deterministic block entities and item frames.""" super().export(path) with path.open('rb') as stream: nbt = NBTFile.from_fileobj(stream) region = nbt['Regions'][CONFIG['name']] region['TileEntities'] = NBTList[Compound](self.tile_entities) region['Entities'] = NBTList[Compound](self.entities) buffer = io.BytesIO() nbt.write(buffer) path.write_bytes(gzip.compress(buffer.getvalue(), mtime=0)) return path def main() -> None: """Generate the build, export it, and verify the exported file.""" parser = argparse.ArgumentParser(description="Generate a Minecraft schematic.") parser.add_argument("--output", type=Path, default=Path(CONFIG["output"])) parser.add_argument("--seed", type=int, default=CONFIG["seed"]) args = parser.parse_args() build = Build(seed=args.seed).build() path = build.export(args.output) report = build.verify(path) print(f"wrote {path}: {report}") if __name__ == "__main__": main()

# Export cropped, open-wall inspection models from the delivered schematic. from pathlib import Path from generate import CONFIG, LitematicCanvas, load_schematic, parse_blockstate ROOT = Path(__file__).resolve().parent VIEWS = { 'ground_rooms': (10, 3, 9, 37, 8, 27), 'living_dining': (10, 9, 9, 37, 15, 27), 'bedroom': (25, 16, 9, 37, 22, 27), 'attic_study': (27, 23, 9, 35, 30, 27), 'low_loft': (10, 16, 11, 24, 21, 25), } def main(): """Make floor-level cutaways; omitted walls are for inspection only.""" source = load_schematic(ROOT / 'output.litematic') ids = source.read_flat(0, source.volume).reshape(source.size_yzx) for name, (x0, y0, z0, x1, y1, z1) in VIEWS.items(): canvas = LitematicCanvas((y1 - y0 + 1, z1 - z0 + 1, x1 - x0 + 1)) for y in range(y0, y1 + 1): for z in range(z0, z1 + 1): for x in range(x0, x1 + 1): if y > y0 and (z == z0 or x == x0): continue state = source.palette[int(ids[y, z, x])] if name in {'low_loft', 'attic_study'} and 'deepslate' in state: continue canvas.block((y - y0, z - z0, x - x0), parse_blockstate(state)) schematic = canvas.to_litematica(name=name, minecraft_data_version=CONFIG['data_version']) schematic.metadata.time_created = schematic.metadata.time_modified = 0 schematic.save(ROOT / 'previews' / (name + '.litematic')) if __name__ == '__main__': main()

// Starting point for rendering a build. Copy into the workspace and edit VIEWS. // Lighting, camera framing and background are already tuned; run it as is to get a first look. import fs from 'node:fs'; import path from 'node:path'; import { createRequire } from 'node:module'; import { createRenderScene, renderLitematicWithMetadata } from '/work/generator/MCRender/src/headless/index.ts'; const RENDER_ROOT = '/work/generator/MCRender'; const requireRenderer = createRequire(path.join(RENDER_ROOT, 'package.json')); const { PNG } = requireRenderer('pngjs'); // vite-node passes script arguments after a bare "--", so drop it before reading them. const argv = process.argv.slice(2).filter(entry => entry !== '--'); const INPUT = argv[0] ?? 'output.litematic'; const OUT_DIR = argv[1] ?? 'previews'; const SIZE = Number(process.env.RENDER_SIZE ?? 900); // Tuned defaults. Ambient near 0.72 keeps shaded faces readable, and a light direction with a // dominant +Y term plus a small +X/+Z tilt separates roof, wall and ground planes. const LIGHT_DIRECTION = [0.08, 0.28, 0.15]; const AMBIENT = 0.72; const BACKGROUND = [47, 52, 59, 255]; const VIEWS = [ { name: 'front', azimuth: 210, elevation: 20, radius: 3.4 }, { name: 'rear', azimuth: 35, elevation: 22, radius: 3.4 }, { name: 'side', azimuth: 120, elevation: 18, radius: 3.4 }, { name: 'top', azimuth: 210, elevation: 62, radius: 3.5 }, { name: 'ground_rooms', azimuth: 210, elevation: 48, radius: 4.0, cutaway: true }, { name: 'living_dining', azimuth: 210, elevation: 48, radius: 4.0, cutaway: true }, { name: 'bedroom', azimuth: 210, elevation: 42, radius: 4.0, cutaway: true }, { name: 'attic_study', azimuth: 210, elevation: 42, radius: 4.0, cutaway: true }, { name: 'low_loft', azimuth: 210, elevation: 42, radius: 4.0, cutaway: true }, ]; // Resolve every path while the working directory is still the caller's. const absoluteInput = path.resolve(INPUT); const absoluteOutDir = path.resolve(OUT_DIR); fs.mkdirSync(absoluteOutDir, { recursive: true }); // The renderer looks for its resource cache relative to the working directory, so move there first, // and only then create the scene. process.chdir(RENDER_ROOT); const scene = createRenderScene({ width: SIZE, height: SIZE }); for (const view of VIEWS) { const result = renderLitematicWithMetadata(view.cutaway ? path.join(absoluteOutDir, `${view.name}.litematic`) : absoluteInput, { width: SIZE, height: SIZE, fov_deg: 30, radius: view.radius, nRandomAzimuths: 0, azimuthInit: 0, elevationInit: 0, azimuthsDeltas: [view.azimuth], elevationsDeltas: [view.elevation], ambientIntensities: [AMBIENT], lightDirections: [LIGHT_DIRECTION], mirror: [false], layout: [[0]], limit: 512, seed: 0, opaque: false, }, scene); // Flatten onto an opaque background so shaded faces keep their contrast. for (let i = 0; i < result.png.data.length; i += 4) { const alpha = result.png.data[i + 3] / 255; for (let channel = 0; channel < 3; channel++) { result.png.data[i + channel] = Math.round(result.png.data[i + channel] * alpha + BACKGROUND[channel] * (1 - alpha)); } result.png.data[i + 3] = 255; } const target = path.join(absoluteOutDir, `${view.name}.png`); fs.writeFileSync(target, PNG.sync.write(result.png)); console.log(`wrote ${target} (${SIZE}x${SIZE}, azimuth ${view.azimuth}, elevation ${view.elevation})`); }

# Validate the delivered Minecraft geometry and NBT independently after reload. from collections import deque import gzip import json from pathlib import Path import sys import subprocess import tempfile import pytest ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) from generate import Build, CONFIG, NBTFile, load_schematic DIRECTIONS = {'north': (0, 0, -1), 'south': (0, 0, 1), 'west': (-1, 0, 0), 'east': (1, 0, 0)} AXES = list(DIRECTIONS.values()) + [(0, 1, 0), (0, -1, 0)] AIRLIKE = {'air', 'ladder', 'vine', 'chain', 'white_wall_banner'} def add(a, b): """Add two coordinates.""" return tuple(x + y for x, y in zip(a, b)) def parse(state): """Split a blockstate into its name and properties.""" name, _, raw = state.partition('[') return name.removeprefix('minecraft:'), (dict(p.split('=') for p in raw.rstrip(']').split(',')) if raw else {}) class Volume: """Read the delivered file without relying on placement bookkeeping.""" def __init__(self, path): """Load block data and the original entity lists.""" self.loaded = load_schematic(path) self.ids = self.loaded.read_flat(0, self.loaded.volume).reshape(self.loaded.size_yzx) self.palette = [parse(s) for s in self.loaded.palette] with gzip.open(path, 'rb') as stream: self.nbt = NBTFile.from_fileobj(stream) self.region = next(iter(self.nbt['Regions'].values())) def at(self, p): """Get a parsed state, treating out-of-volume cells as outside.""" x, y, z = p if not (0 <= x < 45 and 0 <= y < 40 and 0 <= z < 35): return 'outside', {} return self.palette[int(self.ids[y, z, x])] def cells(self): """Iterate every region cell.""" for y in range(40): for z in range(35): for x in range(45): yield (x, y, z), self.at((x, y, z)) @pytest.fixture(scope='module') def volume(): """Inspect the exact contract output.""" return Volume(ROOT / 'output.litematic') @pytest.fixture(scope='module') def design(): """Read declared room targets and compare to a fresh deterministic build.""" return Build().build() def is_clear(name): """Report whether a player can occupy a cell, allowing usable doors.""" return name in AIRLIKE or name.endswith('_carpet') or name.endswith('_door') def is_full(name): """Identify solid bearing blocks among the build's block vocabulary.""" return name not in AIRLIKE | {'outside', 'lantern', 'iron_bars', 'azalea', 'fern', 'short_grass', 'poppy', 'dandelion'} and not any(t in name for t in ('_stairs', '_slab', '_door', '_trapdoor', '_candle', '_wall', '_fence', 'potted_', '_bed', '_carpet')) def test_single_region_version_dimensions_and_palette(volume): """Check Minecraft version, dimensions, all block IDs, and property values.""" assert volume.loaded.size_yzx == (40, 35, 45) assert int(volume.nbt['MinecraftDataVersion']) == 3955 assert len(volume.nbt['Regions']) == 1 registry = json.loads(Path('/work/generator/MCRender/resources/1.21.1-blocks.json').read_text()) for name, props in volume.palette: assert name in registry, name for key, value in props.items(): assert key in registry[name][0] and value in registry[name][0][key], (name, key, value) def test_doors_beds_complete_and_clear(volume): """Check paired blocks, orientation, support and usable approaches.""" doors = beds = 0 for p, (name, props) in volume.cells(): if name.endswith('_door'): dy = 1 if props['half'] == 'lower' else -1 mate, mp = volume.at(add(p, (0, dy, 0))) assert mate == name and mp['half'] != props['half'], p for key in ('facing', 'hinge', 'open', 'powered'): assert props[key] == mp[key], p if dy == 1: doors += 1 assert is_full(volume.at(add(p, (0, -1, 0)))[0]) direction = DIRECTIONS[props['facing']] for sign in (-1, 1): side = add(p, tuple(sign * a for a in direction)) assert is_clear(volume.at(side)[0]), side assert is_clear(volume.at(add(side, (0, 1, 0)))[0]), side if name.endswith('_bed'): d = DIRECTIONS[props['facing']] sign = 1 if props['part'] == 'foot' else -1 mate, mp = volume.at(add(p, tuple(sign * a for a in d))) assert mate == name and mp['part'] != props['part'] and mp['facing'] == props['facing'], p assert is_full(volume.at(add(p, (0, -1, 0)))[0]), p assert is_clear(volume.at(add(p, (0, 1, 0)))[0]), p beds += props['part'] == 'foot' assert doors >= 3 and beds >= 1 def test_all_rooms_reachable_with_two_block_headroom(volume, design): """Flood actual walking positions using stairs and ladders, never flying.""" def standable(p): name, _ = volume.at(p) head, _ = volume.at(add(p, (0, 1, 0))) below, _ = volume.at(add(p, (0, -1, 0))) if not is_clear(name) or not is_clear(head): return False return name == 'ladder' or is_full(below) or below.endswith('_stairs') or below.endswith('_slab') start = (29, 4, 8) assert standable(start) queue, seen = deque([start]), {start} while queue: p = queue.popleft() candidates = [] for dx, _, dz in DIRECTIONS.values(): for dy in (-1, 0, 1): q = add(p, (dx, dy, dz)) # Height changes require a stair tread, not jumping over furniture. if dy and not (volume.at(add(q if dy > 0 else p, (0, -1, 0)))[0].endswith('_stairs')): continue if dy and not is_clear(volume.at(add(p if dy > 0 else q, (0, 2, 0)))[0]): continue candidates.append(q) for dy in (-1, 1): q = add(p, (0, dy, 0)) if volume.at(p)[0] == 'ladder' or volume.at(q)[0] == 'ladder': candidates.append(q) for q in candidates: if q not in seen and standable(q): seen.add(q) queue.append(q) for room, p in design.rooms.items(): assert p in seen, (room, p, 'not reachable with full headroom') # Both stair lanes must also be usable, not only the tower ladder. for x in (21, 22): for i in range(6): assert (x, 5 + i, 17 + i) in seen def test_envelope_separates_all_interior_air_from_sky(volume): """Flood exterior air and reject leaks anywhere in the modeled interiors.""" def permeable(p): name, _ = volume.at(p) return name in AIRLIKE or name.endswith('_carpet') or name in {'lantern', 'iron_bars'} or 'potted_' in name or name.endswith('_candle') seeds = [(x, 39, z) for x in range(45) for z in range(35)] seeds += [(x, y, z) for x in (0, 44) for y in range(40) for z in range(35)] seeds += [(x, y, z) for z in (0, 34) for y in range(40) for x in range(45)] seen = {p for p in seeds if permeable(p)} queue = deque(seen) while queue: p = queue.popleft() for d in AXES: q = add(p, d) if q not in seen and permeable(q): seen.add(q) queue.append(q) leaks = [] interior_count = 0 for p, (name, _) in volume.cells(): x, y, z = p low = 11 <= x <= 24 and 10 <= z <= 26 and 4 <= y < Build.low_roof_y(z) tower = 26 <= x <= 36 and 10 <= z <= 26 and 4 <= y < Build.high_roof_y(x) if (low or tower) and name == 'air': interior_count += 1 if p in seen: leaks.append(p) assert interior_count > 6000 assert not leaks, f'{len(leaks)} sky-connected interior cells; first {leaks[:12]}' def test_windows_have_glass_and_clear_openings(volume, design): """Detect overwritten glass and roof/chimney/furniture obstructions.""" assert len(design.windows) > 100 for glass, exterior, interior in design.windows: assert volume.at(glass)[0] == 'light_gray_stained_glass', glass for p in (exterior, interior): name, _ = volume.at(p) assert is_clear(name), (glass, p, name) def test_decoration_support_and_ladder_backing(volume): """Check every fragile decoration has a bearing or attachment block.""" errors = [] for p, (name, props) in volume.cells(): support = None if name == 'lantern': support = add(p, (0, 1 if props['hanging'] == 'true' else -1, 0)) elif name.endswith('_candle') or name.startswith('potted_') or name.endswith('_carpet') or name in {'azalea', 'fern', 'short_grass', 'poppy', 'dandelion'}: support = add(p, (0, -1, 0)) elif name in {'ladder', 'white_wall_banner'} or name.endswith('_trapdoor'): support = add(p, tuple(-v for v in DIRECTIONS[props['facing']])) elif name == 'chain': support = add(p, (0, 1, 0)) elif name == 'vine': attached = [add(p, DIRECTIONS[f]) for f in DIRECTIONS if props.get(f) == 'true'] assert attached and all(is_full(volume.at(q)[0]) for q in attached), (p, attached) if support: base = volume.at(support)[0] if not (is_full(base) or (name in {'lantern', 'chain'} and base == 'chain')): errors.append((p, name, support, base)) assert not errors, errors[:30] def test_nbt_curtains_frames_and_open_book(volume): """Check visual details the block renderer cannot display.""" tiles = volume.region['TileEntities'] banners = [t for t in tiles if str(t['id']) == 'minecraft:banner'] assert len(banners) == 4 for t in banners: assert [str(p['pattern']) for p in t['patterns']] == ['minecraft:stripe_left', 'minecraft:stripe_center', 'minecraft:stripe_right'] assert all(str(p['color']) == 'green' for p in t['patterns']) assert volume.at(tuple(int(t[a]) for a in ('x', 'y', 'z')))[0] == 'white_wall_banner' lecterns = [t for t in tiles if str(t['id']) == 'minecraft:lectern'] assert len(lecterns) == 1 assert lecterns[0]['Book']['components']['minecraft:written_book_content']['pages'] for t in lecterns: assert volume.at(tuple(int(t[a]) for a in ('x', 'y', 'z')))[1]['has_book'] == 'true' frames = volume.region['Entities'] assert len(frames) >= 6 for frame in frames: p = tuple(int(frame[a]) for a in ('TileX', 'TileY', 'TileZ')) direction = {2: 'north', 3: 'south', 4: 'west', 5: 'east'}[int(frame['Facing'])] backing = add(p, tuple(-v for v in DIRECTIONS[direction])) assert is_full(volume.at(backing)[0]), (p, backing) assert is_clear(volume.at(p)[0]), (p, volume.at(p)) assert int(frame['Item']['count']) == 1 def test_every_room_has_local_light_and_furnishings(volume, design): """Require nearby lights and characteristic furniture on every level.""" lights = [] for p, (name, props) in volume.cells(): if name == 'lantern' or props.get('lit') == 'true': lights.append(p) for room, (x, y, z) in design.rooms.items(): nearby = [p for p in lights if abs(p[0] - x) + abs(p[2] - z) <= 8 and abs(p[1] - y) <= 3] assert nearby, room for y0, y1 in [(4, 8), (10, 15), (17, 22), (24, 29)]: names = {name for (x, y, z), (name, _) in volume.cells() if 10 < x < 37 and 9 < z < 27 and y0 <= y <= y1} assert 'barrel' in names assert 'lantern' in names assert 'dark_oak_stairs' in names or 'spruce_stairs' in names assert any(n.startswith('potted_') for n in names) assert volume.at((8, 5, 20))[1]['lit'] == 'true' assert volume.at((5, 5, 17))[0] == 'anvil' def test_reproducible_export_and_roundtrip(design): """Compare two clean exports and the delivered file byte for byte.""" with tempfile.TemporaryDirectory(dir=ROOT / 'test') as temp: a, b = Path(temp) / 'a.litematic', Path(temp) / 'b.litematic' design.export(a) clean = Path(temp) / 'clean' clean.mkdir() subprocess.run([sys.executable, str(ROOT / 'generate.py')], cwd=clean, check=True, capture_output=True) b = clean / 'output.litematic' design.verify(b) assert a.read_bytes() == b.read_bytes() == (ROOT / 'output.litematic').read_bytes() def test_all_components_grounded_and_containers_usable(volume): """Reject floating decoration clusters and chests with obstructed lids.""" blocks = {p for p, (name, _) in volume.cells() if name != 'air'} seen = {p for p in blocks if p[1] == 0} queue = deque(seen) while queue: p = queue.popleft() for d in AXES: q = add(p, d) if q in blocks and q not in seen: seen.add(q) queue.append(q) assert blocks == seen, sorted(blocks - seen) for p, (name, _) in volume.cells(): if name == 'chest': assert is_full(volume.at(add(p, (0, -1, 0)))[0]), p assert is_clear(volume.at(add(p, (0, 1, 0)))[0]), p for z in (7, 29): assert is_full(volume.at((31, 38, z))[0])

# Generate the furnished Amberstone Lodge as a deterministic Java 1.21.1 litematic. # Run with no arguments in a clean working directory to create output.litematic. from __future__ import annotations import argparse import random import sys from pathlib import Path from typing import Dict, Iterable, Optional, Tuple sys.path.insert(0, "/work/generator/MCIO") from mcio.nbt.nbt import File as NBTFile from mcio.nbt.tag import Compound, String, Int, Byte, Short, Double, Float, IntArray, List as NBTList from mcio.schematic import load_schematic # noqa: E402 from mcio.sketch import LitematicCanvas, Material, parse_blockstate # noqa: E402 CONFIG = { "seed": 20260923, "size_xyz": (45, 41, 35), # width X, height Y, depth Z "minecraft_version": "1.21.1", "data_version": 3955, "output": "output.litematic", "name": "Amberstone Lodge", "author": "generator", "description": "Amberstone Lodge | furnished timber hall, steep gabled tower, smithy and pines | Java 1.21.1", } Position = Tuple[int, int, int] DIRECTIONS = {'north': (0, -1), 'south': (0, 1), 'east': (1, 0), 'west': (-1, 0)} STONE = ('stone_bricks',) * 6 + ('cobblestone',) * 2 + ('mossy_stone_bricks',) PAVING = ('stone_bricks',) * 5 + ('andesite',) * 2 + ('cobblestone',) PLASTER = ('end_stone_bricks',) * 8 + ('sandstone',) * 3 + ('smooth_sandstone',) * 3 FLOOR = ('spruce_planks',) * 8 + ('dark_oak_planks',) * 2 + ('stripped_spruce_log',) ROOF = ('deepslate_tiles',) * 10 + ('deepslate_bricks',) * 3 + ('cobbled_deepslate',) CHIMNEY = ('cobblestone',) * 4 + ('andesite',) * 3 + ('stone_bricks',) * 2 class Build: """Hold a block volume and write it out as a Litematica schematic.""" def __init__(self, size_xyz: Tuple[int, int, int] = CONFIG["size_xyz"], seed: int = CONFIG["seed"]) -> None: """Create an empty volume with one seeded random source. Args: size_xyz (Tuple[int, int, int]): Volume size as width X, height Y, depth Z. seed (int): Seed for every random decision in this build. """ self.size_x, self.size_y, self.size_z = size_xyz self.rng = random.Random(seed) self.canvas = LitematicCanvas((self.size_y, self.size_z, self.size_x)) self.placed: Dict[Position, str] = {} def inside(self, x: int, y: int, z: int) -> bool: """Report whether a coordinate is inside the volume. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: bool: True when every axis is within range. """ return 0 <= x < self.size_x and 0 <= y < self.size_y and 0 <= z < self.size_z def put(self, x: int, y: int, z: int, block: str | Material, **properties: str) -> None: """Place one block, in XYZ order, with an immediate bounds check. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. block (str | Material): Namespaced block name, a full blockstate string, or a Material. **properties: Blockstate properties such as facing or half. Raises: AssertionError: When the coordinate is outside the volume, naming the coordinate. """ assert self.inside(x, y, z), f"out of bounds: (x={x}, y={y}, z={z}) in {self.size_x}x{self.size_y}x{self.size_z}" material = self.material(block, **properties) if isinstance(block, str) else block self.canvas.block((y, z, x), material) self.placed[(x, y, z)] = material.blockstate def material(self, name: str, **properties: str) -> Material: """Build a Material from a block name and its properties. Args: name (str): Namespaced block name, or a full blockstate string. **properties: Blockstate properties. Returns: Material: Material ready for placement. """ if "[" in name: return parse_blockstate(name) return self.canvas.material(name, **dict(sorted(properties.items()))) def box(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill an inclusive box. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive on both ends. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, block, **properties) def shell(self, bounds: Tuple[int, int, int, int, int, int], block: str | Material, **properties: str) -> None: """Fill only the faces of a box, leaving the inside empty. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. block (str | Material): Block to place. **properties: Blockstate properties. """ x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): on_face = x in (x0, x1) or y in (y0, y1) or z in (z0, z1) if on_face: self.put(x, y, z, block, **properties) def texture(self, bounds: Tuple[int, int, int, int, int, int], palette: Iterable[str]) -> None: """Fill a box with a weighted mix of related blocks, so the surface is not flat. Args: bounds (Tuple[int, int, int, int, int, int]): x0, y0, z0, x1, y1, z1, inclusive. palette (Iterable[str]): Block names. Repeat a name to make it more common. """ choices = list(palette) x0, y0, z0, x1, y1, z1 = bounds for x in range(min(x0, x1), max(x0, x1) + 1): for y in range(min(y0, y1), max(y0, y1) + 1): for z in range(min(z0, z1), max(z0, z1) + 1): self.put(x, y, z, self.rng.choice(choices)) def get(self, x: int, y: int, z: int) -> Optional[str]: """Read back what was placed at a coordinate. Args: x (int): Width coordinate. y (int): Height coordinate. z (int): Depth coordinate. Returns: Optional[str]: Blockstate string, or None when the cell is empty. """ return self.placed.get((x, y, z)) def block(self, x: int, y: int, z: int, name: str, **props: str) -> None: """Place a vanilla block with compact names and validated Java properties.""" self.put(x, y, z, 'minecraft:' + name, **props) def fill(self, bounds: tuple, name: str, **props: str) -> None: """Fill an inclusive box with a vanilla material.""" self.box(bounds, 'minecraft:' + name, **props) def mix(self, bounds: tuple, palette: tuple) -> None: """Texture a structural surface using the seeded material palette.""" self.texture(bounds, ['minecraft:' + p for p in palette]) def beam(self, bounds: tuple, axis: str = 'y') -> None: """Place an exposed timber beam.""" self.fill(bounds, 'stripped_spruce_log', axis=axis) def stair(self, x: int, y: int, z: int, facing: str, material: str = 'spruce', half: str = 'bottom') -> None: """Place a fully specified stair, including furniture and roof trim.""" self.block(x, y, z, material + '_stairs', facing=facing, half=half, shape='straight', waterlogged='false') def slab(self, x: int, y: int, z: int, material: str = 'spruce', kind: str = 'bottom') -> None: """Place a slab.""" self.block(x, y, z, material + '_slab', type=kind, waterlogged='false') def trap(self, x: int, y: int, z: int, facing: str, material: str = 'spruce', opened: bool = True) -> None: """Place a shutter or furniture panel.""" self.block(x, y, z, material + '_trapdoor', facing=facing, half='bottom', open=str(opened).lower(), powered='false', waterlogged='false') def tile(self, pos: Position, name: str, **data: object) -> None: """Add deterministic Java block entity data at a placed block.""" x, y, z = pos self.tiles[pos] = Compound({'id': String('minecraft:' + name), 'x': Int(x), 'y': Int(y), 'z': Int(z), **data}) def container(self, x: int, y: int, z: int, name: str = 'barrel', facing: str = 'north', items: tuple = ()) -> None: """Place stocked storage using the 1.21 item stack format.""" props = {'facing': facing} if name == 'barrel': props['open'] = 'false' else: props.update(type='single', waterlogged='false') self.block(x, y, z, name, **props) stacks = [Compound({'Slot': Byte(i), 'id': String('minecraft:' + item), 'count': Int(count)}) for i, (item, count) in enumerate(items)] self.tile((x, y, z), name, Items=NBTList[Compound](stacks)) def door(self, x: int, y: int, z: int, facing: str, hinge: str = 'left', material: str = 'spruce') -> None: """Place matching supported upper and lower door halves.""" for dy, half in enumerate(('lower', 'upper')): self.block(x, y + dy, z, material + '_door', facing=facing, hinge=hinge, half=half, open='false', powered='false') self.doors.append((x, y, z)) def lantern(self, x: int, y: int, z: int, hanging: bool = False) -> None: """Place a warm lantern at its designed support.""" self.block(x, y, z, 'lantern', hanging=str(hanging).lower(), waterlogged='false') def candles(self, x: int, y: int, z: int, count: int = 3) -> None: """Place lit beeswax candles on a shelf or table.""" self.block(x, y, z, 'candle', candles=str(count), lit='true', waterlogged='false') def pot(self, x: int, y: int, z: int, plant: str = 'fern') -> None: """Place a plant in a terracotta flower pot.""" self.block(x, y, z, 'potted_' + plant) def frame(self, backing: Position, facing: str, item: str) -> None: """Attach an item frame entity to a solid face with a deterministic UUID.""" dx, dz = DIRECTIONS[facing] bx, by, bz = backing x, y, z = bx + dx, by, bz + dz # Hanging entities anchor to the adjacent air cell, offset toward their backing. pos = (x + .5 - dx * .46875, y + .5, z + .5 - dz * .46875) entity = Compound({'id': String('minecraft:item_frame'), 'Pos': NBTList[Double]([Double(v) for v in pos]), 'TileX': Int(x), 'TileY': Int(y), 'TileZ': Int(z), 'Facing': Byte({'north': 2, 'south': 3, 'west': 4, 'east': 5}[facing]), 'Rotation': NBTList[Float]([Float({'south': 0, 'west': 90, 'north': 180, 'east': 270}[facing]), Float(0)]), 'ItemRotation': Byte(0), 'ItemDropChance': Float(1), 'Fixed': Byte(1), 'Invisible': Byte(0), 'UUID': IntArray([20260923, bx * 1000 + by, bz, len(self.entities) + 1]), 'Item': Compound({'id': String('minecraft:' + item), 'count': Int(1)})}) self.entities.append(entity) def window(self, axis: str, plane: int, start: int, end: int, y0: int, y1: int) -> None: """Carve a glazed window with timber sill, lintel and exterior shutters.""" for a in range(start, end + 1): for y in range(y0, y1 + 1): x, z = (a, plane) if axis == 'z' else (plane, a) self.block(x, y, z, 'light_gray_stained_glass') self.windows.append((x, y, z)) for y in (y0 - 1, y1 + 1): x, z = (a, plane) if axis == 'z' else (plane, a) self.beam((x, y, z, x, y, z), 'x' if axis == 'z' else 'z') for a in (start - 1, end + 1): for y in range(y0, y1 + 1): x, z = (a, plane) if axis == 'z' else (plane, a) self.beam((x, y, z, x, y, z)) exterior = -1 if plane in (9, 10, 11) else 1 if axis == 'z': self.trap(x, y, z + exterior, 'north' if exterior < 0 else 'south') else: self.trap(x + exterior, y, z, 'west' if exterior < 0 else 'east') def banner(self, x: int, y: int, z: int, facing: str) -> None: """Hang white curtains with two green vertical stripes in Java 1.21 NBT.""" self.block(x, y, z, 'white_wall_banner', facing=facing) self.tile((x, y, z), 'banner', patterns=NBTList[Compound]([Compound({'pattern': String('minecraft:stripe_left'), 'color': String('green')}), Compound({'pattern': String('minecraft:stripe_right'), 'color': String('green')})])) @staticmethod def low_roof(z: int) -> int: """Height of the broad, shallow roof above the lower wing.""" return 14 + min(z - 8, 28 - z) * 7 // 10 @staticmethod def tall_roof(x: int) -> int: """Height of the narrow, steep tower roof, including flared eaves.""" return (37, 34, 31, 28, 25, 22, 19, 17, 16)[abs(x - 31)] def terrain(self) -> None: """Build a broken grass island, raised terrace, stairs and worn approach.""" for x in range(1, 44): for z in range(1, 34): # Trim the corners and roughen only the silhouette. if ((x - 22) / 23)**4 + ((z - 18) / 18)**4 > .97 + self.rng.random() * .14: continue self.block(x, 0, z, 'grass_block') self.mix((4, 1, 7, 40, 2, 30), STONE) self.mix((5, 3, 8, 39, 3, 29), PAVING) for x in range(5, 40): if 24 <= x <= 28: continue self.slab(x, 3, 7, 'stone_brick') for z in range(8, 31): for x in (4, 40): self.slab(x, 3, z, 'stone_brick') self.fill((24, 3, 7, 28, 3, 7), 'stone_bricks') for z, y in ((4, 1), (5, 2), (6, 3)): for x in range(24, 29): self.fill((x, 0, z, x, y - 1, z), 'cobblestone') self.stair(x, y, z, 'south', 'stone_brick') for z in range(0, 6): center = 25 - (5 - z) // 2 for x in range(center - 3, center + 4): if self.rng.random() < .85: self.block(x, 0, z, self.rng.choice(('dirt_path', 'coarse_dirt', 'rooted_dirt', 'gravel'))) for x in range(2, 43): for z in range(3, 33): if self.get(x, 0, z) != 'minecraft:grass_block' or self.get(x, 1, z): continue if self.rng.random() < .09 and not (21 <= x <= 30 and z < 8): self.block(x, 1, z, self.rng.choice(('short_grass', 'fern', 'dandelion', 'poppy', 'moss_carpet'))) for x, z in ((8, 7), (17, 7), (33, 7), (41, 15), (39, 31), (11, 31)): self.block(x, 1, z, 'mossy_cobblestone') def structure(self) -> None: """Construct two joined timber masses, floors and their closed roof union.""" # Floors: stone base, first-floor boards, tower bedroom, narrowed attic. for bounds in ((9, 3, 10, 25, 3, 26), (25, 3, 11, 37, 3, 28)): self.mix(bounds, PAVING) for bounds in ((9, 9, 10, 25, 9, 26), (25, 9, 11, 37, 9, 28), (25, 16, 11, 37, 16, 28), (27, 23, 11, 35, 23, 28)): self.mix(bounds, FLOOR) for x0, z0, x1, z1, top in ((9, 10, 25, 26, 14), (25, 11, 37, 28, 18)): for x in range(x0, x1 + 1): for z in range(z0, z1 + 1): if x not in (x0, x1) and z not in (z0, z1): continue for y in range(4, top + 1): self.block(x, y, z, self.rng.choice(STONE if y < 9 else PLASTER)) for x in range(x0, x1 + 1): for z in (z0, z1): for y in (8, 9, 14): self.beam((x, y, z, x, y, z), 'x') for z in range(z0, z1 + 1): for x in (x0, x1): for y in (8, 9, 14): self.beam((x, y, z, x, y, z), 'z') for x in (x0, x1): for z in (z0, z1): self.beam((x, 4, z, x, top, z)) # Low wing gable ends, hidden rear consistent with the facade. for x in (9, 25): for z in range(10, 27): for y in range(15, self.low_roof(z) + 1): self.block(x, y, z, self.rng.choice(PLASTER)) for x in range(25, 38): for z in (11, 28): for y in range(19, self.tall_roof(x) + 1): self.block(x, y, z, self.rng.choice(PLASTER)) # Half-timber pattern has coherent beams instead of random wood spots. for x in (9, 14, 20, 25): for z in (10, 26): self.beam((x, 9, z, x, 14, z)) for z in (10, 18, 26): self.beam((9, 9, z, 9, self.low_roof(z) - 1, z)) for z in (11, 28): for x in (25, 28, 34, 37): self.beam((x, 9, z, x, min(27, self.tall_roof(x) - 1), z)) self.beam((31, 15, z, 31, 36, z)) for y, xa, xb in ((16, 25, 37), (23, 27, 35), (29, 29, 33)): self.beam((xa, y, z, xb, y, z), 'x') for x in range(26, 37): y = self.tall_roof(x) - 2 self.beam((x, y, z, x, y, z), 'x') for z in (16, 22): self.beam((37, 9, z, 37, 18, z)) # Continuous roof shells. Risers fill all vertical gaps between courses. for x in range(7, 27): for z in range(8, 29): height = self.low_roof(z) outer = z - 1 if z <= 18 else z + 1 bottom = self.low_roof(outer) if 8 <= outer <= 28 else height for y in range(bottom, height + 1): if 25 <= x <= 37 and 11 <= z <= 28 and y < self.tall_roof(x): continue self.block(x, y, z, self.rng.choice(ROOF)) if not (25 <= x <= 37 and 11 <= z <= 28 and height < self.tall_roof(x)): if z != 18: self.stair(x, height + 1, z, 'south' if z < 18 else 'north', 'deepslate_tile') else: self.slab(x, height + 1, z, 'deepslate_brick') for x in range(23, 40): height = self.tall_roof(x) outer = x - 1 if x < 31 else x + 1 bottom = self.tall_roof(outer) if 23 <= outer <= 39 else height for z in range(9, 31): for y in range(bottom, height + 1): if 7 <= x <= 25 and 10 <= z <= 26 and y <= self.low_roof(z): continue self.block(x, y, z, self.rng.choice(ROOF)) if 7 <= x <= 25 and 10 <= z <= 26 and height + 1 <= self.low_roof(z): continue if x == 31: self.slab(x, height + 1, z, 'deepslate_brick') else: self.stair(x, height + 1, z, 'east' if x < 31 else 'west', 'deepslate_tile') # Amber ridge and carved finials, as in the reference. for z in range(10, 30): self.slab(31, 38, z, 'dark_oak') for z in (10, 29): self.block(31, 38, z, 'dark_oak_fence') self.block(31, 39, z, 'dark_oak_fence') # Exposed rafter tails and supporting brackets below the overhang. for x in (9, 14, 20, 25): for z, facing in ((9, 'south'), (27, 'north')): self.stair(x, 13, z, facing, 'spruce', 'top') for z in range(12, 29, 4): self.stair(38, 17, z, 'west', 'spruce', 'top') # Shared wall has wide, framed passages on the occupied floors. for y in (4, 10): self.fill((25, y, 14, 25, y + 3, 17), 'air') self.beam((25, y + 3, 14, 25, y + 3, 17), 'z') # Entry hall and storage partition with a three-block-high opening. self.fill((18, 4, 11, 18, 8, 25), 'spruce_planks') self.fill((18, 4, 14, 18, 6, 16), 'air') self.beam((18, 7, 14, 18, 7, 16), 'z') # Front door is a glazed oak pair, surrounded by a timber portal. for x, hinge in ((21, 'left'), (22, 'right')): self.door(x, 4, 10, 'north', hinge, 'oak') self.block(x, 6, 10, 'light_gray_stained_glass') for x in (20, 23): self.beam((x, 4, 10, x, 7, 10)) self.beam((20, 7, 10, 23, 7, 10), 'x') self.door(9, 4, 16, 'west') # Window apertures are placed after roof construction and kept as a contract. for args in (('z', 10, 11, 12, 5, 6), ('z', 10, 11, 12, 11, 13), ('z', 10, 16, 17, 11, 13), ('z', 11, 29, 32, 5, 6), ('z', 11, 29, 32, 11, 13), ('z', 11, 30, 32, 19, 21), ('z', 11, 30, 32, 26, 28), ('z', 26, 11, 12, 11, 13), ('z', 26, 16, 17, 11, 13), ('z', 28, 29, 32, 11, 13), ('z', 28, 30, 32, 19, 21), ('z', 28, 30, 32, 26, 28), ('x', 9, 21, 23, 11, 13), ('x', 37, 14, 15, 11, 13), ('x', 37, 23, 24, 11, 13), ('x', 37, 20, 21, 5, 6)): self.window(*args) # Front garden ledges, all supported by corbels. for xa, xb, z in ((11, 12, 9), (16, 17, 9), (29, 32, 10)): for x in range(xa, xb + 1): self.stair(x, 9, z, 'south', 'spruce', 'top') self.block(x, 10, z, 'grass_block') self.trap(x, 10, z - 1, 'north') self.block(x, 11, z, 'poppy' if x % 2 else 'fern') for x, y, z in ((19, 5, 9), (24, 5, 9), (28, 5, 10), (36, 11, 10), (10, 11, 27), (38, 11, 18)): self.block(x, y, z, 'spruce_planks') self.lantern(x, y + 1, z) # Attached ivy climbs the stone and then the timber corner. for x, top in ((25, 12), (26, 10), (27, 7)): for y in range(4, top + 1): if self.get(x, y, 11) and self.get(x, y, 11) != 'minecraft:air' and not self.get(x, y, 10): self.block(x, y, 10, 'vine', south='true', north='false', east='false', west='false', up='false') for z in range(23, 27): for y in range(4, 9 + (z % 2)): if self.get(9, y, z) and not self.get(8, y, z): self.block(8, y, z, 'vine', east='true', north='false', south='false', west='false', up='false') def stairs(self) -> None: """Connect all four floors with two-block-wide stair flights and clear landings.""" for x0, z0, bottom, rise, direction in ((21, 18, 3, 6, 'south'), (34, 18, 9, 7, 'south'), (29, 25, 16, 7, 'north')): dz = DIRECTIONS[direction][1] for step in range(rise): z = z0 + dz * step y = bottom + 1 + step for x in (x0, x0 + 1): self.fill((x, bottom + 1, z, x, y, z), 'spruce_planks') self.stair(x, y, z, direction) # Three blocks clear even where the flight pierces a floor. self.fill((x, y + 1, z, x, y + 3, z), 'air') self.flights.append((x0, y, z, direction)) landing = z0 + dz * rise self.fill((x0, bottom + rise, landing, x0 + 1, bottom + rise, landing), 'spruce_planks') self.fill((x0, bottom + rise + 1, landing, x0 + 1, bottom + rise + 3, landing), 'air') # Posts and short balustrades leave the landings and stair treads open. for x, y, z in ((20, 10, 22), (20, 10, 23), (23, 10, 22), (23, 10, 23), (33, 17, 22), (33, 17, 23), (36, 17, 23), (28, 24, 19), (31, 24, 19)): if self.get(x, y - 1, z) not in (None, 'minecraft:air'): self.block(x, y, z, 'spruce_fence') def forge(self) -> None: """Build the sheltered, usable blacksmith shop and its tall stone flue.""" self.mix((3, 1, 12, 8, 2, 22), STONE) self.mix((3, 3, 12, 8, 3, 22), PAVING) for x, z in ((3, 12), (3, 22), (8, 12), (8, 22)): self.fill((x, 1, z, x, 3, z), 'stone_bricks') self.beam((x, 4, z, x, 8, z)) for z in range(11, 24): for x in range(2, 9): y = 7 + (x - 2) // 3 self.block(x, y, z, self.rng.choice(ROOF)) self.stair(x, y + 1, z, 'east', 'deepslate_tile') self.mix((5, 4, 18, 8, 6, 21), STONE) self.fill((5, 4, 19, 6, 5, 20), 'air') self.block(6, 4, 19, 'campfire', facing='west', lit='true', signal_fire='false', waterlogged='false') self.block(6, 4, 20, 'blast_furnace', facing='west', lit='true') self.tile((6, 4, 20), 'blast_furnace', BurnTime=Short(1600), CookTime=Short(0), CookTimeTotal=Short(200), Items=NBTList[Compound]([Compound({'Slot': Byte(0), 'id': String('minecraft:raw_iron'), 'count': Int(48)}), Compound({'Slot': Byte(1), 'id': String('minecraft:coal'), 'count': Int(48)})])) for y in range(7, 26): self.mix((6, y, 19, 7, y, 20), CHIMNEY) for y in (8, 21, 24): self.fill((5, y, 18, 8, y, 21), 'stone_brick_slab', type='top', waterlogged='false') for x in (6, 7): for z in (19, 20): self.block(x, 26, z, 'cobblestone_wall', up='true', north='low', south='low', east='low', west='low', waterlogged='false') self.slab(x, 27, z, 'stone_brick') self.block(4, 4, 16, 'anvil', facing='north') self.block(7, 4, 14, 'smithing_table') self.block(5, 4, 13, 'grindstone', face='floor', facing='south') self.container(6, 4, 12, items=(('iron_ingot', 32), ('coal', 32))) self.container(7, 4, 12, items=(('iron_pickaxe', 1), ('iron_axe', 1))) self.container(3, 4, 21, 'chest', 'east', (('cobblestone', 64), ('charcoal', 32))) self.lantern(3, 7, 13, True) self.block(3, 8, 13, 'spruce_planks') self.frame((7, 4, 14), 'west', 'iron_sword') def ground_rooms(self) -> None: """Furnish the entrance, supply room and stone workshop around clear aisles.""" for z in (12, 18, 22, 24): for y in (4, 5): self.container(10, y, z, items=(('oak_log', 32), ('coal', 16))) for x in (12, 14, 16): self.container(x, 4, 25, 'chest', 'north', (('wheat', 32), ('bread', 16))) self.block(12, 4, 18, 'crafting_table') self.block(13, 4, 18, 'smithing_table') self.block(14, 4, 18, 'spruce_planks') self.candles(14, 5, 18) self.block(12, 4, 19, 'stonecutter', facing='south') self.block(16, 4, 12, 'spruce_planks') self.pot(16, 5, 12, 'blue_orchid') self.frame((18, 5, 20), 'west', 'iron_pickaxe') self.frame((18, 5, 22), 'west', 'leather') for x, z in ((13, 13), (15, 22), (21, 14), (29, 16), (33, 24)): self.block(x, 8, z, 'spruce_planks') self.lantern(x, 7, z, True) for z in range(11, 17): for x in (21, 22): self.block(x, 4, z, 'red_carpet') self.container(19, 4, 12, items=(('map', 1), ('torch', 16))) self.pot(19, 5, 12) self.container(24, 4, 20) self.candles(24, 5, 20, 2) # Tower ground: glazed entrance hall and book wall. for z in range(17, 26): for y in (4, 5, 6): self.block(36, y, z, 'bookshelf' if (z + y) % 3 else 'chiseled_bookshelf', **({} if (z + y) % 3 else {'facing': 'west', 'slot_0_occupied': 'true', 'slot_1_occupied': 'false', 'slot_2_occupied': 'true', 'slot_3_occupied': 'true', 'slot_4_occupied': 'false', 'slot_5_occupied': 'true'})) for x in range(28, 33): self.container(x, 4, 27) self.pot(28, 5, 27, 'spruce_sapling') self.candles(30, 5, 27) self.container(32, 5, 27, 'chest') self.frame((31, 7, 28), 'north', 'clock') for z in range(17, 23): self.block(29, 4, z, 'red_carpet') self.block(30, 4, z, 'red_carpet') self.fill((26, 4, 21, 27, 5, 22), 'bricks') self.pot(26, 6, 21, 'fern') for y in range(6, 9): self.block(26, y, 22, 'oak_leaves', persistent='true', distance='1', waterlogged='false') # Service ladder to a storage shelf, backed by the masonry wall. self.fill((34, 6, 26, 36, 6, 27), 'spruce_planks') for y in range(4, 7): self.block(35, y, 27, 'ladder', facing='north', waterlogged='false') self.container(34, 7, 27) def living_rooms(self) -> None: """Furnish a green sitting room, long dining table and working kitchen.""" # Inlaid living rug and west-wall settle. for x in range(11, 18): for z in range(14, 20): self.block(x, 10, z, 'green_carpet' if x in (11, 17) or z in (14, 19) else 'moss_carpet') for z in range(14, 18): self.stair(10, 10, z, 'west', 'dark_oak') for z in (13, 18): self.container(10, 10, z) self.pot(10, 11, 13, 'blue_orchid') self.lantern(10, 11, 18) for x in (13, 14): self.block(x, 10, 16, 'spruce_planks') self.candles(13, 11, 16) self.pot(14, 11, 16, 'red_tulip') for x in (13, 14): self.stair(x, 10, 18, 'south', 'dark_oak') # Cabinets and open book nook at the rear wall. for x in (10, 11, 12, 13, 14, 15): self.container(x, 10, 25) if x < 13: self.container(x, 12, 25) self.block(14, 11, 25, 'lectern', facing='north', has_book='true', powered='false') self.book((14, 11, 25)) self.candles(15, 11, 25, 2) self.block(15, 12, 26, 'bookshelf') self.frame((20, 12, 26), 'north', 'map') # Solid top dining table and four chairs in the broad middle aisle. for z in (17, 18, 19, 20): self.block(18, 10, z, 'dark_oak_planks') self.block(19, 10, z, 'dark_oak_planks') for z in (17, 20): self.candles(18, 11, z, 2) for z in (17, 19): self.stair(17, 10, z, 'west', 'spruce') self.stair(20, 10, z, 'east', 'spruce') # Kitchen in the tower, with chimney breast and fireproof hearth. for x in range(27, 33): self.container(x, 10, 27) self.block(26, 10, 27, 'smoker', facing='north', lit='true') self.block(27, 10, 27, 'furnace', facing='north', lit='true') self.fill((26, 11, 28, 27, 15, 28), 'stone_bricks') self.block(31, 11, 27, 'water_cauldron', level='3') self.pot(28, 11, 27) self.candles(32, 11, 27) for x in (26, 27, 33): self.container(x, 13, 27) self.block(26, 10, 21, 'crafting_table') self.container(26, 10, 22) self.block(26, 10, 23, 'spruce_planks') self.pot(26, 11, 23, 'brown_mushroom') for z in (13, 22): self.beam((9, 14, z, 25, 14, z), 'x') for z in (16, 24): self.beam((25, 14, z, 37, 14, z), 'x') for x, z in ((14, 13), (17, 22), (22, 13), (29, 16), (32, 24)): self.block(x, 14, z, 'spruce_planks') self.lantern(x, 13, z, True) for x in range(28, 32): for z in range(14, 19): self.block(x, 10, z, 'red_carpet' if x in (28, 31) else 'brown_carpet') for x in (29, 32): self.banner(x, 13, 12, 'south') self.frame((25, 12, 22), 'east', 'golden_carrot') def bedroom(self) -> None: """Recreate the raised green bed, striped curtains, wall cabinets and hearth.""" # A shallow platform leaves generous standing room around the double bed. self.fill((27, 17, 13, 30, 17, 16), 'dark_oak_planks') for x in (28, 29): self.stair(x, 17, 17, 'north', 'dark_oak') self.block(x, 18, 15, 'green_bed', part='foot', facing='north', occupied='false') self.block(x, 18, 14, 'green_bed', part='head', facing='north', occupied='false') for x in (27, 30): for z in (14, 15): self.trap(x, 18, z, 'west' if x == 27 else 'east', 'dark_oak') for x in (28, 29): self.trap(x, 18, 16, 'south', 'dark_oak') self.beam((27, 18, 13, 30, 18, 13), 'x') for x in (27, 30): self.container(x, 19, 13, facing='south') self.block(28, 20, 12, 'bookshelf') self.block(29, 20, 12, 'bookshelf') self.fill((27, 21, 12, 29, 21, 12), 'spruce_planks') self.pot(27, 22, 12, 'fern') self.lantern(30, 20, 13) # Window seat and curtains are on the inside face of the front wall. for x in (31, 32, 33): self.container(x, 17, 12, facing='south') self.block(x, 18, 12, 'white_carpet') for x in (29, 33): self.banner(x, 21, 12, 'south') self.container(34, 17, 13, facing='south') self.pot(34, 18, 13, 'blue_orchid') # Wardrobe, dressing table and back-wall shelving. for x in (26, 27): for y in (17, 18, 19): self.container(x, y, 26) self.fill((31, 17, 27, 33, 17, 27), 'spruce_planks') self.pot(31, 18, 27, 'red_tulip') self.candles(33, 18, 27) self.frame((32, 19, 28), 'north', 'clock') for x in range(31, 34): for z in range(14, 20): self.block(x, 17, z, 'green_carpet') # A solid masonry chimney breast gives the bedroom reference's stone edge. self.mix((36, 17, 14, 36, 20, 16), CHIMNEY) self.block(35, 17, 15, 'campfire', facing='west', lit='true', signal_fire='false', waterlogged='false') self.fill((35, 18, 14, 35, 19, 16), 'stone_bricks') self.block(35, 17, 14, 'stone_bricks') self.block(35, 17, 16, 'stone_bricks') for z in (17, 25): self.beam((27, 21, z, 35, 21, z), 'x') self.beam((26, 21, 23, 28, 21, 23), 'x') for x, z in ((32, 17), (32, 25), (28, 23)): self.block(x, 21, z, 'spruce_planks') self.lantern(x, 20, z, True) self.frame((27, 18, 26), 'south', 'iron_helmet') def book(self, pos: Position) -> None: """Store a readable open book on a lectern using modern item components.""" content = Compound({'title': String('Amberstone Ledger'), 'author': String('The Lodge Keeper'), 'generation': Int(0), 'resolved': Byte(1), 'pages': NBTList[String]([String('{"text":"Amberstone Lodge\\n\\nAutumn stores\\nIron, cedar and candle wax.\\n\\nKeep a lantern burning for the next traveller."}')])}) self.tile(pos, 'lectern', Page=Int(0), Book=Compound({'id': String('minecraft:written_book'), 'count': Int(1), 'components': Compound({'minecraft:written_book_content': content})})) def attic(self) -> None: """Fit an illuminated study under the tall rafters, with a book desk and storage.""" for z in (12, 13, 14, 15): self.block(28, 24, z, 'bookshelf') for z in (12, 13, 14, 15): self.container(34, 24, z, facing='west') for x in (29, 30, 31, 32): self.block(x, 24, 13, 'dark_oak_planks') self.block(31, 25, 13, 'lectern', facing='south', has_book='true', powered='false') self.book((31, 25, 13)) self.candles(29, 25, 13) self.pot(32, 25, 13, 'fern') self.stair(31, 24, 15, 'south', 'dark_oak') for x in (31, 32): for z in range(16, 23): self.block(x, 24, z, 'green_carpet') for x in (28, 33, 34): self.container(x, 24, 27, 'chest') self.container(33, 25, 27) self.pot(33, 26, 27, 'spruce_sapling') # Exposed tie beams carry chains and lanterns within three blocks of the floor. for z in (16, 25): self.beam((29, 28, z, 33, 28, z), 'x') self.block(31, 27, z, 'chain', axis='y', waterlogged='false') self.lantern(31, 26, z, True) self.frame((31, 30, 11), 'south', 'compass') for y in range(24, 27): self.block(32, y, 27, 'ladder', facing='north', waterlogged='false') self.beam((32, 26, 26, 34, 26, 26), 'x') self.container(32, 27, 26) def pine(self, cx: int, cz: int, height: int, radius: int) -> None: """Grow a hand-built pine with exposed stepped limbs and persistent leaf tiers.""" self.block(cx, 0, cz, 'podzol') self.fill((cx, 1, cz, cx, height, cz), 'spruce_log', axis='y') for dx, dz in DIRECTIONS.values(): self.block(cx + dx, 1, cz + dz, 'spruce_log', axis='x' if dx else 'z') tiers = list(range(5, height - 1, 3)) for i, y in enumerate(tiers): r = max(1, radius - i // 2) for dx, dz in DIRECTIONS.values(): for length in range(1, r + 1): xx, zz = cx + dx * length, cz + dz * length self.block(xx, y, zz, 'spruce_log', axis='x' if dx else 'z') self.block(xx, y + 1, zz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') for dx, dz in DIRECTIONS.values(): xx, zz = cx + dx * (r + 1), cz + dz * (r + 1) if self.inside(xx, y, zz) and self.get(xx, y, zz) in (None, 'minecraft:air'): self.block(xx, y, zz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') for dx in range(-r, r + 1): for dz in range(-r, r + 1): if (dx == 0 and dz == 0) or abs(dx) + abs(dz) > r + 1: continue if self.inside(cx + dx, y, cz + dz) and self.get(cx + dx, y, cz + dz) in (None, 'minecraft:air'): self.block(cx + dx, y, cz + dz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') if abs(dx) + abs(dz) <= r and (dx or dz): self.block(cx + dx, y + 1, cz + dz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') for y in range(height - 2, height + 2): self.block(cx, y, cz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') if y < height: for dx, dz in DIRECTIONS.values(): self.block(cx + dx, y, cz + dz, 'spruce_leaves', persistent='true', distance='1', waterlogged='false') def dormer(self) -> None: """Open a timber-framed clerestory in the lower roof, matching the reference.""" self.fill((18, 16, 11, 20, 19, 14), 'air') for x in (17, 21): self.mix((x, 16, 10, x, 19, 14), PLASTER) self.beam((x, 16, 10, x, 19, 10)) self.beam((17, 16, 10, 21, 16, 10), 'x') self.beam((17, 19, 10, 21, 19, 10), 'x') for x in range(18, 21): for y in (17, 18): self.block(x, y, 10, 'light_gray_stained_glass') self.windows.append((x, y, 10)) # Shallow hipped cap ties into the existing slope at the back. for x in range(16, 23): for z in range(9, 16): y = 20 if x in (16, 22) or z == 9 else 21 self.block(x, y, z, 'deepslate_tiles') if y == 20: facing = 'east' if x == 16 else 'west' if x == 22 else 'south' self.stair(x, y + 1, z, facing, 'deepslate_tile') else: self.slab(x, y + 1, z, 'deepslate_tile') self.fill((17, 19, 15, 21, 20, 15), 'deepslate_tiles') self.fill((17, 20, 10, 21, 20, 14), 'spruce_planks') def landscape_detail(self) -> None: """Weather the terrace edge and grow ivy beside the tower entrance.""" # Broken stone toes soften the straight retaining wall without obstructing steps. for x in (6, 7, 11, 15, 16, 20, 31, 35, 38): self.block(x, 0, 6, 'coarse_dirt') self.block(x, 1, 6, 'mossy_cobblestone' if x % 2 else 'cobblestone') if x % 3: self.slab(x, 2, 6, 'cobblestone') for x in (8, 13, 19, 32, 37): self.block(x, 2, 6, 'vine', south='true', north='false', east='false', west='false', up='false') for x, z in ((7, 9), (16, 8), (34, 8), (38, 26), (12, 28), (35, 29)): self.block(x, 3, z, 'mossy_cobblestone') self.block(x, 4, z, 'azalea_leaves', persistent='true', distance='1', waterlogged='false') if x % 2: self.block(x, 5, z, 'flowering_azalea_leaves', persistent='true', distance='1', waterlogged='false') for x, z, ys in ((25, 9, (4, 5, 7, 8, 10, 11, 12)), (26, 10, (4, 5, 6, 8, 9, 10)), (27, 10, (4, 5, 7))): for y in ys: if self.get(x, y, z + 1) not in (None, 'minecraft:air'): self.block(x, y, z, 'oak_leaves', persistent='true', distance='1', waterlogged='false') # A low bench and lantern make the rear terrace useful as well as finished. for x in (16, 17, 18): self.stair(x, 4, 28, 'south', 'spruce') self.container(15, 4, 28) self.lantern(15, 5, 28) def reflect_x(self) -> None: """Orient the finished lodge so the tower is right of the front entrance.""" maximum = self.size_x - 1 blocks = list(self.placed.items()) self.canvas = LitematicCanvas((self.size_y, self.size_z, self.size_x)) self.placed = {} for (x, y, z), state in blocks: name, _, raw = state.partition('[') props = dict(p.split('=') for p in raw.rstrip(']').split(',') if p) if props.get('facing') in ('east', 'west'): props['facing'] = 'west' if props['facing'] == 'east' else 'east' if 'hinge' in props: props['hinge'] = 'right' if props['hinge'] == 'left' else 'left' if 'east' in props and 'west' in props: props['east'], props['west'] = props['west'], props['east'] self.put(maximum - x, y, z, name, **props) tiles = {} for (x, y, z), tile in self.tiles.items(): tile['x'] = Int(maximum - x) tiles[(maximum - x, y, z)] = tile self.tiles = tiles for entity in self.entities: entity['TileX'] = Int(maximum - int(entity['TileX'])) entity['Pos'][0] = Double(self.size_x - float(entity['Pos'][0])) facing = int(entity['Facing']) if facing in (4, 5): entity['Facing'] = Byte(9 - facing) entity['Rotation'][0] = Float((-float(entity['Rotation'][0])) % 360) self.windows = [(maximum - x, y, z) for x, y, z in self.windows] self.doors = [(maximum - x, y, z) for x, y, z in self.doors] self.flights = [(maximum - x - 1, y, z, facing) for x, y, z, facing in self.flights] def build(self) -> 'Build': """Generate Amberstone Lodge, its furnished rooms and landscaped setting.""" self.tiles = {} self.entities = [] self.doors, self.windows, self.flights = [], [], [] self.terrain() self.structure() self.dormer() self.stairs() self.forge() self.ground_rooms() self.living_rooms() self.bedroom() self.attic() self.landscape_detail() self.pine(5, 28, 23, 4) self.pine(3, 7, 16, 2) # Furnishing replacements cannot retain another block type's entity data. self.tiles = {pos: tile for pos, tile in self.tiles.items() if str(tile['id']).split(':')[1] in self.get(*pos).split('[')[0]} for pos, kind in (((26, 10, 27), 'smoker'), ((27, 10, 27), 'furnace')): self.tile(pos, kind, BurnTime=Short(1600), CookTime=Short(0), CookTimeTotal=Short(200), Items=NBTList[Compound]([Compound({'Slot': Byte(0), 'id': String('minecraft:potato' if kind == 'smoker' else 'raw_iron'), 'count': Int(32)}), Compound({'Slot': Byte(1), 'id': String('minecraft:coal'), 'count': Int(32)})])) for pos, state in self.placed.items(): if state.startswith('minecraft:chiseled_bookshelf['): stacks = [Compound({'Slot': Byte(i), 'id': String('minecraft:book'), 'count': Int(1)}) for i in (0, 2, 3, 5)] self.tile(pos, 'chiseled_bookshelf', Items=NBTList[Compound](stacks), last_interacted_slot=Int(0)) self.reflect_x() return self def export(self, path: Path) -> Path: """Write the schematic so that two runs produce identical bytes. Args: path (Path): Destination .litematic path. Returns: Path: The path written. """ schematic = self.canvas.to_litematica( name=CONFIG["name"], author=CONFIG["author"], description=CONFIG["description"], minecraft_data_version=CONFIG["data_version"], ) # The metadata otherwise records the current wall clock, which changes the bytes on every run. schematic.metadata.time_created = 0 schematic.metadata.time_modified = 0 path.parent.mkdir(parents=True, exist_ok=True) root = schematic.write_to_nbt() region = root['Regions'][CONFIG['name']] region['TileEntities'] = NBTList[Compound]([self.tiles[p] for p in sorted(self.tiles)]) region['Entities'] = NBTList[Compound](self.entities) NBTFile(root).save(path) return path def verify(self, path: Path) -> Dict[str, object]: """Reload the written file and confirm it matches what was placed. Args: path (Path): Schematic to reload. Returns: Dict[str, object]: Size, block count and palette size of the reloaded file. Raises: AssertionError: When a reloaded cell differs from what was placed. """ loaded = load_schematic(path) size_y, size_z, size_x = loaded.size_yzx assert (size_x, size_y, size_z) == (self.size_x, self.size_y, self.size_z), "size changed on reload" ids = loaded.read_flat(0, loaded.volume).reshape(loaded.size_yzx) for (x, y, z), state in self.placed.items(): assert loaded.palette[int(ids[y, z, x])] == state, f"cell (x={x}, y={y}, z={z}) changed on reload" return { "size_xyz": [size_x, size_y, size_z], "non_air_blocks": len(self.canvas._blocks), "palette_states": len(loaded.palette), } def main() -> None: """Generate the build, export it, and verify the exported file.""" parser = argparse.ArgumentParser(description="Generate a Minecraft schematic.") parser.add_argument("--output", type=Path, default=Path(CONFIG["output"])) parser.add_argument("--seed", type=int, default=CONFIG["seed"]) args = parser.parse_args() build = Build(seed=args.seed).build() path = build.export(args.output) report = build.verify(path) print(f"wrote {path}: {report}") if __name__ == "__main__": main()

# Export cropped, opened inspection copies from the finished schematic for rendering. from pathlib import Path import sys sys.path.insert(0, '/work/generator/MCIO') from mcio.sketch import LitematicCanvas, parse_blockstate from mcio.schematic import load_schematic ROOT = Path(__file__).resolve().parent VIEWS = { 'ground_cutaway': ((7, 3, 10, 35, 8, 28), 'northeast'), 'living_cutaway': ((7, 9, 10, 35, 15, 28), 'northeast'), 'bedroom_cutaway': ((7, 16, 11, 19, 22, 28), 'southwest'), 'bedroom_detail_cutaway': ((8, 16, 11, 18, 22, 18), 'southwest'), 'forge_cutaway': ((35, 3, 11, 42, 8, 23), 'northeast'), 'attic_cutaway': ((9, 23, 11, 17, 27, 28), 'southwest'), } def main() -> None: """Create inspection cutaways without changing the delivered schematic.""" source = load_schematic(ROOT / 'output.litematic') ids = source.read_flat(0, source.volume).reshape(source.size_yzx) output = ROOT / 'previews' output.mkdir(exist_ok=True) for name, (bounds, side) in VIEWS.items(): x0, y0, z0, x1, y1, z1 = bounds canvas = LitematicCanvas((y1 - y0 + 1, z1 - z0 + 1, x1 - x0 + 1)) for x in range(x0, x1 + 1): for y in range(y0, y1 + 1): for z in range(z0, z1 + 1): if y > y0 and ((side == 'northeast' and (x == x1 or z == z0)) or (side == 'southwest' and (x == x0 or z == z1))): continue state = source.palette[int(ids[y, z, x])] # Remove cut-side roofing so the camera can inspect the furnishings. if name in ('attic_cutaway', 'bedroom_detail_cutaway', 'forge_cutaway') and 'deepslate' in state: continue if name == 'bedroom_detail_cutaway' and z >= 17 and y >= 20: continue if state != 'minecraft:air': canvas.block((y - y0, z - z0, x - x0), parse_blockstate(state)) schematic = canvas.to_litematica(name=name, author='Amberstone Lodge', description='Inspection cutaway of output.litematic', minecraft_data_version=3955) schematic.metadata.time_created = schematic.metadata.time_modified = 0 schematic.save(output / (name + '.litematic')) print('wrote', name) if __name__ == '__main__': main()

// Starting point for rendering a build. Copy into the workspace and edit VIEWS. // Lighting, camera framing and background are already tuned; run it as is to get a first look. import fs from 'node:fs'; import path from 'node:path'; import { createRequire } from 'node:module'; import { createRenderScene, renderLitematicWithMetadata } from '/work/generator/MCRender/src/headless/index.ts'; const RENDER_ROOT = '/work/generator/MCRender'; const requireRenderer = createRequire(path.join(RENDER_ROOT, 'package.json')); const { PNG } = requireRenderer('pngjs'); // vite-node passes script arguments after a bare "--", so drop it before reading them. const argv = process.argv.slice(2).filter(entry => entry !== '--'); const INPUT = argv[0] ?? 'output.litematic'; const OUT_DIR = argv[1] ?? 'previews'; const SIZE = Number(process.env.RENDER_SIZE ?? 1000); // Tuned defaults. Ambient near 0.72 keeps shaded faces readable, and a light direction with a // dominant +Y term plus a small +X/+Z tilt separates roof, wall and ground planes. const LIGHT_DIRECTION = [0.08, 0.28, 0.15]; const AMBIENT = 0.72; const BACKGROUND = [47, 52, 59, 255]; const VIEWS = [ { name: 'front', azimuth: 145, elevation: 18, radius: 3.3 }, { name: 'rear', azimuth: 325, elevation: 24, radius: 3.3 }, { name: 'side', azimuth: 240, elevation: 16, radius: 3.3 }, { name: 'top', azimuth: 145, elevation: 60, radius: 3.3 }, { name: 'ground', input: 'ground_cutaway', azimuth: 145, elevation: 52, radius: 3.6 }, { name: 'living', input: 'living_cutaway', azimuth: 145, elevation: 50, radius: 3.6 }, { name: 'bedroom_plan', input: 'bedroom_cutaway', azimuth: 325, elevation: 65, radius: 3.6 }, { name: 'bedroom', input: 'bedroom_detail_cutaway', azimuth: 325, elevation: 32, radius: 3.5 }, { name: 'forge', input: 'forge_cutaway', azimuth: 145, elevation: 34, radius: 3.6 }, { name: 'study', input: 'attic_cutaway', azimuth: 325, elevation: 45, radius: 3.6 }, ]; // Resolve every path while the working directory is still the caller's. const absoluteInput = path.resolve(INPUT); const absoluteOutDir = path.resolve(OUT_DIR); fs.mkdirSync(absoluteOutDir, { recursive: true }); // The renderer looks for its resource cache relative to the working directory, so move there first, // and only then create the scene. process.chdir(RENDER_ROOT); const scene = createRenderScene({ width: SIZE, height: SIZE }); for (const view of VIEWS) { const result = renderLitematicWithMetadata(view.input ? path.join(absoluteOutDir, `${view.input}.litematic`) : absoluteInput, { width: SIZE, height: SIZE, fov_deg: 30, radius: view.radius, nRandomAzimuths: 0, azimuthInit: 0, elevationInit: 0, azimuthsDeltas: [view.azimuth], elevationsDeltas: [view.elevation], ambientIntensities: [AMBIENT], lightDirections: [LIGHT_DIRECTION], mirror: [false], layout: [[0]], limit: 512, seed: 0, opaque: false, }, scene); // Flatten onto an opaque background so shaded faces keep their contrast. for (let i = 0; i < result.png.data.length; i += 4) { const alpha = result.png.data[i + 3] / 255; for (let channel = 0; channel < 3; channel++) { result.png.data[i + channel] = Math.round(result.png.data[i + channel] * alpha + BACKGROUND[channel] * (1 - alpha)); } result.png.data[i + 3] = 255; } const target = path.join(absoluteOutDir, `${view.name}.png`); fs.writeFileSync(target, PNG.sync.write(result.png)); fs.writeFileSync(path.join(absoluteOutDir, `${view.name}.camera.json`), JSON.stringify(result.camera, null, 2) + '\n'); console.log(`wrote ${target} (${SIZE}x${SIZE}, azimuth ${view.azimuth}, elevation ${view.elevation})`); }

# Validate the exported Java schematic, its navigation, envelope and furnishings. from __future__ import annotations from collections import deque from pathlib import Path import json import sys import shutil import subprocess import tempfile import pytest ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) import generate from mcio.nbt.nbt import File as NBTFile DIR = {'north': (0, -1), 'south': (0, 1), 'west': (-1, 0), 'east': (1, 0)} AIR = {'air', 'cave_air', 'void_air'} THIN = {'air', 'cave_air', 'void_air', 'ladder', 'vine', 'chain', 'lantern', 'candle', 'fern', 'short_grass', 'poppy', 'dandelion', 'red_tulip', 'white_wall_banner'} def design_pos(x, y, z): """Map architectural coordinates to the final reflected presentation.""" return 44 - x, y, z def parse(state): """Split a canonical state into its short block name and properties.""" name, _, props = state.partition('[') return name.removeprefix('minecraft:'), dict(v.split('=') for v in props.rstrip(']').split(',') if v) class World: """Expose reloaded schematic cells in XYZ order for independent tests.""" def __init__(self, path): """Load the actual delivery artifact and its original NBT.""" self.loaded = generate.load_schematic(path) self.ids = self.loaded.read_flat(0, self.loaded.volume).reshape(self.loaded.size_yzx) self.sy, self.sz, self.sx = self.loaded.size_yzx self.palette = [parse(s) for s in self.loaded.palette] self.root = NBTFile.load_regardless_of_gzipped(path) self.region = next(iter(self.root['Regions'].values())) self.tiles = {(int(t['x']), int(t['y']), int(t['z'])): t for t in self.region['TileEntities']} def cell(self, x, y, z): """Read a cell, treating the outside as air.""" if not (0 <= x < self.sx and 0 <= y < self.sy and 0 <= z < self.sz): return 'air', {} return self.palette[int(self.ids[y, z, x])] def full_top(self, x, y, z): """Require a complete top surface for floor-standing decorations.""" name, props = self.cell(x, y, z) if name.endswith('_slab'): return props['type'] in ('top', 'double') if name.endswith('_stairs'): return props['half'] == 'top' return self.solid(x, y, z) and not name.endswith(('_fence', '_wall', '_bed')) def cells(self): """Iterate nonempty cells.""" for y in range(self.sy): for z in range(self.sz): for x in range(self.sx): name, props = self.cell(x, y, z) if name not in AIR: yield (x, y, z), name, props def solid(self, x, y, z): """Identify load-bearing geometry for furnishing support.""" name, props = self.cell(x, y, z) return name not in THIN and not (name.endswith(('_carpet', '_wall_banner', '_door')) or name.startswith('potted_')) @pytest.fixture(scope='session') def world(): """Use the delivered export, not the generator's in-memory model.""" return World(ROOT / 'output.litematic') @pytest.fixture(scope='session') def plan(): """Recreate the design for aperture contracts and reproducibility checks.""" return generate.Build().build() def test_java_version_one_region_and_scale(world): """Verify the contract dimensions, version and substantial structure.""" assert int(world.root['MinecraftDataVersion']) == 3955 assert len(world.root['Regions']) == 1 assert (world.sx, world.sy, world.sz) == (45, 41, 35) assert sum(1 for _ in world.cells()) > 10000 assert int(world.root['Metadata']['TimeCreated']) == 0 assert int(world.root['Metadata']['TimeModified']) == 0 def test_palette_is_valid_java_1211(world): """Check every block name and supplied property against the bundled authority.""" authority = json.loads(Path('/work/generator/MCRender/resources/1.21.1-blocks.json').read_text()) for name, props in world.palette: assert name in authority, name allowed = authority[name][0] for key, value in props.items(): assert key in allowed and value in allowed[key], (name, key, value) def test_roundtrip_and_reproducible_bytes(plan): """Compare a fresh export with the contract file, including entities and NBT.""" with tempfile.TemporaryDirectory(dir=ROOT / 'test') as temp: target = Path(temp) / 'rebuild.litematic' plan.export(target) plan.verify(target) assert target.read_bytes() == (ROOT / 'output.litematic').read_bytes() shutil.copy2(ROOT / 'generate.py', Path(temp) / 'generate.py') subprocess.run([sys.executable, 'generate.py'], cwd=temp, check=True, capture_output=True) assert (Path(temp) / 'output.litematic').read_bytes() == target.read_bytes() def test_doors_complete_and_clear(world): """Validate every door half, matching properties, floor and clear approaches.""" count = 0 for (x, y, z), name, props in world.cells(): if not name.endswith('_door'): continue dy = 1 if props['half'] == 'lower' else -1 other, op = world.cell(x, y + dy, z) assert other == name and op['half'] != props['half'], (x, y, z) assert all(props[k] == op[k] for k in ('facing', 'hinge', 'open', 'powered')) if props['half'] == 'lower': count += 1 assert world.solid(x, y - 1, z) dx, dz = DIR[props['facing']] for sign in (-1, 1): for h in (0, 1): n, _ = world.cell(x + sign * dx, y + h, z + sign * dz) assert n in AIR or n.endswith('_carpet'), (x, y, z, n) assert count >= 3 def test_beds_complete_and_supported(world): """Check each head and foot pair on the raised platform.""" heads = 0 for (x, y, z), name, props in world.cells(): if not name.endswith('_bed'): continue dx, dz = DIR[props['facing']] sign = 1 if props['part'] == 'foot' else -1 other, op = world.cell(x + sign * dx, y, z + sign * dz) assert other == name and op['facing'] == props['facing'] and op['part'] != props['part'] assert world.solid(x, y - 1, z) assert world.cell(x, y + 1, z)[0] in AIR heads += props['part'] == 'head' assert heads == 2 def walkable(world, pos): """Conservatively require two clear blocks above a standing surface.""" x, y, z = pos for h in (0, 1): name, _ = world.cell(x, y + h, z) if name not in AIR and not name.endswith(('_door', '_carpet')) and name != 'ladder': return False below, bp = world.cell(x, y - 1, z) return world.solid(x, y - 1, z) and not below.endswith(('_fence', '_wall')) def navigation(world, start): """Flood standing positions; elevation changes require correctly oriented stairs.""" assert walkable(world, start), start seen, queue = {start}, deque([start]) while queue: x, y, z = queue.popleft() for facing, (dx, dz) in DIR.items(): for dy in (0, 1, -1): nxt = (x + dx, y + dy, z + dz) if not (0 <= nxt[0] < world.sx and 1 <= nxt[1] < world.sy - 1 and 0 <= nxt[2] < world.sz): continue if nxt in seen or not walkable(world, nxt): continue if dy: hi = nxt if dy > 0 else (x, y, z) name, props = world.cell(hi[0], hi[1] - 1, hi[2]) expected = facing if dy > 0 else {'north': 'south', 'south': 'north', 'east': 'west', 'west': 'east'}[facing] if not name.endswith('_stairs') or props['half'] != 'bottom' or props['facing'] != expected: continue # The lower position must also clear the higher head elevation. lo = (x, y, z) if dy > 0 else nxt n, _ = world.cell(lo[0], lo[1] + 2, lo[2]) if n not in AIR and not n.endswith('_door'): continue seen.add(nxt) queue.append(nxt) return seen def test_all_rooms_and_floors_reachable_with_headroom(world, plan): """Walk from the front door through each room and every stair landing.""" seen = navigation(world, design_pos(21, 4, 10)) rooms = {'entrance': (22, 4, 13), 'store': (15, 4, 15), 'workshop': (13, 4, 20), 'tower_hall': (30, 4, 19), 'living': (15, 10, 15), 'dining': (23, 10, 18), 'kitchen': (30, 10, 24), 'bedroom': (32, 17, 18), 'attic_study': (31, 24, 17), 'smithy': (4, 4, 18), 'terrace': (26, 4, 7), 'path': (25, 1, 2)} for room, pos in rooms.items(): pos = design_pos(*pos) assert pos in seen, f'{room} is unreachable at {pos}; reached elevations {sorted(set(p[1] for p in seen))}' for x, y, z, direction in plan.flights: for xx in (x, x + 1): assert (xx, y + 1, z) in seen, ('stair', xx, y, z) def test_envelope_separates_every_internal_air_cell_from_sky(world): """Flood exterior air through thin decorations and check the entire room volume.""" def permeable(p): name, _ = world.cell(*p) return name in THIN or name.endswith('_carpet') or name.startswith('potted_') queue, exterior = deque(), set() for x in range(world.sx): for y in range(world.sy): for z in range(world.sz): if x in (0, world.sx - 1) or y in (0, world.sy - 1) or z in (0, world.sz - 1): p = (x, y, z) if permeable(p): exterior.add(p) queue.append(p) while queue: x, y, z = queue.popleft() for dx, dy, dz in ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)): p = x + dx, y + dy, z + dz if p in exterior or not (0 <= p[0] < world.sx and 0 <= p[1] < world.sy and 0 <= p[2] < world.sz): continue if permeable(p): exterior.add(p) queue.append(p) leaks = [] for x in range(10, 37): for z in range(11, 28): low = x < 25 and z < 26 high = x > 25 and z > 11 top = generate.Build.low_roof(z) if low else generate.Build.tall_roof(x) if high else 4 for y in range(4, top): if design_pos(x, y, z) in exterior: leaks.append(design_pos(x, y, z)) for x in range(18, 21): for y in range(16, 20): for z in range(11, 15): if design_pos(x, y, z) in exterior: leaks.append(design_pos(x, y, z)) assert not leaks, f'{len(leaks)} interior cells open to exterior, examples: {leaks[:15]}' def test_windows_preserved_and_external_faces_clear(world, plan): """Check glazing survives furnishings and excludes roof or flue intrusion.""" for x, y, z in plan.windows: assert world.cell(x, y, z)[0] == 'light_gray_stained_glass', (x, y, z) if z in (10, 11, 26, 28): dx, dz = 0, -1 if z < 20 else 1 else: dx, dz = (1 if x == 35 else -1), 0 outside = world.cell(x + dx, y, z + dz)[0] assert outside in AIR | {'fern', 'poppy'}, (x, y, z, outside) def test_decorations_supported(world): """Validate all small blocks, furniture, plants and hanging decorations.""" errors = [] for (x, y, z), name, props in world.cells(): supported = True if name.endswith('_wall_banner') or name == 'ladder': dx, dz = DIR[props['facing']] supported = world.solid(x - dx, y, z - dz) elif name == 'vine': faces = [(dx, 0, dz) for facing, (dx, dz) in DIR.items() if props.get(facing) == 'true'] if props.get('up') == 'true': faces.append((0, 1, 0)) supported = any(world.solid(x + dx, y + dy, z + dz) for dx, dy, dz in faces) elif name == 'lantern': if props.get('hanging') == 'true': supported = world.solid(x, y + 1, z) or world.cell(x, y + 1, z)[0] == 'chain' else: supported = world.full_top(x, y - 1, z) elif name == 'chain': supported = world.solid(x, y + 1, z) or world.cell(x, y + 1, z)[0] == 'chain' elif name.startswith('potted_') or name in {'candle', 'anvil', 'grindstone', 'campfire', 'lectern', 'fern', 'short_grass', 'poppy', 'dandelion'} or name.endswith('_carpet'): supported = world.full_top(x, y - 1, z) elif name in {'barrel', 'chest', 'bookshelf', 'chiseled_bookshelf'}: # Wall cabinets may attach sideways or upward, floor cabinets downward. supported = any(world.solid(x + dx, y + dy, z + dz) for dx, dy, dz in ((0, -1, 0), (0, 1, 0), (1, 0, 0), (-1, 0, 0), (0, 0, 1), (0, 0, -1))) elif name.endswith('_trapdoor'): supported = any(world.solid(x + dx, y + dy, z + dz) for dx, dy, dz in ((0, -1, 0), (1, 0, 0), (-1, 0, 0), (0, 0, 1), (0, 0, -1))) if not supported: errors.append(((x, y, z), name)) assert not errors, errors def test_solid_geometry_has_no_floating_components(world): """Require all substantial geometry to connect to ground through adjacent blocks.""" cells = {(x, y, z) for (x, y, z), n, p in world.cells() if world.solid(x, y, z)} grounded = {p for p in cells if p[1] == 0} queue = deque(grounded) while queue: x, y, z = queue.popleft() for dx, dy, dz in ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)): p = (x + dx, y + dy, z + dz) if p in cells and p not in grounded: grounded.add(p) queue.append(p) floating = cells - grounded assert not floating, sorted(floating) def test_room_lighting_and_furnishings(world): """Require low lights and substantive furniture in all four room groups.""" rooms = [(10, 4, 11, 24, 8, 25), (26, 4, 12, 36, 8, 27), (10, 10, 11, 24, 14, 25), (26, 10, 12, 36, 15, 27), (26, 17, 12, 36, 22, 27), (28, 24, 12, 34, 28, 27)] for x0, y0, z0, x1, y1, z1 in rooms: x0, x1 = 44 - x1, 44 - x0 contents = [(p, n, props) for p, n, props in world.cells() if x0 <= p[0] <= x1 and y0 <= p[1] <= y1 and z0 <= p[2] <= z1] lights = [p for p, n, props in contents if n == 'lantern' or (n in {'candle', 'campfire', 'furnace', 'smoker'} and props.get('lit') == 'true')] assert lights and min(p[1] - y0 for p in lights) <= 3, (x0, y0, z0) furniture = [n for p, n, props in contents if n in {'barrel', 'chest', 'bookshelf', 'lectern', 'crafting_table', 'green_bed'}] assert len(furniture) >= 4, (x0, y0, z0, furniture) assert world.cell(*design_pos(4, 4, 16))[0] == 'anvil' assert world.cell(*design_pos(6, 4, 19))[1].get('lit') == 'true' for x, z, h in ((5, 28, 23), (3, 7, 16)): x = 44 - x assert world.cell(x, 3, z)[0] == 'spruce_log' assert world.cell(x, h, z)[0] == 'spruce_leaves' assert sum(1 for p, n, props in world.cells() if n == 'spruce_leaves' and abs(p[0] - x) <= 4 and abs(p[2] - z) <= 4) > 70 def test_nbt_curtains_books_inventory_and_frames(world): """Inspect details the renderer cannot display, including attachment of frames.""" counts = {'banner': 0, 'lectern': 0, 'storage': 0} for pos, tile in world.tiles.items(): kind = str(tile['id']).removeprefix('minecraft:') name, props = world.cell(*pos) if kind == 'banner': counts['banner'] += 1 assert name == 'white_wall_banner' patterns = [(str(p['pattern']), str(p['color'])) for p in tile['patterns']] assert patterns == [('minecraft:stripe_left', 'green'), ('minecraft:stripe_right', 'green')] elif kind == 'lectern': counts['lectern'] += 1 assert name == 'lectern' and props['has_book'] == 'true' assert str(tile['Book']['id']) == 'minecraft:written_book' assert tile['Book']['components']['minecraft:written_book_content']['pages'] else: assert kind == name, (pos, kind, name) counts['storage'] += bool(tile.get('Items')) assert counts['banner'] >= 4 and counts['lectern'] == 2 and counts['storage'] >= 10 entities = world.region['Entities'] assert len(entities) >= 8 for frame in entities: assert str(frame['id']) == 'minecraft:item_frame' facing = {2: 'north', 3: 'south', 4: 'west', 5: 'east'}[int(frame['Facing'])] dx, dz = DIR[facing] x, y, z = (int(frame[k]) for k in ('TileX', 'TileY', 'TileZ')) assert world.solid(x - dx, y, z - dz), (x, y, z) assert world.cell(x, y, z)[0] in AIR, (x, y, z) assert int(frame['Item']['count']) == 1 def test_two_roofs_form_a_continuous_join(world): """Require a face-connected dark roof between the hall and tower.""" roof = {p for p, name, props in world.cells() if 'deepslate' in name} start, target = design_pos(12, 20, 17), design_pos(31, 37, 18) assert start in roof and target in roof seen, queue = {start}, deque([start]) while queue: x, y, z = queue.popleft() for dx, dy, dz in ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)): p = x + dx, y + dy, z + dz if p in roof and p not in seen: seen.add(p) queue.append(p) assert target in seen def test_forge_is_lit_stocked_and_accessible(world): """Walk to the exposed furnace face and verify a usable lit iron-smelting setup.""" furnace = design_pos(6, 4, 20) name, props = world.cell(*furnace) assert name == 'blast_furnace' and props['lit'] == 'true' dx, dz = DIR[props['facing']] approach = furnace[0] + dx, furnace[1], furnace[2] + dz assert approach in navigation(world, design_pos(21, 4, 10)) assert world.cell(*approach)[0] == 'air' inventory = {int(item['Slot']): str(item['id']) for item in world.tiles[furnace]['Items']} assert inventory == {0: 'minecraft:raw_iron', 1: 'minecraft:coal'} assert int(world.tiles[furnace]['BurnTime']) > 0