amulet-core 2.0a7__cp312-cp312-win_amd64.whl → 2.0.1a2.post250529084747__cp312-cp312-win_amd64.whl

amulet/resource_pack/abc/resource_pack_manager.py

@@ -1,87 +0,0 @@
-from typing import Optional, Iterator, TypeVar, Generic
-import json
-import copy
-
-from amulet.block import Block, BlockStack
-from amulet.mesh.block import BlockMesh
-from amulet.resource_pack.abc.resource_pack import BaseResourcePack
-from amulet.img import missing_no_icon_path
-from amulet.mesh.block.missing_block import get_missing_block
-
-PackT = TypeVar("PackT", bound=BaseResourcePack)
-
-
-class BaseResourcePackManager(Generic[PackT]):
-    """The base class that all resource pack managers must inherit from. Defines the base api."""
-
-    def __init__(self) -> None:
-        self._packs: list[PackT] = []
-        self._missing_block: Optional[BlockMesh] = None
-        self._texture_is_transparent: dict[str, tuple[float, bool]] = {}
-        self._cached_models: dict[BlockStack, BlockMesh] = {}
-
-    @property
-    def pack_paths(self) -> list[str]:
-        return [pack.root_dir for pack in self._packs]
-
-    def _unload(self) -> None:
-        """Clear all loaded resources."""
-        self._texture_is_transparent.clear()
-        self._cached_models.clear()
-
-    def _load_transparency_cache(self, path: str) -> None:
-        try:
-            with open(path) as f:
-                self._texture_is_transparent = json.load(f)
-        except:
-            pass
-
-    def _load_iter(self) -> Iterator[float]:
-        """Load resources."""
-        raise NotImplementedError
-
-    def reload(self) -> Iterator[float]:
-        """Unload and reload resources"""
-        self._unload()
-        yield from self._load_iter()
-
-    @property
-    def missing_no(self) -> str:
-        """The path to the missing_no image"""
-        return missing_no_icon_path
-
-    @property
-    def missing_block(self) -> BlockMesh:
-        if self._missing_block is None:
-            self._missing_block = get_missing_block(self)
-        return self._missing_block
-
-    @property
-    def textures(self) -> tuple[str, ...]:
-        """Returns a tuple of all the texture paths in the resource pack."""
-        raise NotImplementedError
-
-    def get_texture_path(self, namespace: Optional[str], relative_path: str) -> str:
-        """Get the absolute texture path from the namespace and relative path pair"""
-        raise NotImplementedError
-
-    def get_block_model(self, block_stack: BlockStack) -> BlockMesh:
-        """Get a model for a block state.
-        The block should already be in the resource pack format"""
-        if block_stack not in self._cached_models:
-            if len(block_stack) == 1:
-                self._cached_models[block_stack] = self._get_model(
-                    block_stack.base_block
-                )
-            else:
-                self._cached_models[block_stack] = BlockMesh.merge(
-                    (self._get_model(block_stack.base_block),)
-                    + tuple(
-                        self._get_model(block_) for block_ in block_stack.extra_blocks
-                    )
-                )
-
-        return copy.deepcopy(self._cached_models[block_stack])
-
-    def _get_model(self, block: Block) -> BlockMesh:
-        raise NotImplementedError

amulet/resource_pack/bedrock/__init__.py

@@ -1,2 +0,0 @@
-from .resource_pack import BedrockResourcePack
-from .resource_pack_manager import BedrockResourcePackManager

amulet/resource_pack/bedrock/blockshapes/__init__.py

@@ -1,31 +0,0 @@
-import importlib
-import pkgutil
-
-from .base_blockshape import BaseBlockShape
-
-BlockShapeClasses: dict[str, BaseBlockShape] = {}
-_class_names = set()
-
-
-def _load_blockshape(module_name: str) -> None:
-    blockshape_module = importlib.import_module(module_name)
-    if hasattr(blockshape_module, "BlockShape"):
-        blockshape = getattr(blockshape_module, "BlockShape")
-        if isinstance(blockshape, BaseBlockShape):
-            if blockshape.blockshape in BlockShapeClasses:
-                print(f"Name conflict with blockshape {blockshape.blockshape}")
-            if blockshape.__class__.__name__ in _class_names:
-                print(f"Duplicate class name {blockshape.__class__.__name__}")
-            else:
-                _class_names.add(blockshape.__class__.__name__)
-            BlockShapeClasses[blockshape.blockshape] = blockshape
-
-
-def _load_blockshapes() -> None:
-    package_prefix = __name__ + "."
-
-    for _, name, _ in pkgutil.walk_packages(__path__, package_prefix):
-        _load_blockshape(name)
-
-
-_load_blockshapes()

