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

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()

amulet/resource_pack/bedrock/blockshapes/fence.py

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

amulet/resource_pack/bedrock/blockshapes/flat.py

@@ -0,0 +1,55 @@
+import numpy
+
+from amulet.block import Block
+from amulet.mesh.block.block_mesh import BlockMesh, Transparency
+from amulet.resource_pack.bedrock.blockshapes.default import Default
+
+
+class Flat(Default):
+    @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.0,
+                        0.0625,
+                        1.0,
+                        1.0,
+                        0.0625,
+                        1.0,
+                        1.0,
+                        0.0625,
+                        0.0,
+                        0.0,
+                        0.0625,
+                        0.0,
+                    ],
+                    dtype=numpy.float32,
+                )
+            },
+            {
+                None: numpy.array(
+                    [0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0], numpy.float32
+                )
+            },
+            {None: numpy.array(self.tint * 4, numpy.float32)},
+            {None: numpy.array([0, 1, 2, 0, 2, 3], numpy.uint32)},
+            {None: numpy.array([0, 0], numpy.uint32)},
+            (up,),
+            Transparency.Partial,
+        )

amulet/resource_pack/bedrock/blockshapes/flat_wall.py

@@ -0,0 +1,55 @@
+import numpy
+
+from amulet.block import Block
+from amulet.mesh.block.block_mesh import BlockMesh, Transparency
+from amulet.resource_pack.bedrock.blockshapes.default import Default
+
+
+class FlatWall(Default):
+    @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.0,
+                        0.0,
+                        1 / 16,
+                        1.0,
+                        0.0,
+                        1 / 16,
+                        1.0,
+                        1.0,
+                        1 / 16,
+                        0.0,
+                        1.0,
+                        1 / 16,
+                    ],
+                    dtype=numpy.float32,
+                )
+            },
+            {
+                None: numpy.array(
+                    [0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0], numpy.float32
+                )
+            },
+            {None: numpy.array(self.tint * 4, numpy.float32)},
+            {None: numpy.array([0, 1, 2, 0, 2, 3], numpy.uint32)},
+            {None: numpy.array([0, 0], numpy.uint32)},
+            (up,),
+            Transparency.Partial,
+        )

amulet/resource_pack/bedrock/blockshapes/furnace.py

@@ -0,0 +1,44 @@
+from amulet.block import Block
+from amulet.mesh.block import BlockMesh
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+import amulet_nbt
+
+
+class Furnace(Cube):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("facing_direction"), amulet_nbt.TAG_Int)
+
+    @property
+    def blockshape(self) -> str:
+        return "furnace"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 0
+
+    @property
+    def rotation_map(self) -> dict[int, int]:
+        return {2: 2, 3: 0, 4: 1, 5: 3}
+
+    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:
+        rotation = self.rotation_map.get(
+            block.properties["facing_direction"].py_data, 0
+        )
+
+        return (
+            super()
+            .get_block_model(block, down, up, north, east, south, west, transparency)
+            .rotate(0, rotation)
+        )
+
+
+BlockShape = Furnace()

amulet/resource_pack/bedrock/blockshapes/furnace_lit.py

@@ -0,0 +1,14 @@
+from amulet.resource_pack.bedrock.blockshapes.furnace import Furnace
+
+
+class FurnaceLit(Furnace):
+    @property
+    def blockshape(self) -> str:
+        return "furnace_lit"
+
+    @property
+    def rotation_map(self) -> dict[int, int]:
+        return {2: 3, 3: 1, 4: 2, 5: 0}
+
+
+BlockShape = FurnaceLit()

amulet/resource_pack/bedrock/blockshapes/green_cube.py

@@ -0,0 +1,39 @@
+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 GreenCube(Cube):
+    @property
+    def blockshape(self) -> str:
+        return "greencube"
+
+    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
+            ),
+            (0, 1, 0),
+        )
+
+
+BlockShape = GreenCube()

amulet/resource_pack/bedrock/blockshapes/ladder.py

