amulet-core 2.0a3__cp312-cp312-win_amd64.whl

amulet/game/bedrock/_block.py

@@ -0,0 +1,42 @@
+from collections.abc import Mapping
+
+from amulet.game.abc import (
+    DatabaseBlockData,
+    BlockDataNumericalComponent,
+    GameVersion,
+    BlockSpec,
+)
+from amulet.game.translate import (
+    BlockToUniversalTranslator,
+    BlockFromUniversalTranslator,
+)
+
+
+class BedrockBlockData(DatabaseBlockData, BlockDataNumericalComponent):
+    def __init__(
+        self,
+        game_version: GameVersion,
+        specification: Mapping[str, Mapping[str, BlockSpec]],
+        to_universal: Mapping[tuple[str, str], BlockToUniversalTranslator],
+        from_universal: Mapping[tuple[str, str], BlockFromUniversalTranslator],
+        numerical_map: Mapping[int, tuple[str, str]],
+    ):
+        super().__init__(game_version, specification, to_universal, from_universal)
+        self._num_to_str = numerical_map
+        self._str_to_num = {v: k for k, v in self._num_to_str.items()}
+
+    def __getstate__(self) -> dict:
+        state = super().__getstate__()
+        state["_num_to_str"] = self._num_to_str
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        super().__setstate__(state)
+        self._num_to_str = state["_num_to_str"]
+        self._str_to_num = {v: k for k, v in self._num_to_str.items()}
+
+    def numerical_id_to_namespace_id(self, numerical_id: int) -> tuple[str, str]:
+        return self._num_to_str[numerical_id]
+
+    def namespace_id_to_numerical_id(self, namespace: str, base_name: str) -> int:
+        return self._str_to_num[(namespace, base_name)]

amulet/game/bedrock/_version.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+from typing import Self
+import json
+import os
+
+from amulet.biome import Biome
+from amulet.game import get_game_version
+from amulet.game.abc import GameVersion, load_json_block_spec, load_json_biome_data
+from amulet.game.translate import (
+    BlockToUniversalTranslator,
+    BlockFromUniversalTranslator,
+    load_json_block_translations,
+)
+from amulet.version import VersionNumber
+
+from ._block import BedrockBlockData
+from ._biome import BedrockBiomeData
+
+
+class BedrockGameVersion(GameVersion):
+    _block: BedrockBlockData
+    _biome: BedrockBiomeData
+
+    def __init__(
+        self,
+        min_data_version: VersionNumber,
+        max_data_version: VersionNumber,
+        min_semantic_version: VersionNumber,
+        max_semantic_version: VersionNumber,
+    ) -> None:
+        """Do not use this."""
+        self._min_data_version = min_data_version
+        self._max_data_version = max_data_version
+        self._min_semantic_version = min_semantic_version
+        self._max_semantic_version = max_semantic_version
+
+    def supports_version(self, platform: str, version: VersionNumber) -> bool:
+        return platform == "bedrock" and (
+            self._min_data_version <= version <= self._max_data_version
+            or self._min_semantic_version <= version <= self._max_semantic_version
+        )
+
+    @classmethod
+    def from_json(cls, version_path: str) -> Self:
+        with open(os.path.join(version_path, "__init__.json")) as f:
+            init = json.load(f)
+        assert init["platform"] == "bedrock"
+        min_data_version = VersionNumber(init.get("data_version", -1))
+        max_data_version = VersionNumber(init.get("data_version_max", -1))
+        min_semantic_version = VersionNumber(*init["version"])
+        max_semantic_version = VersionNumber(*init["version_max"])
+
+        block_format = {
+            "numerical": "numerical",
+            "pseudo-numerical": "numerical",
+            "nbt-blockstate": "blockstate",
+        }[init["block_format"]]
+        universal_version = get_game_version("universal", VersionNumber(1))
+
+        self = cls(
+            min_data_version,
+            max_data_version,
+            min_semantic_version,
+            max_semantic_version,
+        )
+
+        # Load the block specification and translations
+        block_spec = load_json_block_spec(version_path, block_format)
+        block_to_universal = load_json_block_translations(
+            version_path,
+            block_format,
+            "to_universal",
+            BlockToUniversalTranslator,
+            lambda namespace, base_name: block_spec[namespace][base_name],
+            universal_version,
+        )
+        block_from_universal = load_json_block_translations(
+            version_path,
+            block_format,
+            "from_universal",
+            BlockFromUniversalTranslator,
+            universal_version.block.get_specification,
+            self,
+        )
+
+        numerical_block_map = {}
+        file_path = os.path.join(version_path, "__numerical_block_map__.json")
+        if os.path.isfile(file_path):
+            with open(file_path) as f:
+                block_map: dict[str, int] = json.load(f)
+            for block_str, block_num in block_map.items():
+                namespace, base_name = block_str.split(":", 1)
+                numerical_block_map[block_num] = (namespace, base_name)
+
+        self._block = BedrockBlockData(
+            self,
+            block_spec,
+            block_to_universal,
+            block_from_universal,
+            numerical_block_map,
+        )
+
+        biomes, to_universal, from_universal = load_json_biome_data(version_path)
+        biome_namespace = dict[str, list[str]]()
+        for namespace, base_name in biomes:
+            biome_namespace.setdefault(namespace, []).append(base_name)
+
+        self._biome = BedrockBiomeData(
+            self,
+            biome_namespace,
+            {
+                biome: Biome(
+                    "universal",
+                    VersionNumber(1),
+                    universal_namespace,
+                    universal_base_name,
+                )
+                for (
+                    biome,
+                    (universal_namespace, universal_base_name),
+                ) in to_universal.items()
+            },
+            {
+                Biome(
+                    "universal",
+                    VersionNumber(1),
+                    universal_namespace,
+                    universal_base_name,
+                ): biome
+                for (
+                    (universal_namespace, universal_base_name),
+                    biome,
+                ) in from_universal.items()
+            },
+            {
+                biome_id: biome
+                for biome, biome_id in biomes.items()
+                if biome_id is not None
+            },
+        )
+
+        return self
+
+    def __repr__(self) -> str:
+        return f"BedrockGameVersion({self.min_version!r})"
+
+    @property
+    def platform(self) -> str:
+        return "bedrock"
+
+    @property
+    def min_version(self) -> VersionNumber:
+        return self._min_semantic_version
+
+    @property
+    def max_version(self) -> VersionNumber:
+        return self._max_semantic_version
+
+    @property
+    def block(self) -> BedrockBlockData:
+        return self._block
+
+    @property
+    def biome(self) -> BedrockBiomeData:
+        return self._biome

