def __init__(self, path_or_buffer: str, platform: str, selection: SelectionBox):
self._path_or_buffer = path_or_buffer
if platform == "java":
self._materials = "Alpha"
elif platform == "bedrock":
self._materials = "Pocket"
else:
raise Exception(
f'"{platform}" is not a supported platform for a schematic file.'
)
self._selection = selection
self._data = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound(
{
"TileTicks": amulet_nbt.TAG_List(),
"Width": amulet_nbt.TAG_Short(selection.size_x),
"Height": amulet_nbt.TAG_Short(selection.size_y),
"Length": amulet_nbt.TAG_Short(selection.size_z),
"Materials": amulet_nbt.TAG_String(self._materials),
}
),
"Schematic",
)
self._entities = []
self._block_entities = []
self._blocks = numpy.zeros(
selection.shape, dtype=numpy.uint16
) # only 12 bits are actually used at most
self._block_data = numpy.zeros(
selection.shape, dtype=numpy.uint8
) # only 4 bits are used
def _save_subchunks_1(self, blocks: "Blocks",
palette: AnyNDArray) -> List[Optional[bytes]]:
for index, block in enumerate(palette):
block: Tuple[Tuple[None, Block], ...]
block_data = block[0][1].properties.get("block_data",
amulet_nbt.TAG_Int(0))
if isinstance(block_data, amulet_nbt.TAG_Int):
block_data = block_data.value
# if block_data >= 16:
# block_data = 0
else:
block_data = 0
palette[index] = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String(block[0][1].namespaced_name),
"val":
amulet_nbt.TAG_Short(block_data),
}))
chunk = []
for cy in range(16):
if cy in blocks:
palette_index, sub_chunk = fast_unique(
blocks.get_sub_chunk(cy))
sub_chunk_palette = list(palette[palette_index])
chunk.append(b"\x01" + self._save_palette_subchunk(
sub_chunk.ravel(), sub_chunk_palette))
else:
chunk.append(None)
return chunk
def _save_subchunks_8(self, blocks: "Blocks",
palette: AnyNDArray) -> List[Optional[bytes]]:
palette_depth = numpy.array([len(block) for block in palette])
if palette.size:
if palette[0][0][0] is None:
air = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String("minecraft:air"),
"val":
amulet_nbt.TAG_Short(0),
}))
else:
air = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String("minecraft:air"),
"states":
amulet_nbt.TAG_Compound({}),
"version":
amulet_nbt.TAG_Int(17_629_184), # 1, 13, 0, 0
}))
for index, block in enumerate(palette):
block: Tuple[Tuple[Optional[int], Block], ...]
full_block = []
for sub_block_version, sub_block in block:
properties = sub_block.properties
if sub_block_version is None:
block_data = properties.get("block_data",
amulet_nbt.TAG_Int(0))
if isinstance(block_data, amulet_nbt.TAG_Int):
block_data = block_data.value
# if block_data >= 16:
# block_data = 0
else:
block_data = 0
sub_block_ = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String(
sub_block.namespaced_name),
"val":
amulet_nbt.TAG_Short(block_data),
}))
else:
sub_block_ = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String(
sub_block.namespaced_name),
"states":
amulet_nbt.TAG_Compound({
key: val
for key, val in properties.items()
if isinstance(val, PropertyDataTypes)
}),
"version":
amulet_nbt.TAG_Int(sub_block_version),
}))
full_block.append(sub_block_)
palette[index] = tuple(full_block)
chunk = []
for cy in range(16):
if cy in blocks:
palette_index, sub_chunk = fast_unique(
blocks.get_sub_chunk(cy))
sub_chunk_palette = palette[palette_index]
sub_chunk_depth = palette_depth[palette_index].max()
if (sub_chunk_depth == 1 and len(sub_chunk_palette) == 1
and sub_chunk_palette[0][0]["name"].value
== "minecraft:air"):
chunk.append(None)
else:
# pad block_palette with air in the extra layers
sub_chunk_palette_full = numpy.empty(
(sub_chunk_palette.size, sub_chunk_depth),
dtype=object)
sub_chunk_palette_full.fill(air)
for index, block_tuple in enumerate(sub_chunk_palette):
for sub_index, block in enumerate(block_tuple):
sub_chunk_palette_full[index,
sub_index] = block
# should now be a 2D array with an amulet_nbt.NBTFile in each element
sub_chunk_bytes = [b"\x08", bytes([sub_chunk_depth])]
for sub_chunk_layer_index in range(sub_chunk_depth):
# TODO: sort out a way to do this quicker without brute forcing it.
(
sub_chunk_layer_palette,
sub_chunk_remap,
) = brute_sort_objects_no_hash(
sub_chunk_palette_full[:,
sub_chunk_layer_index])
sub_chunk_layer = sub_chunk_remap[
sub_chunk.ravel()]
# sub_chunk_layer, sub_chunk_layer_palette = sub_chunk, sub_chunk_palette_full[:, sub_chunk_layer_index]
sub_chunk_bytes.append(
self._save_palette_subchunk(
sub_chunk_layer.reshape(16, 16, 16),
list(sub_chunk_layer_palette.ravel()),
))
chunk.append(b"".join(sub_chunk_bytes))
else:
chunk.append(None)
else:
chunk = [None] * 16
return chunk
def _encode_subchunks(
self,
blocks: "Blocks",
palette: AnyNDArray,
bounds: Tuple[int, int],
max_world_version: VersionNumberTuple,
) -> Dict[int, Optional[bytes]]:
# Encode sub-chunk block format 8
palette_depth = numpy.array([len(block) for block in palette])
min_y = bounds[0] // 16
max_y = bounds[1] // 16
if palette.size:
if palette[0][0][0] is None:
air = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String("minecraft:air"),
"val":
amulet_nbt.TAG_Short(0),
}))
else:
air = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String("minecraft:air"),
"states":
amulet_nbt.TAG_Compound({}),
"version":
amulet_nbt.TAG_Int(17_629_184), # 1, 13, 0, 0
}))
for index, block in enumerate(palette):
block: Tuple[Tuple[Optional[int], Block], ...]
full_block = []
for sub_block_version, sub_block in block:
properties = sub_block.properties
if sub_block_version is None:
block_data = properties.get("block_data",
amulet_nbt.TAG_Int(0))
if isinstance(block_data, amulet_nbt.TAG_Int):
block_data = block_data.value
# if block_data >= 16:
# block_data = 0
else:
block_data = 0
sub_block_ = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String(
sub_block.namespaced_name),
"val":
amulet_nbt.TAG_Short(block_data),
}))
else:
sub_block_ = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"name":
amulet_nbt.TAG_String(
sub_block.namespaced_name),
"states":
amulet_nbt.TAG_Compound({
key: val
for key, val in properties.items()
if isinstance(val, PropertyDataTypes)
}),
"version":
amulet_nbt.TAG_Int(sub_block_version),
}))
full_block.append(sub_block_)
palette[index] = tuple(full_block)
chunk = {}
for cy in range(min_y, max_y):
if cy in blocks:
palette_index, sub_chunk = fast_unique(
blocks.get_sub_chunk(cy))
sub_chunk_palette = palette[palette_index]
sub_chunk_depth = palette_depth[palette_index].max()
if (sub_chunk_depth == 1 and len(sub_chunk_palette) == 1
and sub_chunk_palette[0][0]["name"].value
== "minecraft:air"):
chunk[cy] = None
else:
# pad block_palette with air in the extra layers
sub_chunk_palette_full = numpy.empty(
(sub_chunk_palette.size, sub_chunk_depth),
dtype=object)
sub_chunk_palette_full.fill(air)
for index, block_tuple in enumerate(sub_chunk_palette):
for sub_index, block in enumerate(block_tuple):
sub_chunk_palette_full[index,
sub_index] = block
# should now be a 2D array with an amulet_nbt.NBTFile in each element
if max_world_version[1] >= (
1,
17,
30,
): # Why do I need to check against game version and not chunk version
sub_chunk_bytes = [
b"\x09",
bytes([sub_chunk_depth]),
struct.pack("b", cy),
]
else:
sub_chunk_bytes = [
b"\x08", bytes([sub_chunk_depth])
]
for sub_chunk_layer_index in range(sub_chunk_depth):
# TODO: sort out a way to do this quicker without brute forcing it.
(
sub_chunk_layer_palette,
sub_chunk_remap,
) = brute_sort_objects_no_hash(
sub_chunk_palette_full[:,
sub_chunk_layer_index])
sub_chunk_layer = sub_chunk_remap[
sub_chunk.ravel()]
# sub_chunk_layer, sub_chunk_layer_palette = sub_chunk, sub_chunk_palette_full[:, sub_chunk_layer_index]
sub_chunk_bytes.append(
self._save_palette_subchunk(
sub_chunk_layer.reshape(16, 16, 16),
list(sub_chunk_layer_palette.ravel()),
))
chunk[cy] = b"".join(sub_chunk_bytes)
else:
chunk[cy] = None
else:
chunk = {i: None for i in range(min_y, max_y)}
return chunk
def save_to(self, f: BinaryIO):
if self._platform == "java":
materials = "Alpha"
elif self._platform == "bedrock":
materials = "Pocket"
else:
raise ObjectWriteError(
f'"{self._platform}" is not a supported platform for a schematic file.'
)
selection = self._selection.selection_boxes[0]
data = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"TileTicks":
amulet_nbt.TAG_List(),
"Width":
amulet_nbt.TAG_Short(selection.size_x),
"Height":
amulet_nbt.TAG_Short(selection.size_y),
"Length":
amulet_nbt.TAG_Short(selection.size_z),
"Materials":
amulet_nbt.TAG_String(materials),
}),
"Schematic",
)
entities = []
block_entities = []
blocks = numpy.zeros(
selection.shape,
dtype=numpy.uint16) # only 12 bits are actually used at most
block_data = numpy.zeros(selection.shape,
dtype=numpy.uint8) # only 4 bits are used
for (
selection_,
blocks_,
data_,
block_entities_,
entities_,
) in self._chunks.values():
if selection_.intersects(selection):
box = selection_.create_moved_box(selection.min, subtract=True)
blocks[box.slice] = blocks_
block_data[box.slice] = data_
for be in block_entities_:
coord_type = be["x"].__class__
be["x"] = coord_type(be["x"] - selection.min_x)
be["y"] = coord_type(be["y"] - selection.min_y)
be["z"] = coord_type(be["z"] - selection.min_z)
block_entities.append(be)
for e in entities_:
coord_type = e["Pos"][0].__class__
e["Pos"][0] = coord_type(e["Pos"][0] - selection.min_x)
e["Pos"][1] = coord_type(e["Pos"][1] - selection.min_y)
e["Pos"][2] = coord_type(e["Pos"][2] - selection.min_z)
entities.append(e)
data["Entities"] = amulet_nbt.TAG_List(entities)
data["TileEntities"] = amulet_nbt.TAG_List(block_entities)
data["Data"] = amulet_nbt.TAG_Byte_Array(
numpy.transpose(block_data, (1, 2, 0)) # XYZ => YZX
)
data["Blocks"] = amulet_nbt.TAG_Byte_Array(
numpy.transpose((blocks & 0xFF).astype(numpy.uint8), (1, 2, 0)))
if numpy.max(blocks) > 0xFF:
add_blocks = numpy.transpose(blocks & 0xF00, (1, 2, 0)) >> 8
data["AddBlocks"] = amulet_nbt.TAG_Byte_Array(
add_blocks[::2] + (add_blocks[1::2] << 4))
data.save_to(f)
def save_to(self, f: BinaryIO):
if self._schem_version == 1:
raise SpongeSchemReadError(
"Sponge Schematic Version 1 is not supported currently.")
elif self._schem_version == 2:
selection = self._bounds[self.dimensions[0]].selection_boxes[0]
if any(s > 2**16 - 1 for s in selection.shape):
raise SpongeSchemWriteError(
"The structure is too large to be exported to a Sponge Schematic file. It must be 2^16 - 1 at most in each dimension."
)
overflowed_shape = [
s if s < 2**15 else s - 2**16 for s in selection.shape
]
data = amulet_nbt.NBTFile(
amulet_nbt.TAG_Compound({
"Version":
amulet_nbt.TAG_Int(2),
"DataVersion":
amulet_nbt.TAG_Int(self._version),
"Width":
amulet_nbt.TAG_Short(overflowed_shape[0]),
"Height":
amulet_nbt.TAG_Short(overflowed_shape[1]),
"Length":
amulet_nbt.TAG_Short(overflowed_shape[2]),
"Offset":
amulet_nbt.TAG_Int_Array(selection.min),
}),
name="Schematic",
)
entities = []
block_entities = []
blocks = numpy.zeros(selection.shape, dtype=numpy.uint32)
palette: List[AnyNDArray] = []
if self._version < 1500:
raise Exception(
"Writing to Sponge Schematic files in pre-1.13 format is not currently supported."
)
else:
arr = numpy.empty(1, dtype=object)
arr[0] = Block("minecraft", "air")
palette.append((arr))
palette_len = 1
for (
selection_,
blocks_,
palette_,
block_entities_,
entities_,
) in self._chunks.values():
if selection_.intersects(selection):
box = selection_.create_moved_box(selection.min,
subtract=True)
blocks[box.slice] = blocks_ + palette_len
palette.append(palette_)
palette_len += len(palette_)
for be in block_entities_:
be = copy.deepcopy(be)
be["Pos"] = amulet_nbt.TAG_Int_Array(be["Pos"] -
selection.min)
block_entities.append(be)
for e in entities_:
e = copy.deepcopy(e)
x, y, z = e["Pos"]
e["Pos"] = amulet_nbt.TAG_List([
amulet_nbt.TAG_Int(x - selection.min_x),
amulet_nbt.TAG_Int(y - selection.min_y),
amulet_nbt.TAG_Int(z - selection.min_z),
])
entities.append(e)
compact_palette, lut = brute_sort_objects_no_hash(
numpy.concatenate(palette))
blocks = numpy.transpose(lut[blocks],
(1, 2, 0)).ravel() # XYZ => YZX
block_palette = []
for index, block in enumerate(compact_palette):
block: Block
block_palette.append(block.blockstate)
data["PaletteMax"] = amulet_nbt.TAG_Int(len(compact_palette))
data["Palette"] = amulet_nbt.TAG_Compound({
blockstate: amulet_nbt.TAG_Int(index)
for index, blockstate in enumerate(block_palette)
})
data["BlockData"] = amulet_nbt.TAG_Byte_Array(
list(encode_array(blocks)))
if block_entities:
data["BlockEntities"] = amulet_nbt.TAG_List(block_entities)
if entities:
data["Entities"] = amulet_nbt.TAG_List(entities)
data.save_to(f)
else:
raise SpongeSchemReadError(
f"Sponge Schematic Version {self._schem_version} is not supported currently."
)