@@ -0,0 +1,36 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.flat_wall import (
+    FlatWall,
+)
+from amulet.mesh.block import BlockMesh
+
+
+class Ladder(FlatWall):
+    @property
+    def blockshape(self) -> str:
+        return "ladder"
+
+    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:
+        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)
+            .rotate(0, rotation)
+        )
+
+
+BlockShape = Ladder()

amulet/resource_pack/bedrock/blockshapes/lilypad.py

@@ -0,0 +1,14 @@
+from amulet.resource_pack.bedrock.blockshapes.flat import Flat
+
+
+class LilyPad(Flat):
+    @property
+    def blockshape(self) -> str:
+        return "lilypad"
+
+    @property
+    def tint(self) -> tuple[float, float, float]:
+        return 0, 1, 0
+
+
+BlockShape = LilyPad()

amulet/resource_pack/bedrock/blockshapes/partial_block.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+from amulet.block import Block
+from amulet.mesh.block.block_mesh import BlockMesh, Transparency
+from amulet.mesh.block.cube import get_cube
+from amulet.resource_pack.bedrock.blockshapes.default import Default
+
+BoundsType = tuple[tuple[float, float], tuple[float, float], tuple[float, float]]
+DoNotCullType = tuple[bool, bool, bool, bool, bool, bool]
+
+
+class PartialBlock(Default):
+    def bounds(self, block: Block) -> BoundsType:
+        return (0, 1), (0, 1), (0, 1)
+
+    @property
+    def do_not_cull(self) -> DoNotCullType:
+        return False, False, 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],
+        modify_uv: bool = True,
+        bounds: Optional[BoundsType] = None,
+        do_not_cull: Optional[DoNotCullType] = None,
+    ) -> BlockMesh:
+        bounds = bounds or self.bounds(block)
+        if modify_uv:
+            uv = (
+                (bounds[0][0], bounds[2][0], bounds[0][1], bounds[2][1]),
+                (bounds[0][0], bounds[2][0], bounds[0][1], bounds[2][1]),
+                (bounds[0][0], 1 - bounds[1][1], bounds[0][1], 1 - bounds[1][0]),
+                (bounds[2][0], 1 - bounds[1][1], bounds[2][1], 1 - bounds[1][0]),
+                (bounds[0][0], 1 - bounds[1][1], bounds[0][1], 1 - bounds[1][0]),
+                (bounds[2][0], 1 - bounds[1][1], bounds[2][1], 1 - bounds[1][0]),
+            )
+        else:
+            uv = ((0, 0, 1, 1),) * 6
+        return get_cube(
+            down,
+            up,
+            north,
+            east,
+            south,
+            west,
+            Transparency.Partial,
+            bounds=bounds,
+            texture_uv=uv,
+            do_not_cull=do_not_cull or self.do_not_cull,
+        )

amulet/resource_pack/bedrock/blockshapes/piston.py

@@ -0,0 +1,44 @@
+from amulet.block import Block
+from amulet.mesh.block import BlockMesh
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+import amulet_nbt
+
+
+class Piston(Cube):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("facing_direction"), amulet_nbt.TAG_Int)
+
+    @property
+    def blockshape(self) -> str:
+        return "piston"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 0
+
+    @property
+    def rotation_map(self) -> dict[int, tuple[int, int]]:
+        return {0: (2, 0), 1: (0, 0), 2: (1, 2), 3: (1, 0), 4: (1, 1), 5: (1, 3)}
+
+    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:
+        rotation = self.rotation_map.get(
+            block.properties["facing_direction"].py_data, (0, 0)
+        )
+
+        return (
+            super()
+            .get_block_model(block, down, up, north, east, south, west, transparency)
+            .rotate(*rotation)
+        )
+
+
+BlockShape = Piston()

amulet/resource_pack/bedrock/blockshapes/piston_arm.py

