amulet-core 2.0a6__cp311-cp311-win_amd64.whl → 2.0a7__cp311-cp311-win_amd64.whl

amulet/resource_pack/bedrock/blockshapes/slab_double.py

@@ -0,0 +1,15 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+
+
+class SlabDouble(Cube):
+    @property
+    def blockshape(self) -> str:
+        return "slab_double"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        """The texture index to use within the list for the given Block"""
+        return aux_value % 8
+
+
+BlockShape = SlabDouble()

amulet/resource_pack/bedrock/blockshapes/tree.py

@@ -0,0 +1,41 @@
+from amulet.block import Block
+from amulet.mesh.block import BlockMesh
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+import amulet_nbt
+
+
+class Tree(Cube):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("pillar_axis"), amulet_nbt.TAG_String)
+
+    @property
+    def blockshape(self) -> str:
+        return "tree"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return aux_value % 4
+
+    def get_block_model(
+        self,
+        block: Block,
+        down: str,
+        up: str,
+        north: str,
+        east: str,
+        south: str,
+        west: str,
+        transparency: tuple[bool, bool, bool, bool, bool, bool],
+    ) -> BlockMesh:
+        axis: str = block.properties["pillar_axis"].py_data
+
+        model = super().get_block_model(
+            block, down, up, north, east, south, west, transparency
+        )
+        if axis == "x":
+            return model.rotate(1, 1)
+        elif axis == "z":
+            return model.rotate(1, 2)
+        return model
+
+
+BlockShape = Tree()

amulet/resource_pack/bedrock/blockshapes/turtle_egg.py

