amulet-core 2.0a5__cp312-cp312-macosx_10_13_universal2.whl

amulet/level/bedrock/_raw/_level.py

@@ -0,0 +1,463 @@
+from __future__ import annotations
+
+import copy
+from typing import Optional, Callable
+from collections.abc import Iterable
+from threading import RLock
+import os
+import struct
+import logging
+from dataclasses import dataclass
+import shutil
+import time
+
+from leveldb import LevelDB
+
+from amulet_nbt import (
+    IntTag,
+    LongTag,
+    StringTag,
+    ListTag,
+    CompoundTag,
+    ByteTag,
+    ShortTag,
+    ReadOffset,
+    read_nbt,
+    utf8_escape_encoding,
+)
+
+from amulet.data_types import DimensionId
+from amulet.selection import SelectionGroup, SelectionBox
+from amulet.errors import PlayerDoesNotExist, LevelWriteError
+from amulet.level.abc import (
+    RawLevel,
+    RawLevelPlayerComponent,
+    IdRegistry,
+    RawLevelBufferedComponent,
+)
+from amulet.version import VersionNumber
+from amulet.utils.signal import Signal, SignalInstanceCacheName
+from amulet.utils.weakref import DetachableWeakRef
+
+from ._level_dat import BedrockLevelDAT
+from ._actor_counter import ActorCounter
+from ._dimension import BedrockRawDimension
+from ._constant import OVERWORLD, THE_NETHER, THE_END, LOCAL_PLAYER, DefaultSelection
+from ._typing import InternalDimension, PlayerID, RawPlayer
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class BedrockCreateArgsV1:
+    """A class to house call arguments to create.
+
+    If the call arguments to create need to be modified in the future a new arguments class can be created.
+    The create method can inspect which class it was given and access arguments accordingly.
+    """
+
+    overwrite: bool
+    path: str
+    version: VersionNumber
+    level_name: str
+
+
+class BedrockRawLevelOpenData:
+    """Data that only exists when the level is open"""
+
+    back_reference: Callable[[], BedrockRawLevel | None]
+    detach_back_reference: Callable[[], None]
+    dimensions: dict[DimensionId | InternalDimension, BedrockRawDimension]
+    dimensions_lock: RLock
+    db: LevelDB
+    dimension_aliases: frozenset[DimensionId]
+    actor_counter: ActorCounter
+    block_id_override: IdRegistry
+    biome_id_override: IdRegistry
+
+    def __init__(
+        self, raw_level: BedrockRawLevel, db: LevelDB, actor_counter: ActorCounter
+    ):
+        self.back_reference, self.detach_back_reference = DetachableWeakRef.new(
+            raw_level
+        )
+        self.db = db
+        self.dimensions = {}
+        self.dimensions_lock = RLock()
+        self.dimension_aliases = frozenset()
+        self.actor_counter = actor_counter
+        self.block_id_override = IdRegistry()
+        self.biome_id_override = IdRegistry()
+
+
+class BedrockRawLevel(
+    RawLevel[BedrockRawDimension],
+    RawLevelPlayerComponent[PlayerID, RawPlayer],
+    RawLevelBufferedComponent,
+):
+    _path: str
+    _level_dat: BedrockLevelDAT
+    _raw_open_data: BedrockRawLevelOpenData | None
+
+    __slots__ = (
+        "_path",
+        "_level_dat",
+        "_raw_open_data",
+        SignalInstanceCacheName,
+    )
+
+    def __init__(self, _ikwiad: bool = False) -> None:
+        if not _ikwiad:
+            raise RuntimeError(
+                "BedrockRawLevel must be constructed using the create or load classmethod."
+            )
+
+    @classmethod
+    def load(cls, path: str) -> BedrockRawLevel:
+        self = cls(True)
+        self._path = path
+        self._raw_open_data = None
+        self.reload()
+        return self
+
+    @classmethod
+    def create(cls, args: BedrockCreateArgsV1) -> BedrockRawLevel:
+        overwrite = args.overwrite
+        path = args.path
+        version = args.version
+        level_name = args.level_name
+
+        if os.path.isdir(path):
+            if overwrite:
+                shutil.rmtree(path)
+            else:
+                raise LevelWriteError(f"A directory already exists at the path {path}")
+        os.makedirs(path, exist_ok=True)
+
+        root = CompoundTag()
+        root["StorageVersion"] = IntTag(8)
+        root["lastOpenedWithVersion"] = ListTag(
+            [IntTag(i) for i in version.padded_version(5)]
+        )
+        root["Generator"] = IntTag(1)
+        root["LastPlayed"] = LongTag(int(time.time()))
+        root["LevelName"] = StringTag(level_name)
+        BedrockLevelDAT(root, level_dat_version=9).save_to(
+            os.path.join(path, "level.dat")
+        )
+
+        with open(os.path.join(path, "levelname.txt"), "w", encoding="utf-8") as f:
+            f.write(level_name)
+
+        db = LevelDB(os.path.join(path, "db"), True)
+        db.close()
+
+        return cls.load(path)
+
+    def is_open(self) -> bool:
+        return self._raw_open_data is not None
+
+    @property
+    def _o(self) -> BedrockRawLevelOpenData:
+        o = self._raw_open_data
+        if o is None:
+            raise RuntimeError("The level is not open.")
+        return o
+
+    def reload(self) -> None:
+        """Reload the raw level."""
+        if self.is_open():
+            raise RuntimeError("Cannot reload a level when it is open.")
+        self._level_dat = BedrockLevelDAT.from_file(
+            os.path.join(self.path, "level.dat")
+        )
+
+    opened = Signal[()]()
+
+    def open(self) -> None:
+        """Open the raw level."""
+        if self.is_open():
+            return
+        db = LevelDB(os.path.join(self.path, "db"))
+        actor_counter = ActorCounter()
+        self._raw_open_data = BedrockRawLevelOpenData(self, db, actor_counter)
+        actor_counter.init(self)
+        self.opened.emit()
+
+        # TODO: implement error handling and level closing if the db errors
+        # except LevelDBEncrypted as e:
+        #     self._is_open = self._has_lock = False
+        #     raise LevelDBException(
+        #         "It looks like this world is from the marketplace.\nThese worlds are encrypted and cannot be edited."
+        #     ) from e
+        # except LevelDBException as e:
+        #     msg = str(e)
+        #     self._is_open = self._has_lock = False
+        #     # I don't know if there is a better way of handling this.
+        #     if msg.startswith("IO error:") and msg.endswith(": Permission denied"):
+        #         traceback.print_exc()
+        #         raise LevelDBException(
+        #             f"Failed to load the database. The world may be open somewhere else.\n{msg}"
+        #         ) from e
+        #     else:
+        #         raise e
+
+    closed = Signal[()]()
+
+    def close(self) -> None:
+        """Close the raw level."""
+        if not self.is_open():
+            return
+        open_data = self._o
+        self._raw_open_data = None
+        open_data.db.close()
+        open_data.detach_back_reference()
+        self.closed.emit()
+
+    def pre_save(self) -> None:
+        self._level_dat.save_to(os.path.join(self.path, "level.dat"))
+
+    def save(self) -> None:
+        pass
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @property
+    def level_db(self) -> LevelDB:
+        """
+        The leveldb database.
+        Changes made to this are made directly to the level.
+        """
+        return self._o.db
+
+    @property
+    def level_dat(self) -> BedrockLevelDAT:
+        """Get the level.dat file for the world"""
+        return copy.deepcopy(self._level_dat)
+
+    @level_dat.setter
+    def level_dat(self, level_dat: BedrockLevelDAT) -> None:
+        """Set the level.dat. :meth:`pre_save` need to be run to push this to disk."""
+        if not isinstance(level_dat, BedrockLevelDAT):
+            raise TypeError
+        if not self.is_open():
+            raise RuntimeError("Level is not open.")
+        self._level_dat = copy.deepcopy(level_dat)
+
+    @property
+    def platform(self) -> str:
+        return "bedrock"
+
+    @property
+    def version(self) -> VersionNumber:
+        """
+        The game version that the level was last opened in.
+        This is used to determine the data format to save in.
+        """
+        try:
+            last_opened_tag = self.level_dat.compound.get_list("lastOpenedWithVersion")
+            assert last_opened_tag is not None
+            return VersionNumber(*(t.py_int for t in last_opened_tag))
+        except Exception:
+            return VersionNumber(1, 2, 0)
+
+    @property
+    def modified_time(self) -> float:
+        try:
+            return self.level_dat.compound.get_long("LastPlayed", LongTag()).py_int
+        except Exception:
+            return 0
+
+    def _find_dimensions(self) -> None:
+        with self._o.dimensions_lock:
+            if self._o.dimensions:
+                return
+
+            dimenion_bounds = {}
+
+            # find dimension bounds
+            experiments = self.level_dat.compound.get_compound(
+                "experiments", CompoundTag()
+            )
+            if (
+                experiments.get_byte("caves_and_cliffs", ByteTag()).py_int
+                or experiments.get_byte("caves_and_cliffs_internal", ByteTag()).py_int
+                or self.version >= VersionNumber(1, 18)
+            ):
+                dimenion_bounds[OVERWORLD] = SelectionGroup(
+                    SelectionBox(
+                        (-30_000_000, -64, -30_000_000), (30_000_000, 320, 30_000_000)
+                    )
+                )
+            else:
+                dimenion_bounds[OVERWORLD] = DefaultSelection
+            dimenion_bounds[THE_NETHER] = SelectionGroup(
+                SelectionBox(
+                    (-30_000_000, 0, -30_000_000), (30_000_000, 128, 30_000_000)
+                )
+            )
+            dimenion_bounds[THE_END] = DefaultSelection
+
+            if b"LevelChunkMetaDataDictionary" in self.level_db:
+                data = self.level_db[b"LevelChunkMetaDataDictionary"]
+                count, data = struct.unpack("<I", data[:4])[0], data[4:]
+                for _ in range(count):
+                    key, data = data[:8], data[8:]
+                    offset = ReadOffset()
+                    value = read_nbt(
+                        data,
+                        little_endian=True,
+                        compressed=False,
+                        string_encoding=utf8_escape_encoding,
+                        read_offset=offset,
+                    ).compound
+                    data = data[offset.offset :]
+
+                    try:
+                        dimension_name_tag = value.get_string("DimensionName")
+                        assert dimension_name_tag is not None
+                        dimension_name = dimension_name_tag.py_str
+                        # The dimension names are stored differently TODO: split local and global names
+                        dimension_name = {
+                            "Overworld": OVERWORLD,
+                            "Nether": THE_NETHER,
+                            "TheEnd": THE_END,
+                        }.get(dimension_name, dimension_name)
+
+                    except KeyError:
+                        # Some entries seem to not have a dimension assigned to them. Is there a default? We will skip over these for now.
+                        # {'LastSavedBaseGameVersion': StringTag("1.19.81"), 'LastSavedDimensionHeightRange': CompoundTag({'max': ShortTag(320), 'min': ShortTag(-64)})}
+                        pass
+                    else:
+                        previous_bounds = dimenion_bounds.get(
+                            dimension_name, DefaultSelection
+                        )
+                        min_y = min(
+                            value.get_compound(
+                                "LastSavedDimensionHeightRange", CompoundTag()
+                            )
+                            .get_short("min", ShortTag())
+                            .py_int,
+                            value.get_compound(
+                                "OriginalDimensionHeightRange", CompoundTag()
+                            )
+                            .get_short("min", ShortTag())
+                            .py_int,
+                            previous_bounds.min_y,
+                        )
+                        max_y = max(
+                            value.get_compound(
+                                "LastSavedDimensionHeightRange", CompoundTag()
+                            )
+                            .get_short("max", ShortTag())
+                            .py_int,
+                            value.get_compound(
+                                "OriginalDimensionHeightRange", CompoundTag()
+                            )
+                            .get_short("max", ShortTag())
+                            .py_int,
+                            previous_bounds.max_y,
+                        )
+                        dimenion_bounds[dimension_name] = SelectionGroup(
+                            SelectionBox(
+                                (previous_bounds.min_x, min_y, previous_bounds.min_z),
+                                (previous_bounds.max_x, max_y, previous_bounds.max_z),
+                            )
+                        )
+
+            dimensions = set()
+
+            def register_dimension(
+                dimension: InternalDimension, alias: Optional[str] = None
+            ) -> None:
+                """
+                Register a new dimension.
+
+                :param dimension: The internal representation of the dimension
+                :param alias: The name of the level visible to the user. Defaults to f"DIM{dimension}"
+                :return:
+                """
+                if dimension not in self._o.dimensions:
+                    if alias is None:
+                        alias = f"DIM{dimension}"
+                    self._o.dimensions[dimension] = self._o.dimensions[alias] = (
+                        BedrockRawDimension(
+                            self._o.back_reference,
+                            dimension,
+                            alias,
+                            dimenion_bounds.get(alias, DefaultSelection),
+                        )
+                    )
+                    dimensions.add(alias)
+
+            register_dimension(None, OVERWORLD)
+            register_dimension(1, THE_NETHER)
+            register_dimension(2, THE_END)
+
+            for key in self._o.db.keys():
+                if len(key) == 13 and key[12] in [44, 118]:  # "," "v"
+                    register_dimension(struct.unpack("<i", key[8:12])[0])
+
+            self._o.dimension_aliases = frozenset(dimensions)
+
+    def dimension_ids(self) -> frozenset[DimensionId]:
+        self._find_dimensions()
+        return self._o.dimension_aliases
+
+    def get_dimension(
+        self, dimension_id: DimensionId | InternalDimension
+    ) -> BedrockRawDimension:
+        self._find_dimensions()
+        if dimension_id not in self._o.dimensions:
+            raise RuntimeError(f"Dimension {dimension_id} does not exist")
+        return self._o.dimensions[dimension_id]
+
+    def players(self) -> Iterable[PlayerID]:
+        yield from (
+            pid[7:].decode("utf-8")
+            for pid, _ in self.level_db.iterate(b"player_", b"player_\xFF")
+        )
+        if self.has_player(LOCAL_PLAYER):
+            yield LOCAL_PLAYER
+
+    def has_player(self, player_id: PlayerID) -> bool:
+        if player_id != LOCAL_PLAYER:
+            player_id = f"player_{player_id}"
+        return player_id.encode("utf-8") in self.level_db
+
+    def get_raw_player(self, player_id: PlayerID) -> RawPlayer:
+        if player_id == LOCAL_PLAYER:
+            key = player_id.encode("utf-8")
+        else:
+            key = f"player_{player_id}".encode("utf-8")
+        try:
+            data = self.level_db.get(key)
+        except KeyError:
+            raise PlayerDoesNotExist(f"Player {player_id} doesn't exist")
+        return read_nbt(
+            data,
+            compressed=False,
+            little_endian=True,
+            string_encoding=utf8_escape_encoding,
+        )
+
+    def set_raw_player(self, player_id: PlayerID, player: RawPlayer) -> None:
+        raise NotImplementedError
+
+    @property
+    def block_id_override(self) -> IdRegistry:
+        """
+        A two-way map from hard coded numerical block id <-> block string.
+        This only stores overridden values. If the value is not present here you should check the translator.
+        """
+        return self._o.block_id_override
+
+    @property
+    def biome_id_override(self) -> IdRegistry:
+        """
+        A two-way map from hard coded numerical biome id <-> biome string.
+        This only stores overridden values. If the value is not present here you should check the translator.
+        """
+        return self._o.biome_id_override