amulet/resource_pack/bedrock/blockshapes/air.py

@@ -1,35 +0,0 @@
-from amulet.block import Block
-from amulet.mesh.block.block_mesh import BlockMesh, Transparency
-from amulet.resource_pack.bedrock.blockshapes.base_blockshape import (
-    BaseBlockShape,
-)
-
-
-class Air(BaseBlockShape):
-    @property
-    def blockshape(self) -> str:
-        return "air"
-
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        return True
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        return 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],
-    ) -> BlockMesh:
-        return BlockMesh(3, {}, {}, {}, {}, {}, (), Transparency.Partial)
-
-
-BlockShape = Air()

amulet/resource_pack/bedrock/blockshapes/base_blockshape.py

@@ -1,29 +0,0 @@
-from amulet.block import Block
-from amulet.mesh.block import BlockMesh
-
-
-class BaseBlockShape:
-    @property
-    def blockshape(self) -> str:
-        raise NotImplementedError
-
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        raise NotImplementedError
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        raise NotImplementedError
-
-    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:
-        raise NotImplementedError

amulet/resource_pack/bedrock/blockshapes/bubble_column.py

@@ -1,29 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
-    Cross,
-)
-from amulet.mesh.block import BlockMesh
-
-
-class BubbleColumn(Cross):
-    @property
-    def blockshape(self) -> str:
-        return "bubble_column"
-
-    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 super().get_block_model(
-            block, north, north, north, north, north, north, transparency
-        )
-
-
-BlockShape = BubbleColumn()

amulet/resource_pack/bedrock/blockshapes/cake.py

@@ -1,46 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.partial_block import (
-    PartialBlock,
-)
-from amulet_nbt import AbstractBaseIntTag, IntTag
-
-
-class Cake(PartialBlock):
-    def is_valid(self, block: Block) -> bool:
-        return isinstance(block.properties.get("bite_counter"), IntTag)
-
-    @property
-    def blockshape(self) -> str:
-        return "cake"
-
-    def bounds(
-        self, block: Block
-    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        bite_count = block.properties["bite_counter"]
-        return (
-            (
-                1 / 16
-                + (
-                    bite_count.py_int
-                    if isinstance(bite_count, AbstractBaseIntTag)
-                    else 0
-                )
-                * 2
-                / 16,
-                15 / 16,
-            ),
-            (0, 0.5),
-            (1 / 16, 15 / 16),
-        )
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        bite_counter = block.properties["bite_counter"]
-        assert isinstance(bite_counter, AbstractBaseIntTag)
-        return min(1, bite_counter.py_int)
-
-    @property
-    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
-        return False, True, True, True, True, True
-
-
-BlockShape = Cake()

amulet/resource_pack/bedrock/blockshapes/chest.py

@@ -1,54 +0,0 @@
-from typing import Any
-
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.partial_block import (
-    PartialBlock,
-)
-from amulet.mesh.block import BlockMesh
-
-
-class Chest(PartialBlock):
-    @property
-    def blockshape(self) -> str:
-        return "chest"
-
-    def bounds(
-        self, block: Block
-    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        return (1 / 16, 15 / 16), (0, 14 / 16), (1 / 16, 15 / 16)
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        return 0
-
-    @property
-    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
-        return False, True, True, True, True, True
-
-    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,
-        *args: Any,
-        **kwargs: Any
-    ) -> BlockMesh:
-        rotation = {2: 2, 3: 0, 4: 1, 5: 3}.get(
-            block.properties["facing_direction"].py_data, 0
-        )
-
-        return (
-            super()
-            .get_block_model(
-                block, down, up, north, east, south, west, transparency, modify_uv=False
-            )
-            .rotate(0, rotation)
-        )
-
-
-BlockShape = Chest()

amulet/resource_pack/bedrock/blockshapes/comparator.py

@@ -1,51 +0,0 @@
-from typing import Any
-
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.partial_block import (
-    PartialBlock,
-)
-from amulet.mesh.block import BlockMesh
-import amulet_nbt
-
-
-class Comparator(PartialBlock):
-    def is_valid(self, block: Block) -> bool:
-        return isinstance(block.properties.get("direction"), amulet_nbt.TAG_Int)
-
-    @property
-    def blockshape(self) -> str:
-        return "comparator"
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        return (aux_value >> 3) & 1
-
-    def bounds(
-        self, block: Block
-    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        return (0, 1), (0, 2 / 16), (0, 1)
-
-    @property
-    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
-        return False, True, False, False, False, False
-
-    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],
-        *args: Any,
-        **kwargs: Any
-    ) -> BlockMesh:
-        return (
-            super()
-            .get_block_model(block, down, up, north, east, south, west, transparency)
-            .rotate(0, block.properties["direction"].py_data)
-        )
-
-
-BlockShape = Comparator()