amulet/game/java/__init__.py

@@ -0,0 +1,2 @@
+from ._version import JavaGameVersion
+from ._block import Waterloggable

amulet/game/java/_biome.py

@@ -0,0 +1,35 @@
+from collections.abc import Mapping, Collection
+
+from amulet.biome import Biome
+from amulet.game.abc import DatabaseBiomeData, BiomeDataNumericalComponent
+from amulet.game.abc import GameVersion
+
+
+class JavaBiomeData(DatabaseBiomeData, BiomeDataNumericalComponent):
+    def __init__(
+        self,
+        game_version: GameVersion,
+        biomes: Mapping[str, Collection[str]],
+        to_universal: Mapping[tuple[str, str], Biome],
+        from_universal: Mapping[Biome, tuple[str, str]],
+        numerical_map: Mapping[int, tuple[str, str]],
+    ):
+        super().__init__(game_version, biomes, to_universal, from_universal)
+        self._num_to_str = numerical_map
+        self._str_to_num = {v: k for k, v in self._num_to_str.items()}
+
+    def __getstate__(self) -> dict:
+        state = super().__getstate__()
+        state["_num_to_str"] = self._num_to_str
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        super().__setstate__(state)
+        self._num_to_str = state["_num_to_str"]
+        self._str_to_num = {v: k for k, v in self._num_to_str.items()}
+
+    def numerical_id_to_namespace_id(self, numerical_id: int) -> tuple[str, str]:
+        return self._num_to_str[numerical_id]
+
+    def namespace_id_to_numerical_id(self, namespace: str, base_name: str) -> int:
+        return self._str_to_num[(namespace, base_name)]