amulet/level/bedrock/_raw/_level_dat.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import struct
+from typing import BinaryIO, Any
+from copy import deepcopy
+
+from amulet_nbt import (
+    read_nbt,
+    NamedTag,
+    utf8_escape_encoding,
+    AnyNBT,
+    EncodingPreset,
+    StringEncoding,
+)
+from amulet.errors import LevelReadError
+
+
+class BedrockLevelDAT(NamedTag):
+    _level_dat_version: int
+
+    def __init__(
+        self,
+        tag: AnyNBT | None = None,
+        name: str | bytes = "",
+        level_dat_version: int | None = None,
+    ) -> None:
+        if not isinstance(level_dat_version, int):
+            raise TypeError(
+                "level_dat_version must be specified when constructing a BedrockLevelDAT instance."
+            )
+        super().__init__(tag, name)
+        self._level_dat_version = level_dat_version
+
+    def __reduce__(self) -> Any:
+        return BedrockLevelDAT, (self.tag, self.name, self.level_dat_version)
+
+    def __copy__(self) -> BedrockLevelDAT:
+        return BedrockLevelDAT(self.tag, self.name, self.level_dat_version)
+
+    def __deepcopy__(self, memo: dict) -> BedrockLevelDAT:
+        return BedrockLevelDAT(
+            deepcopy(self.tag, memo=memo), self.name, self.level_dat_version
+        )
+
+    @property
+    def level_dat_version(self) -> int:
+        return self._level_dat_version
+
+    @classmethod
+    def from_file(cls, path: str) -> BedrockLevelDAT:
+        with open(path, "rb") as f:
+            level_dat_version = struct.unpack("<i", f.read(4))[0]
+            if 4 <= level_dat_version <= 10:
+                data_length = struct.unpack("<i", f.read(4))[0]
+                root_tag = read_nbt(
+                    f.read(data_length),
+                    compressed=False,
+                    little_endian=True,
+                    string_encoding=utf8_escape_encoding,
+                )
+                name = root_tag.name
+                tag = root_tag.tag
+            else:
+                # TODO: handle other versions
+                raise LevelReadError(
+                    f"Unsupported level.dat version {level_dat_version}"
+                )
+        return cls(tag, name, level_dat_version)
+
+    def save_to(
+        self,
+        filename_or_buffer: str | BinaryIO | None = None,
+        *,
+        preset: EncodingPreset | None = None,
+        compressed: bool = False,
+        little_endian: bool = True,
+        string_encoding: StringEncoding = utf8_escape_encoding,
+    ) -> bytes:
+        payload = super().save_to(
+            compressed=compressed,
+            little_endian=little_endian,
+            string_encoding=string_encoding,
+        )
+        dat = struct.pack("<ii", self._level_dat_version, len(payload)) + payload
+        if isinstance(filename_or_buffer, str):
+            with open(filename_or_buffer, "wb") as f:
+                f.write(dat)
+        elif filename_or_buffer is not None:
+            filename_or_buffer.write(dat)
+        return dat