amulet/resource_pack/bedrock/blockshapes/cross_texture.py

@@ -1,186 +0,0 @@
-import numpy
-
-from amulet.block import Block
-from amulet.mesh.block.block_mesh import BlockMesh, Transparency
-from amulet.resource_pack.bedrock.blockshapes.base_blockshape import (
-    BaseBlockShape,
-)
-
-
-class Cross(BaseBlockShape):
-    @property
-    def blockshape(self) -> str:
-        return "cross_texture"
-
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        return True
-
-    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 % 16
-
-    @property
-    def tint(self) -> tuple[float, float, float]:
-        return 1, 1, 1
-
-    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 BlockMesh(
-            3,
-            {
-                None: numpy.array(
-                    [
-                        0.0625,
-                        0.0,
-                        0.0625,
-                        0.9375,
-                        0.0,
-                        0.9375,
-                        0.9375,
-                        1.0,
-                        0.9375,
-                        0.0625,
-                        1.0,
-                        0.0625,
-                        0.0625,
-                        0.0,
-                        0.9375,
-                        0.9375,
-                        0.0,
-                        0.0625,
-                        0.9375,
-                        1.0,
-                        0.0625,
-                        0.0625,
-                        1.0,
-                        0.9375,
-                        0.9375,
-                        0.0,
-                        0.0625,
-                        0.0625,
-                        0.0,
-                        0.9375,
-                        0.0625,
-                        1.0,
-                        0.9375,
-                        0.9375,
-                        1.0,
-                        0.0625,
-                        0.9375,
-                        0.0,
-                        0.9375,
-                        0.0625,
-                        0.0,
-                        0.0625,
-                        0.0625,
-                        1.0,
-                        0.0625,
-                        0.9375,
-                        1.0,
-                        0.9375,
-                    ],
-                    dtype=numpy.float32,
-                )
-            },
-            {
-                None: numpy.array(
-                    [
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                    ],
-                    numpy.float32,
-                )
-            },
-            {None: numpy.array(self.tint * 16, numpy.float32)},
-            {
-                None: numpy.array(
-                    [
-                        0,
-                        1,
-                        2,
-                        0,
-                        2,
-                        3,
-                        4,
-                        5,
-                        6,
-                        4,
-                        6,
-                        7,
-                        8,
-                        9,
-                        10,
-                        8,
-                        10,
-                        11,
-                        12,
-                        13,
-                        14,
-                        12,
-                        14,
-                        15,
-                    ],
-                    numpy.uint32,
-                )
-            },
-            {
-                None: numpy.array(
-                    [
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                    ],
-                    numpy.uint32,
-                )
-            },
-            (up,),
-            Transparency.Partial,
-        )
-
-
-BlockShape = Cross()

amulet/resource_pack/bedrock/blockshapes/cross_texture0.py

@@ -1,17 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
-    Cross,
-)
-
-
-class Cross0(Cross):
-    @property
-    def blockshape(self) -> str:
-        return "cross_texture0"
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        return 0
-
-
-BlockShape = Cross0()

amulet/resource_pack/bedrock/blockshapes/cross_texture_green.py

@@ -1,16 +0,0 @@
-from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
-    Cross,
-)
-
-
-class CrossGreen(Cross):
-    @property
-    def blockshape(self) -> str:
-        return "cross_texture_green"
-
-    @property
-    def tint(self) -> tuple[float, float, float]:
-        return 0, 1, 0
-
-
-BlockShape = CrossGreen()

amulet/resource_pack/bedrock/blockshapes/cube.py

@@ -1,38 +0,0 @@
-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.default import Default
-
-
-class Cube(Default):
-    @property
-    def blockshape(self) -> str:
-        return "cube"
-
-    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,
-            up,
-            north,
-            east,
-            south,
-            west,
-            (
-                Transparency.FullTranslucent
-                if any(transparency)
-                else Transparency.FullOpaque
-            ),
-        )
-
-
-BlockShape = Cube()

amulet/resource_pack/bedrock/blockshapes/default.py

@@ -1,14 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.base_blockshape import (
-    BaseBlockShape,
-)
-
-
-class Default(BaseBlockShape):
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        return True
-
-    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 % 16