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

amulet/resource_pack/bedrock/blockshapes/bubble_column.py

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,186 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -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.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

@@ -0,0 +1,14 @@
+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

amulet/resource_pack/bedrock/blockshapes/door.py

@@ -0,0 +1,38 @@
+from amulet.block import Block
+from amulet.mesh.block import BlockMesh
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+import amulet_nbt
+
+
+class Door(Cube):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("upper_block_bit"), amulet_nbt.TAG_Byte)
+
+    @property
+    def blockshape(self) -> str:
+        return "door"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        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:
+        if block.properties["upper_block_bit"].py_data:
+            return super().get_block_model(
+                block, north, north, north, north, north, north, transparency
+            )
+        return super().get_block_model(
+            block, down, down, down, down, down, down, transparency
+        )
+
+
+BlockShape = Door()

amulet/resource_pack/bedrock/blockshapes/door1.py

@@ -0,0 +1,14 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.door import Door
+
+
+class Door1(Door):
+    @property
+    def blockshape(self) -> str:
+        return "door1"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 1
+
+
+BlockShape = Door1()

amulet/resource_pack/bedrock/blockshapes/door2.py

@@ -0,0 +1,14 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.door import Door
+
+
+class Door2(Door):
+    @property
+    def blockshape(self) -> str:
+        return "door2"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 2
+
+
+BlockShape = Door2()

amulet/resource_pack/bedrock/blockshapes/door3.py

@@ -0,0 +1,14 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.door import Door
+
+
+class Door3(Door):
+    @property
+    def blockshape(self) -> str:
+        return "door3"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 3
+
+
+BlockShape = Door3()

amulet/resource_pack/bedrock/blockshapes/door4.py

@@ -0,0 +1,14 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.door import Door
+
+
+class Door4(Door):
+    @property
+    def blockshape(self) -> str:
+        return "door4"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 4
+
+
+BlockShape = Door4()

amulet/resource_pack/bedrock/blockshapes/door5.py

@@ -0,0 +1,14 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.door import Door
+
+
+class Door5(Door):
+    @property
+    def blockshape(self) -> str:
+        return "door5"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 5
+
+
+BlockShape = Door5()

amulet/resource_pack/bedrock/blockshapes/door6.py

@@ -0,0 +1,14 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.door import Door
+
+
+class Door6(Door):
+    @property
+    def blockshape(self) -> str:
+        return "door6"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 6
+
+
+BlockShape = Door6()

amulet/resource_pack/bedrock/blockshapes/double_plant.py

@@ -0,0 +1,40 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
+    Cross,
+)
+from amulet.mesh.block import BlockMesh
+import amulet_nbt
+
+
+class DoublePlant(Cross):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("upper_block_bit"), amulet_nbt.TAG_Byte)
+
+    @property
+    def blockshape(self) -> str:
+        return "double_plant"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return aux_value % 8
+
+    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:
+        if block.properties["upper_block_bit"].py_data:
+            return super().get_block_model(block, up, up, up, up, up, up, transparency)
+        else:
+            return super().get_block_model(
+                block, down, down, down, down, down, down, transparency
+            )
+        # TODO: add the sunflower face and tint the required blocks
+
+
+BlockShape = DoublePlant()

amulet/resource_pack/bedrock/blockshapes/enchanting_table.py

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

amulet/resource_pack/bedrock/blockshapes/farmland.py

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