@@ -0,0 +1,72 @@
+from typing import Any
+from amulet.block import Block
+from amulet.mesh.block import BlockMesh
+from amulet.resource_pack.bedrock.blockshapes.partial_block import (
+    PartialBlock,
+)
+import amulet_nbt
+
+
+class PistonArm(PartialBlock):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("facing_direction"), amulet_nbt.TAG_Int)
+
+    @property
+    def blockshape(self) -> str:
+        return "piston_arm"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 0
+
+    @property
+    def rotation_map(self) -> dict[int, tuple[int, int]]:
+        return {0: (2, 0), 1: (0, 0), 2: (1, 2), 3: (1, 0), 4: (1, 1), 5: (1, 3)}
+
+    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:
+        rotation = self.rotation_map.get(
+            block.properties["facing_direction"].py_data, (0, 0)
+        )
+
+        return BlockMesh.merge(
+            [
+                super().get_block_model(
+                    block,
+                    down,
+                    up,
+                    north,
+                    north,
+                    north,
+                    north,
+                    transparency,
+                    bounds=((0, 1), (12 / 16, 1), (0, 1)),
+                    do_not_cull=(True, False, True, True, True, True),
+                ),
+                super().get_block_model(
+                    block,
+                    west,
+                    west,
+                    west,
+                    west,
+                    west,
+                    west,
+                    (transparency[5],) * 6,
+                    bounds=((6 / 16, 10 / 16), (0, 12 / 16), (6 / 16, 10 / 16)),
+                    do_not_cull=(False, False, True, True, True, True),
+                ),
+            ]
+        ).rotate(*rotation)
+
+
+BlockShape = PistonArm()

amulet/resource_pack/bedrock/blockshapes/portal_frame.py

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

amulet/resource_pack/bedrock/blockshapes/pressure_plate.py

@@ -0,0 +1,29 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.partial_block import (
+    PartialBlock,
+)
+import amulet_nbt
+
+
+class PressurePlate(PartialBlock):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("redstone_signal"), amulet_nbt.TAG_Int)
+
+    @property
+    def blockshape(self) -> str:
+        return "pressure_plate"
+
+    def bounds(
+        self, block: Block
+    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
+        if block.properties["redstone_signal"].py_data >= 1:
+            return (1 / 16, 15 / 16), (0, 1 / 32), (1 / 16, 15 / 16)
+        else:
+            return (1 / 16, 15 / 16), (0, 1 / 16), (1 / 16, 15 / 16)
+
+    @property
+    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
+        return False, True, True, True, True, True
+
+
+BlockShape = PressurePlate()

amulet/resource_pack/bedrock/blockshapes/pumpkin.py

@@ -0,0 +1,36 @@
+from amulet.block import Block
+from amulet.resource_pack.bedrock.blockshapes.cube import Cube
+from amulet.mesh.block import BlockMesh
+import amulet_nbt
+
+
+class Pumpkin(Cube):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("direction"), amulet_nbt.TAG_Int)
+
+    @property
+    def blockshape(self) -> str:
+        return "pumpkin"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        return 2
+
+    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, down, up, north, east, south, west, transparency)
+            .rotate(0, block.properties["direction"].py_data)
+        )
+
+
+BlockShape = Pumpkin()

amulet/resource_pack/bedrock/blockshapes/pumpkin_carved.py

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

amulet/resource_pack/bedrock/blockshapes/pumpkin_lit.py

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

amulet/resource_pack/bedrock/blockshapes/red_dust.py

@@ -0,0 +1,14 @@
+from amulet.resource_pack.bedrock.blockshapes.flat import Flat
+
+
+class RedDust(Flat):
+    @property
+    def blockshape(self) -> str:
+        return "red_dust"
+
+    @property
+    def tint(self) -> tuple[float, float, float]:
+        return 1, 0, 0
+
+
+BlockShape = RedDust()

amulet/resource_pack/bedrock/blockshapes/repeater.py

@@ -0,0 +1,53 @@
+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 Repeater(PartialBlock):
+    def is_valid(self, block: Block) -> bool:
+        return isinstance(block.properties.get("direction"), amulet_nbt.TAG_Int)
+
+    @property
+    def blockshape(self) -> str:
+        return "repeater"
+
+    def texture_index(self, block: Block, aux_value: int) -> int:
+        if block.base_name == "powered_repeater":
+            return 1
+        else:
+            return 0
+
+    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 = Repeater()