@@ -0,0 +1,15 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+
+
+class TurtleEgg(Cube):
+    @property
+    def blockshape(self) -> str:
+        return "turtle_egg"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        """The texture index to use within the list for the given Block"""
+        return (aux_value // 4) % 3
+
+
+BlockShape = TurtleEgg()

amulet/resource_pack/bedrock/blockshapes/vine.py

@@ -0,0 +1,52 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.flat_wall import (
+    FlatWall,
+)
+from amulet.mesh.block import BlockMesh
+import amulet_nbt
+
+
+class Vine(FlatWall):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(
+            block.properties.get("vine_direction_bits"), amulet_nbt.TAG_Int
+        )
+
+    @property
+    def blockshape(self) -> str:
+        return "vine"
+
+    @property
+    def tint(self) -> tuple[float, float, float]:
+        return 0, 1, 0
+
+    def get_block_model(
+        self,
+        block: Block,
+        down: str,
+        up: str,
+        north: str,
+        east: str,
+        south: str,
+        west: str,
+        transparency: tuple[bool, bool, bool, bool, bool, bool],
+        modify_uv: bool = True,
+    ) -> BlockMesh:
+        models = []
+        data: int = block.properties["vine_direction_bits"].py_data
+        if data:
+            model = super().get_block_model(
+                block, down, up, north, east, south, west, transparency
+            )
+            if data & 1:
+                models.append(model.rotate(0, 2))
+            if data & 2:
+                models.append(model.rotate(0, 3))
+            if data & 4:
+                models.append(model.rotate(0, 0))
+            if data & 8:
+                models.append(model.rotate(0, 1))
+        return BlockMesh.merge(models)
+
+
+BlockShape = Vine()

amulet/resource_pack/bedrock/blockshapes/wall.py

@@ -0,0 +1,22 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.partial_block import (
+    PartialBlock,
+)
+
+
+class Wall(PartialBlock):
+    @property
+    def blockshape(self) -> str:
+        return "wall"
+
+    def bounds(
+        self, block: Block
+    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
+        return (4 / 16, 12 / 16), (0, 1), (4 / 16, 12 / 16)
+
+    @property
+    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
+        return False, False, True, True, True, True
+
+
+BlockShape = Wall()

amulet/resource_pack/bedrock/blockshapes/water.py

@@ -0,0 +1,38 @@
+from amulet.block import Block
+from amulet.mesh.block.block_mesh import BlockMesh, Transparency
+from amulet.mesh.block.cube import get_unit_cube
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+
+
+class Water(Cube):
+    @property
+    def blockshape(self) -> str:
+        return "water"
+
+    def get_block_model(
+        self,
+        block: Block,
+        down: str,
+        up: str,
+        north: str,
+        east: str,
+        south: str,
+        west: str,
+        transparency: tuple[bool, bool, bool, bool, bool, bool],
+    ) -> BlockMesh:
+        return get_unit_cube(
+            down,
+            down,
+            down,
+            down,
+            down,
+            down,
+            (
+                Transparency.FullTranslucent
+                if transparency[0]
+                else Transparency.FullOpaque
+            ),
+        )
+
+
+BlockShape = Water()

amulet/resource_pack/bedrock/download_resources.py

@@ -0,0 +1,147 @@
+import os
+
+# import shutil
+# import zipfile
+# import json
+# from urllib.request import urlopen
+# import io
+from typing import Generator, Optional, TypeVar, Any
+import logging
+
+from amulet.resource_pack import BedrockResourcePack
+
+T = TypeVar("T")
+
+log = logging.getLogger(__name__)
+
+
+def generator_unpacker(gen: Generator[Any, Any, T]) -> T:
+    try:
+        while True:
+            next(gen)
+    except StopIteration as e:
+        return e.value  # type: ignore
+
+
+def get_latest() -> BedrockResourcePack:
+    return generator_unpacker(get_latest_iter())
+
+
+def get_latest_iter() -> Generator[float, None, BedrockResourcePack]:
+    vanilla_rp_path = os.path.join(
+        os.environ["CACHE_DIR"], "resource_packs", "bedrock", "vanilla"
+    )
+    yield 0
+    # new_version = launcher_manifest["latest"]["release"]
+    # if new_version is None:
+    #     if os.path.isdir(vanilla_rp_path):
+    #         log.error(
+    #             "Could not download the launcher manifest. The resource pack seems to be present so using that."
+    #         )
+    #     else:
+    #         log.error(
+    #             "Could not download the launcher manifest. The resource pack is not present, blocks may not be rendered correctly."
+    #         )
+    # else:
+    #     if os.path.isdir(vanilla_rp_path):
+    #         if os.path.isfile(os.path.join(vanilla_rp_path, "version")):
+    #             with open(os.path.join(vanilla_rp_path, "version")) as f:
+    #                 old_version = f.read()
+    #             if old_version != new_version:
+    #                 yield from _remove_and_download_iter(vanilla_rp_path, new_version)
+    #         else:
+    #             yield from _remove_and_download_iter(vanilla_rp_path, new_version)
+    #     else:
+    #         yield from _remove_and_download_iter(vanilla_rp_path, new_version)
+    return BedrockResourcePack(vanilla_rp_path)
+
+
+_bedrock_vanilla_fix: Optional[BedrockResourcePack] = None
+_bedrock_vanilla_latest: Optional[BedrockResourcePack] = None
+
+
+def get_bedrock_vanilla_fix() -> BedrockResourcePack:
+    global _bedrock_vanilla_fix
+    if _bedrock_vanilla_fix is None:
+        _bedrock_vanilla_fix = BedrockResourcePack(
+            os.path.join(os.path.dirname(__file__), "bedrock_vanilla_fix")
+        )
+    return _bedrock_vanilla_fix
+
+
+def get_bedrock_vanilla_latest() -> BedrockResourcePack:
+    global _bedrock_vanilla_latest
+    if _bedrock_vanilla_latest is None:
+        _bedrock_vanilla_latest = get_latest()
+    return _bedrock_vanilla_latest
+
+
+def get_bedrock_vanilla_latest_iter() -> Generator[float, None, BedrockResourcePack]:
+    global _bedrock_vanilla_latest
+    if _bedrock_vanilla_latest is None:
+        _bedrock_vanilla_latest = yield from get_latest_iter()
+    return _bedrock_vanilla_latest
+
+
+# def _remove_and_download(path, version):
+#     for _ in _remove_and_download_iter(path, version):
+#         pass
+
+
+# def _remove_and_download_iter(path, version) -> Generator[float, None, None]:
+#     if os.path.isdir(path):
+#         shutil.rmtree(path, ignore_errors=True)
+#     exists = yield from download_resources_iter(path, version)
+#     if exists:
+#         with open(os.path.join(path, "version"), "w") as f:
+#             f.write(version)
+
+
+# def download_resources(path, version) -> bool:
+#     return generator_unpacker(download_resources_iter(path, version))
+
+
+# def download_resources_iter(
+#     path, version, chunk_size=4096
+# ) -> Generator[float, None, bool]:
+#     log.info(f"Downloading Bedrock resource pack for version {version}")
+#     version_url = next(
+#         (v["url"] for v in launcher_manifest["versions"] if v["id"] == version), None
+#     )
+#     if version_url is None:
+#         log.error(f"Could not find Bedrock resource pack for version {version}.")
+#         return False
+#
+#     try:
+#         version_manifest = json.load(urlopen(version_url))
+#         version_client_url = version_manifest["downloads"]["client"]["url"]
+#
+#         response = urlopen(version_client_url)
+#         data = []
+#         data_size = int(response.headers["content-length"].strip())
+#         index = 0
+#         chunk = b"hello"
+#         while chunk:
+#             chunk = response.read(chunk_size)
+#             data.append(chunk)
+#             index += 1
+#             yield min(1.0, (index * chunk_size) / (data_size * 2))
+#
+#         client = zipfile.ZipFile(io.BytesIO(b"".join(data)))
+#         paths = [fpath for fpath in client.namelist() if fpath.startswith("assets/")]
+#         path_count = len(paths)
+#         for path_index, fpath in enumerate(paths):
+#             if not path_index % 30:
+#                 yield path_index / (path_count * 2) + 0.5
+#             client.extract(fpath, path)
+#         client.extract("pack.mcmeta", path)
+#         client.extract("pack.png", path)
+#
+#     except:
+#         log.error(
+#             f"Failed to download and extract the Bedrock resource pack for version {version}. Make sure you have a connection to the internet.",
+#             exc_info=True,
+#         )
+#         return False
+#     log.info(f"Finished downloading Bedrock resource pack for version {version}")
+#     return True

amulet/resource_pack/bedrock/resource_pack.py

@@ -0,0 +1,40 @@
+import os
+import json
+
+from amulet.resource_pack.abc import BaseResourcePack
+from amulet.utils import comment_json
+
+
+class BedrockResourcePack(BaseResourcePack):
+    """A class to hold the bare-bones information about the resource pack.
+    Holds the pack format, description and if the pack is valid.
+    This information can be used in a viewer to display the packs to the user."""
+
+    def __init__(self, resource_pack_path: str):
+        super().__init__(resource_pack_path)
+        meta_path = os.path.join(resource_pack_path, "manifest.json")
+        if os.path.isfile(meta_path):
+            try:
+                with open(meta_path) as f:
+                    pack_mcmeta = comment_json.load(f)
+            except json.JSONDecodeError:
+                pass
+            else:
+                if isinstance(pack_mcmeta, dict):
+                    header = pack_mcmeta.get("header", None)
+                    if isinstance(header, dict):
+                        description = header.get("description", None)
+                        if isinstance(description, str):
+                            self._pack_description = description
+                            self._valid_pack = True
+
+        pack_icon_path = os.path.join(resource_pack_path, "pack_icon.png")
+        if os.path.isfile(pack_icon_path):
+            self._pack_icon = pack_icon_path
+
+    @staticmethod
+    def is_valid(pack_path: str) -> bool:
+        return os.path.isfile(os.path.join(pack_path, "manifest.json"))
+
+    def __repr__(self) -> str:
+        return f"BedrockResourcePack({self._root_dir})"