amulet/level/bedrock/_raw/_typing.py

@@ -0,0 +1,6 @@
+from typing import TypeAlias
+from amulet_nbt import NamedTag
+
+InternalDimension: TypeAlias = int | None
+PlayerID: TypeAlias = str
+RawPlayer: TypeAlias = NamedTag

amulet/level/bedrock/_raw/leveldb_chunk_versions.py

@@ -0,0 +1,83 @@
+from typing import Dict, Tuple, TypeAlias
+
+# from amulet.api.data_types import VersionNumberTuple
+VersionNumberTuple: TypeAlias = tuple[int, ...]
+
+# This is a dictionary of the first and last times each chunk version was written by a game version
+# It is used to convert the chunk version to the game version that could have saved that chunk.
+# It is also used to convert back to the chunk version when saving based on the game version.
+chunk_version_to_max_version: Dict[
+    int, Tuple[VersionNumberTuple, VersionNumberTuple]
+] = {
+    0: ((0, 9, 0, 0), (0, 9, 1, 9999)),
+    1: ((0, 9, 2, 0), (0, 9, 4, 9999)),
+    2: ((0, 9, 5, 0), (0, 16, 999, 9999)),
+    3: ((0, 17, 0, 0), (0, 17, 999, 9999)),
+    4: ((0, 18, 0, 0), (0, 18, 0, 0)),
+    5: ((0, 18, 0, 0), (1, 1, 999, 9999)),
+    6: ((1, 2, 0, 0), (1, 2, 0, 0)),
+    7: ((1, 2, 0, 0), (1, 2, 999, 9999)),
+    8: ((1, 3, 0, 0), (1, 7, 999, 9999)),
+    9: ((1, 8, 0, 0), (1, 8, 999, 9999)),
+    10: ((1, 9, 0, 0), (1, 9, 999, 9999)),
+    11: ((1, 10, 0, 0), (1, 10, 999, 9999)),
+    12: ((1, 11, 0, 0), (1, 11, 0, 9999)),
+    13: ((1, 11, 1, 0), (1, 11, 1, 9999)),
+    14: ((1, 11, 2, 0), (1, 11, 999, 999)),
+    15: ((1, 12, 0, 0), (1, 15, 999, 9999)),
+    16: ((1, 15, 999, 9999), (1, 15, 999, 9999)),
+    17: ((1, 15, 999, 9999), (1, 15, 999, 9999)),
+    18: ((1, 16, 0, 0), (1, 16, 0, 0)),
+    19: ((1, 16, 0, 0), (1, 16, 100, 55)),
+    20: ((1, 16, 100, 56), (1, 16, 100, 57)),
+    21: ((1, 16, 100, 58), (1, 16, 210, 0)),
+    22: ((1, 16, 210, 0), (1, 17, 999, 999)),  # caves and cliffs disabled
+    # used with experimental features
+    23: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    24: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    25: ((1, 17, 0, 0), (1, 17, 20, 999)),  # 1.17.0-20 caves and cliffs enabled
+    26: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    27: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    28: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    29: ((1, 17, 30, 0), (1, 17, 30, 999)),  # 1.17.30 caves and cliffs enabled
+    30: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    31: ((1, 17, 40, 0), (1, 17, 999, 999)),  # 1.17.40 caves and cliffs enabled
+    32: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    33: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    34: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    35: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    36: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    37: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    38: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    # continue without experimental gameplay
+    39: ((1, 18, 0, 0), (1, 18, 29, 999)),
+    40: ((1, 18, 30, 0), (999, 999, 999, 999)),
+}  # TODO: fill this list with the actual last game version number each chunk version was last used in
+
+
+def chunk_to_game_version(
+    max_game_version: VersionNumberTuple, chunk_version: int
+) -> VersionNumberTuple:
+    """Find the game version to use based on the chunk version."""
+    return min(chunk_version_to_max_version[chunk_version][1], max_game_version)
+
+
+def game_to_chunk_version(
+    max_game_version: VersionNumberTuple, cnc: bool = False
+) -> int:
+    """Get the chunk version that should be used for the given game version number."""
+    # The comparison can fail if they are no the same length
+    max_game_version = (max_game_version + (0,) * (4 - len(max_game_version)))[:4]
+    cnc = cnc or max_game_version >= (1, 18, 0)
+    for chunk_version, (first, last) in chunk_version_to_max_version.items():
+        if (
+            first <= max_game_version <= last  # if the version is in the range
+            and cnc
+            == (
+                chunk_version > 22
+            )  # and it is in the correct range (caves and cliffs or not)
+        ):
+            return chunk_version
+
+    # If all else fails return the minimum we support
+    return 6

amulet/level/bedrock/chunk/__init__.py

@@ -0,0 +1 @@
+from ._chunk import BedrockChunk0, BedrockChunk29, BedrockChunk, BedrockChunk