def is_valid(path: PathOrBuffer) -> bool:
"""
Returns whether this format is able to load the given object.
:param path: The path of the object to load.
:return: True if the world can be loaded by this format, False otherwise.
"""
return os.path.isfile(path) and path.endswith(".construction")
def __init__(self, path: PathOrBuffer, mode: str = "r"):
super().__init__(path)
assert mode in ("r", "w"), 'Mode must be either "r" or "w".'
self._mode = mode
if isinstance(path, str):
assert path.endswith(".schematic"), 'Path must end with ".schematic"'
if mode == "r":
assert os.path.isfile(path), "File specified does not exist."
self._data: Optional[Union[SchematicWriter, SchematicReader]] = None
self._open = False
self._platform = "java"
self._version = (1, 12, 2)
self._selection: SelectionBox = SelectionBox((0, 0, 0), (0, 0, 0))
def __init__(self, path: PathOrBuffer, mode: str = "r"):
super().__init__(path)
assert mode in ("r", "w"), 'Mode must be either "r" or "w".'
self._mode = mode
if isinstance(path, str):
assert path.endswith(".construction"), 'Path must end with ".construction"'
if mode == "r":
assert os.path.isfile(path), "File specified does not exist."
self._data: Optional[Union[ConstructionWriter, ConstructionReader]] = None
self._open = False
self._platform = "java"
self._version = (1, 15, 2)
self._selection: SelectionGroup = SelectionGroup()
# used to look up which sections are in a given chunk when loading
self._chunk_to_section: Optional[Dict[Tuple[int, int], List[int]]] = None
# used to look up which selection boxes intersect a given chunk (boxes are clipped to the size of the chunk)
self._chunk_to_box: Optional[Dict[Tuple[int, int], List[SelectionBox]]] = None
def __init__(self, path_or_buffer: PathOrBuffer):
if isinstance(path_or_buffer, str):
assert path_or_buffer.endswith(
".schematic"), "File selected is not a .schematic file"
assert os.path.isfile(
path_or_buffer
), f"There is no schematic file at path {path_or_buffer}"
schematic = amulet_nbt.load(path_or_buffer)
assert not all(key in schematic for key in (
"Version", "Data Version",
"BlockData")), "This file is not a legacy schematic file."
else:
assert hasattr(path_or_buffer,
"read"), "Object does not have a read method"
schematic = amulet_nbt.load(buffer=path_or_buffer)
materials = schematic.get("Materials", amulet_nbt.TAG_String()).value
if materials == "Alpha":
self._platform = "java"
elif materials == "Pocket":
self._platform = "bedrock"
else:
raise Exception(
f'"{materials}" is not a supported platform for a schematic file.'
)
self._chunks: Dict[ChunkCoordinates,
Tuple[SelectionBox, BlockArrayType,
BlockDataArrayType, list, list], ] = {}
self._selection = SelectionBox(
(0, 0, 0),
(
schematic["Width"].value,
schematic["Height"].value,
schematic["Length"].value,
),
)
entities: amulet_nbt.TAG_List = schematic.get("Entities",
amulet_nbt.TAG_List())
block_entities: amulet_nbt.TAG_List = schematic.get(
"TileEntities", amulet_nbt.TAG_List())
blocks: numpy.ndarray = schematic["Blocks"].value.astype(
numpy.uint8).astype(numpy.uint16)
if "AddBlocks" in schematic:
add_blocks = schematic["AddBlocks"]
blocks = blocks + (numpy.concatenate([
[(add_blocks & 0xF0) >> 4], [add_blocks & 0xF]
]).T.ravel().astype(numpy.uint16) << 8)[:blocks.size]
max_point = self._selection.max
temp_shape = (max_point[1], max_point[2], max_point[0])
blocks = numpy.transpose(blocks.reshape(temp_shape),
(2, 0, 1)) # YZX => XYZ
data = numpy.transpose(schematic["Data"].value.reshape(temp_shape),
(2, 0, 1))
for cx, cz in self._selection.chunk_locations():
box = SelectionBox(
(cx * 16, 0, cz * 16),
(
min((cx + 1) * 16, self._selection.size_x),
self._selection.size_y,
min((cz + 1) * 16, self._selection.size_z),
),
)
self._chunks[(cx, cz)] = (box, blocks[box.slice], data[box.slice],
[], [])
for e in block_entities:
if all(key in e for key in ("x", "y", "z")):
x, y, z = e["x"].value, e["y"].value, e["z"].value
if (x, y, z) in self._selection:
cx = x >> 4
cz = z >> 4
self._chunks[(cx, cz)][3].append(e)
for e in entities:
if "Pos" in e:
pos: PointCoordinates = tuple(
map(lambda t: t.value, e["Pos"].value))
if pos in self._selection:
cx = int(pos[0]) >> 4
cz = int(pos[2]) >> 4
self._chunks[(cx, cz)][4].append(e)