amulet/game/java/_block.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from enum import IntEnum
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+from amulet.game.abc import (
+    DatabaseBlockData,
+    BlockDataNumericalComponent,
+    BlockSpec,
+)
+from amulet.game.translate import (
+    BlockToUniversalTranslator,
+    BlockFromUniversalTranslator,
+)
+
+if TYPE_CHECKING:
+    from ._version import JavaGameVersion
+
+
+class Waterloggable(IntEnum):
+    No = 0
+    Yes = 1
+    Always = 2
+
+
+class JavaBlockData(DatabaseBlockData, BlockDataNumericalComponent):
+    def __init__(
+        self,
+        game_version: JavaGameVersion,
+        specification: Mapping[str, Mapping[str, BlockSpec]],
+        to_universal: Mapping[tuple[str, str], BlockToUniversalTranslator],
+        from_universal: Mapping[tuple[str, str], BlockFromUniversalTranslator],
+        numerical_map: Mapping[int, tuple[str, str]],
+        waterloggable: Mapping[tuple[str, str], Waterloggable],
+    ):
+        super().__init__(game_version, specification, to_universal, from_universal)
+        self._num_to_str = numerical_map
+        self._str_to_num = {v: k for k, v in self._num_to_str.items()}
+        self._waterloggable = waterloggable
+
+    def __getstate__(self) -> dict:
+        state = super().__getstate__()
+        state["_num_to_str"] = self._num_to_str
+        state["_waterloggable"] = self._waterloggable
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        super().__setstate__(state)
+        self._num_to_str = state["_num_to_str"]
+        self._str_to_num = {v: k for k, v in self._num_to_str.items()}
+        self._waterloggable = state["_waterloggable"]
+
+    def numerical_id_to_namespace_id(self, numerical_id: int) -> tuple[str, str]:
+        return self._num_to_str[numerical_id]
+
+    def namespace_id_to_numerical_id(self, namespace: str, base_name: str) -> int:
+        return self._str_to_num[(namespace, base_name)]
+
+    def waterloggable(self, namespace: str, base_name: str) -> Waterloggable:
+        return self._waterloggable.get((namespace, base_name), Waterloggable.No)

amulet/game/java/_version.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+from typing import Self
+import os
+import json
+
+from amulet.biome import Biome
+from amulet.game import get_game_version
+from amulet.game.abc import GameVersion, load_json_block_spec, load_json_biome_data
+from amulet.game.translate import (
+    BlockToUniversalTranslator,
+    BlockFromUniversalTranslator,
+    load_json_block_translations,
+)
+from amulet.version import VersionNumber
+
+from ._block import JavaBlockData, Waterloggable
+from ._biome import JavaBiomeData
+
+
+class JavaGameVersion(GameVersion):
+    _block: JavaBlockData
+    _biome: JavaBiomeData
+
+    def __init__(
+        self,
+        min_data_version: VersionNumber,
+        max_data_version: VersionNumber,
+        min_semantic_version: VersionNumber,
+        max_semantic_version: VersionNumber,
+    ):
+        """Do not use this."""
+        self._min_data_version = min_data_version
+        self._max_data_version = max_data_version
+        self._min_semantic_version = min_semantic_version
+        self._max_semantic_version = max_semantic_version
+
+    @classmethod
+    def from_json(cls, version_path: str) -> Self:
+        with open(os.path.join(version_path, "__init__.json")) as f:
+            init = json.load(f)
+        assert init["platform"] == "java"
+        min_data_version = VersionNumber(init["data_version"])
+        max_data_version = VersionNumber(init["data_version_max"])
+        min_semantic_version = VersionNumber(*init["version"])
+        max_semantic_version = VersionNumber(*init["version_max"])
+
+        block_format = init["block_format"]
+        universal_version = get_game_version("universal", VersionNumber(1))
+
+        self = cls(
+            min_data_version,
+            max_data_version,
+            min_semantic_version,
+            max_semantic_version,
+        )
+
+        # Load the block specification and translations
+        block_spec = load_json_block_spec(version_path, block_format)
+        block_to_universal = load_json_block_translations(
+            version_path,
+            block_format,
+            "to_universal",
+            BlockToUniversalTranslator,
+            lambda namespace, base_name: block_spec[namespace][base_name],
+            universal_version,
+        )
+        block_from_universal = load_json_block_translations(
+            version_path,
+            block_format,
+            "from_universal",
+            BlockFromUniversalTranslator,
+            universal_version.block.get_specification,
+            self,
+        )
+
+        waterloggable = dict[tuple[str, str], Waterloggable]()
+        for name, state in (
+            ("__waterloggable__.json", Waterloggable.Yes),
+            ("__always_waterlogged__.json", Waterloggable.Always),
+        ):
+            file_path = os.path.join(version_path, name)
+            if not os.path.isfile(file_path):
+                continue
+            with open(file_path) as f:
+                blocks: list[str] = json.load(f)
+            for block in blocks:
+                namespace, base_name = block.split(":", 1)
+                waterloggable[(namespace, base_name)] = state
+
+        numerical_block_map = {}
+        file_path = os.path.join(version_path, "__numerical_block_map__.json")
+        if os.path.isfile(file_path):
+            with open(file_path) as f:
+                block_map: dict[str, int] = json.load(f)
+            for block_str, block_num in block_map.items():
+                namespace, base_name = block_str.split(":", 1)
+                numerical_block_map[block_num] = (namespace, base_name)
+
+        self._block = JavaBlockData(
+            self,
+            block_spec,
+            block_to_universal,
+            block_from_universal,
+            numerical_block_map,
+            waterloggable,
+        )
+
+        biomes, to_universal, from_universal = load_json_biome_data(version_path)
+        biome_namespace = dict[str, list[str]]()
+        for namespace, base_name in biomes:
+            biome_namespace.setdefault(namespace, []).append(base_name)
+
+        self._biome = JavaBiomeData(
+            self,
+            biome_namespace,
+            {
+                biome: Biome(
+                    "universal",
+                    VersionNumber(1),
+                    universal_namespace,
+                    universal_base_name,
+                )
+                for (
+                    biome,
+                    (universal_namespace, universal_base_name),
+                ) in to_universal.items()
+            },
+            {
+                Biome(
+                    "universal",
+                    VersionNumber(1),
+                    universal_namespace,
+                    universal_base_name,
+                ): biome
+                for (
+                    (universal_namespace, universal_base_name),
+                    biome,
+                ) in from_universal.items()
+            },
+            {
+                biome_id: biome
+                for biome, biome_id in biomes.items()
+                if biome_id is not None
+            },
+        )
+
+        return self
+
+    def __repr__(self) -> str:
+        return f"JavaGameVersion({self.min_version!r})"
+
+    def supports_version(self, platform: str, version: VersionNumber) -> bool:
+        return platform == "java" and (
+            self._min_data_version <= version <= self._max_data_version
+            or self._min_semantic_version <= version <= self._max_semantic_version
+        )
+
+    @property
+    def platform(self) -> str:
+        return "java"
+
+    @property
+    def min_version(self) -> VersionNumber:
+        return self._min_data_version
+
+    @property
+    def max_version(self) -> VersionNumber:
+        return self._max_data_version
+
+    @property
+    def block(self) -> JavaBlockData:
+        return self._block
+
+    @property
+    def biome(self) -> JavaBiomeData:
+        return self._biome

amulet/game/translate/__init__.py

@@ -0,0 +1,12 @@
+"""
+A package to support translating block and entity data between versions.
+Everything that is not imported into this module is an implementation detail.
+"""
+
+from ._translator import (
+    BlockToUniversalTranslator,
+    BlockFromUniversalTranslator,
+    EntityToUniversalTranslator,
+    EntityFromUniversalTranslator,
+    load_json_block_translations,
+)

amulet/game/translate/_functions/__init__.py

@@ -0,0 +1,15 @@
+from .abc import AbstractBaseTranslationFunction
+from ._state import SrcData, SrcDataExtra, StateData, DstData
+from .carry_nbt import CarryNBT
+from .carry_properties import CarryProperties
+from .code import Code
+from .map_block_name import MapBlockName
+from .map_nbt import MapNBT
+from .map_properties import MapProperties
+from .multiblock import MultiBlock
+from .new_block import NewBlock
+from .new_entity import NewEntity
+from .new_nbt import NewNBT
+from .new_properties import NewProperties
+from .sequence import TranslationFunctionSequence
+from .walk_input_nbt import WalkInputNBT