amulet-core 2.0a3__cp312-cp312-win_amd64.whl

amulet/game/translate/_functions/_code_functions/bedrock_chest_connection.py

@@ -0,0 +1,152 @@
+from typing import Callable, Any
+from amulet_nbt import CompoundTag, IntTag, ByteTag, StringTag, AbstractBaseTag
+from .._state import SrcData, StateData, DstData
+
+
+def _bedrock_chest_connection(
+    facing_property: str, connections: dict[tuple[Any, int, int], StringTag]
+) -> Callable[[SrcData, StateData, DstData], None]:
+    def main(src: SrcData, state: StateData, dst: DstData) -> None:
+        nbt = src.nbt
+        if nbt is None:
+            return
+
+        tag = nbt.tag
+        if not isinstance(tag, CompoundTag):
+            return
+
+        if tag.get("pairlead") != ByteTag(1):
+            return
+
+        pairx = tag.get("pairx")
+        if not isinstance(pairx, IntTag):
+            return
+
+        pairz = tag.get("pairz")
+        if not isinstance(pairz, IntTag):
+            return
+
+        block = src.block
+        if block is None:
+            return
+        extra = src.extra
+        if extra is None:
+            dst.extra_needed = True
+            return
+
+        facing_direction = block.properties.get(facing_property)
+        if not isinstance(facing_direction, AbstractBaseTag):
+            return
+
+        dx = pairx.py_int - extra.absolute_coordinates[0]
+        dz = pairz.py_int - extra.absolute_coordinates[2]
+
+        connection = connections.get((facing_direction.py_data, dx, dz))
+        if connection is None:
+            return
+        dst.properties["connection"] = connection
+
+    return main
+
+
+bedrock_chest_connection_other_left = _bedrock_chest_connection(
+    "facing_direction",
+    {
+        (2, -1, 0): StringTag("left"),  # north
+        (3, 1, 0): StringTag("left"),  # south
+        (4, 0, 1): StringTag("left"),  # west
+        (5, 0, -1): StringTag("left"),  # east
+    },
+)
+
+bedrock_chest_connection_other_right = _bedrock_chest_connection(
+    "facing_direction",
+    {
+        (2, 1, 0): StringTag("right"),  # north
+        (3, -1, 0): StringTag("right"),  # south
+        (4, 0, -1): StringTag("right"),  # west
+        (5, 0, 1): StringTag("right"),  # east
+    },
+)
+
+bedrock_chest_connection_self = _bedrock_chest_connection(
+    "facing_direction",
+    {
+        (2, -1, 0): StringTag("right"),  # north
+        (2, 1, 0): StringTag("left"),  # north
+        (3, 1, 0): StringTag("right"),  # south
+        (3, -1, 0): StringTag("left"),  # south
+        (4, 0, 1): StringTag("right"),  # west
+        (4, 0, -1): StringTag("left"),  # west
+        (5, 0, -1): StringTag("right"),  # east
+        (5, 0, 1): StringTag("left"),  # east
+    },
+)
+
+bedrock_chest_connection_other_left_120 = _bedrock_chest_connection(
+    "minecraft:cardinal_direction",
+    {
+        ("north", -1, 0): StringTag("left"),  # north
+        ("south", 1, 0): StringTag("left"),  # south
+        ("west", 0, 1): StringTag("left"),  # west
+        ("east", 0, -1): StringTag("left"),  # east
+    },
+)
+
+bedrock_chest_connection_other_right_120 = _bedrock_chest_connection(
+    "minecraft:cardinal_direction",
+    {
+        ("north", 1, 0): StringTag("right"),  # north
+        ("south", -1, 0): StringTag("right"),  # south
+        ("west", 0, -1): StringTag("right"),  # west
+        ("east", 0, 1): StringTag("right"),  # east
+    },
+)
+
+bedrock_chest_connection_self_120 = _bedrock_chest_connection(
+    "minecraft:cardinal_direction",
+    {
+        ("north", -1, 0): StringTag("right"),  # north
+        ("north", 1, 0): StringTag("left"),  # north
+        ("south", 1, 0): StringTag("right"),  # south
+        ("south", -1, 0): StringTag("left"),  # south
+        ("west", 0, 1): StringTag("right"),  # west
+        ("west", 0, -1): StringTag("left"),  # west
+        ("east", 0, -1): StringTag("right"),  # east
+        ("east", 0, 1): StringTag("left"),  # east
+    },
+)
+
+
+def from_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    block = src.block
+    if block is None:
+        return
+
+    extra = src.extra
+    if extra is None:
+        dst.extra_needed = True
+        return
+
+    facing = block.properties.get("facing")
+    if not isinstance(facing, StringTag):
+        return
+
+    x, _, z = extra.absolute_coordinates
+    facing_str = facing.py_str
+    if facing_str == "north":
+        dst.nbt.append(("", CompoundTag, (), "pairlead", ByteTag(1)))
+        dst.nbt.append(("", CompoundTag, (), "pairx", IntTag(x - 1)))
+        dst.nbt.append(("", CompoundTag, (), "pairz", IntTag(z)))
+    elif facing_str == "south":
+        dst.nbt.append(("", CompoundTag, (), "pairlead", ByteTag(1)))
+        dst.nbt.append(("", CompoundTag, (), "pairx", IntTag(x + 1)))
+        dst.nbt.append(("", CompoundTag, (), "pairz", IntTag(z)))
+    elif facing_str == "west":
+        dst.nbt.append(("", CompoundTag, (), "pairlead", ByteTag(1)))
+        dst.nbt.append(("", CompoundTag, (), "pairx", IntTag(x)))
+        dst.nbt.append(("", CompoundTag, (), "pairz", IntTag(z + 1)))
+    elif facing_str == "east":
+        dst.nbt.append(("", CompoundTag, (), "pairlead", ByteTag(1)))
+        dst.nbt.append(("", CompoundTag, (), "pairx", IntTag(x)))
+        dst.nbt.append(("", CompoundTag, (), "pairz", IntTag(z - 1)))

amulet/game/translate/_functions/_code_functions/bedrock_moving_block_pos.py

@@ -0,0 +1,88 @@
+from amulet_nbt import CompoundTag, IntTag
+from .._state import SrcData, StateData, DstData
+
+
+def to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    if src.extra is None:
+        return
+
+    x, y, z = src.extra.absolute_coordinates
+
+    nbt = src.nbt
+    if nbt is None:
+        return
+
+    tag = nbt.tag
+    if not isinstance(tag, CompoundTag):
+        return
+
+    pistonPosX = tag.get("pistonPosX")
+    if not isinstance(pistonPosX, IntTag):
+        return
+    pistonPosY = tag.get("pistonPosY")
+    if not isinstance(pistonPosY, IntTag):
+        return
+    pistonPosZ = tag.get("pistonPosZ")
+    if not isinstance(pistonPosZ, IntTag):
+        return
+
+    dst.nbt.append(
+        (
+            "",
+            CompoundTag,
+            (("utags", CompoundTag),),
+            "pistonPosdX",
+            IntTag(pistonPosX.py_int - x),
+        )
+    )
+    dst.nbt.append(
+        (
+            "",
+            CompoundTag,
+            (("utags", CompoundTag),),
+            "pistonPosdY",
+            IntTag(pistonPosY.py_int - y),
+        )
+    )
+    dst.nbt.append(
+        (
+            "",
+            CompoundTag,
+            (("utags", CompoundTag),),
+            "pistonPosdZ",
+            IntTag(pistonPosZ.py_int - z),
+        )
+    )
+
+
+def from_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    if src.extra is None:
+        return
+
+    x, y, z = src.extra.absolute_coordinates
+
+    nbt = src.nbt
+    if nbt is None:
+        return
+
+    tag = nbt.tag
+    if not isinstance(tag, CompoundTag):
+        return
+
+    utags = tag.get("utags")
+    if not isinstance(utags, CompoundTag):
+        return
+
+    pistonPosdX = utags.get("pistonPosdX")
+    if not isinstance(pistonPosdX, IntTag):
+        return
+    pistonPosdY = utags.get("pistonPosdY")
+    if not isinstance(pistonPosdY, IntTag):
+        return
+    pistonPosdZ = utags.get("pistonPosdZ")
+    if not isinstance(pistonPosdZ, IntTag):
+        return
+
+    dst.nbt.append(("", CompoundTag, (), "pistonPosX", IntTag(pistonPosdX.py_int + x)))
+    dst.nbt.append(("", CompoundTag, (), "pistonPosY", IntTag(pistonPosdY.py_int + y)))
+    dst.nbt.append(("", CompoundTag, (), "pistonPosZ", IntTag(pistonPosdZ.py_int + z)))

amulet/game/translate/_functions/_code_functions/bedrock_sign.py

@@ -0,0 +1,152 @@
+import json
+from typing import Any
+from uuid import uuid4
+
+from amulet_nbt import StringTag, CompoundTag, ListTag
+from ._text import RawTextComponent, ExtendedBedrockSectionParser
+from .._state import SrcData, StateData, DstData
+
+
+BedrockFrontText = str(uuid4())
+BedrockBackText = str(uuid4())
+
+
+def _to_universal(
+    src: CompoundTag,
+    src_key: str,
+    dst: DstData,
+    universal_native_key: str,
+    universal_key: str,
+) -> None:
+    text = src.get_string(src_key)
+    if not isinstance(text, StringTag):
+        return
+
+    dst.nbt.append(
+        (
+            "",
+            CompoundTag,
+            (("utags", CompoundTag),),
+            universal_native_key,
+            text,
+        )
+    )
+
+    if text:
+        for line_num, component in enumerate(
+            RawTextComponent.from_section_text(
+                text.py_str, ExtendedBedrockSectionParser, True
+            )
+        ):
+            dst.nbt.append(
+                (
+                    "",
+                    CompoundTag,
+                    (
+                        ("utags", CompoundTag),
+                        (universal_key, CompoundTag),
+                        ("messages", ListTag),
+                    ),
+                    line_num,
+                    StringTag(json.dumps(component.to_java_raw_text())),
+                )
+            )
+
+
+def _from_universal(
+    utags: CompoundTag,
+    universal_native_key: str,
+    universal_key: str,
+    dst: DstData,
+    native_key: str,
+) -> None:
+    native_text = utags.get_string(universal_native_key)
+    text: StringTag
+    if isinstance(native_text, StringTag):
+        text = native_text
+    else:
+        messages = utags.get_compound(universal_key, CompoundTag()).get_list(
+            "messages", ListTag()
+        )
+
+        lines: list[Any] = [""]
+        if messages.element_class is StringTag:
+            for line_num in range(4):
+                if line_num >= len(messages):
+                    lines.append("")
+                else:
+                    try:
+                        lines.append(json.loads(messages.get_string(line_num).py_str))
+                    except:
+                        lines.append("")
+        else:
+            lines.extend([""] * 4)
+
+        text = StringTag(
+            RawTextComponent.from_java_raw_text(lines).to_section_text(
+                ExtendedBedrockSectionParser
+            )
+        )
+
+    dst.nbt.append(
+        (
+            "",
+            CompoundTag,
+            (),
+            native_key,
+            text,
+        )
+    )
+
+
+def to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    nbt = src.nbt
+    if nbt is None:
+        return
+
+    tag = nbt.tag
+    if not isinstance(tag, CompoundTag):
+        return
+
+    _to_universal(tag, "Text", dst, BedrockFrontText, "front_text")
+
+
+def from_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    nbt = src.nbt
+    if nbt is not None:
+        tag = nbt.tag
+        if isinstance(tag, CompoundTag):
+            utags = tag.get_compound("utags")
+            if isinstance(utags, CompoundTag):
+                _from_universal(utags, BedrockFrontText, "front_text", dst, "Text")
+                return
+
+    dst.nbt.append(("", CompoundTag, (), "Text", StringTag()))
+
+
+def to_universal_120(src: SrcData, state: StateData, dst: DstData) -> None:
+    nbt = src.nbt
+    if nbt is None:
+        return
+
+    tag = nbt.tag
+    if not isinstance(tag, CompoundTag):
+        return
+
+    _to_universal(tag, "FrontText", dst, BedrockFrontText, "front_text")
+    _to_universal(tag, "BackText", dst, BedrockBackText, "back_text")
+
+
+def from_universal_120(src: SrcData, state: StateData, dst: DstData) -> None:
+    nbt = src.nbt
+    if nbt is not None:
+        tag = nbt.tag
+        if isinstance(tag, CompoundTag):
+            utags = tag.get_compound("utags")
+            if isinstance(utags, CompoundTag):
+                _from_universal(utags, BedrockFrontText, "front_text", dst, "FrontText")
+                _from_universal(utags, BedrockBackText, "back_text", dst, "BackText")
+                return
+
+    dst.nbt.append(("", CompoundTag, (), "FrontText", StringTag()))
+    dst.nbt.append(("", CompoundTag, (), "BackText", StringTag()))

amulet/game/translate/_functions/_code_functions/bedrock_skull_rotation.py

@@ -0,0 +1,16 @@
+from amulet_nbt import CompoundTag, FloatTag, StringTag
+from .._state import SrcData, StateData, DstData
+
+
+def to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    nbt = src.nbt
+    if nbt is not None:
+        tag = nbt.tag
+        if isinstance(tag, CompoundTag):
+            rotation = tag.get("Rotation")
+            if isinstance(rotation, FloatTag):
+                dst.properties["rotation"] = StringTag(
+                    f"{int(rotation.py_float // 22.5) % 16}"
+                )
+                return
+    dst.properties["rotation"] = StringTag("0")

amulet/game/translate/_functions/_code_functions/custom_name.py

@@ -0,0 +1,146 @@
+from uuid import uuid4
+import json
+from typing import Callable
+
+from amulet_nbt import CompoundTag, StringTag
+
+from .._state import SrcData, StateData, DstData
+from ._text import (
+    RawTextComponent,
+    BedrockSectionParser,
+    ExtendedBedrockSectionParser,
+    JavaSectionParser,
+)
+
+
+JavaSectionText = str(uuid4())
+JavaRawText = str(uuid4())
+BedrockSectionText = str(uuid4())
+BedrockExtendedSectionText = str(uuid4())
+
+
+def get_custom_name(src: SrcData, dst: DstData, key: str) -> None:
+    nbt = src.nbt
+    if nbt is None:
+        return
+
+    tag = nbt.tag
+    if not isinstance(tag, CompoundTag):
+        return
+
+    custom_name = tag.get("CustomName")
+    if not isinstance(custom_name, StringTag):
+        return
+
+    # Store the raw value so we can non-destructively recover it
+    dst.nbt.append(("", CompoundTag, (("utags", CompoundTag),), key, custom_name))
+
+
+def java_section_to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    get_custom_name(src, dst, JavaSectionText)
+
+
+def java_raw_to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    get_custom_name(src, dst, JavaRawText)
+
+
+def bedrock_to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    get_custom_name(src, dst, BedrockSectionText)
+
+
+def bedrock_extended_to_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    get_custom_name(src, dst, BedrockExtendedSectionText)
+
+
+def set_custom_name(
+    src: SrcData,
+    dst: DstData,
+    target: str,
+    component_to_raw: Callable[[RawTextComponent], StringTag],
+) -> None:
+    nbt = src.nbt
+    if nbt is None:
+        return
+
+    tag = nbt.tag
+    if not isinstance(tag, CompoundTag):
+        return
+
+    utags = tag.get("utags")
+    if not isinstance(utags, CompoundTag):
+        return
+
+    if isinstance((native_custom_name := utags.get(target)), StringTag):
+        custom_name = native_custom_name
+    elif isinstance(
+        (java_section_custom_name := utags.get(JavaSectionText)), StringTag
+    ):
+        component = RawTextComponent.from_section_text(
+            java_section_custom_name.py_str, JavaSectionParser
+        )
+        custom_name = component_to_raw(component)
+    elif isinstance((java_raw_custom_name := utags.get(JavaRawText)), StringTag):
+        try:
+            component = RawTextComponent.from_java_raw_text(
+                json.loads(java_raw_custom_name.py_str)
+            )
+        except:
+            custom_name = StringTag()
+        else:
+            custom_name = component_to_raw(component)
+
+    elif isinstance((bedrock_custom_name := utags.get(BedrockSectionText)), StringTag):
+        component = RawTextComponent.from_section_text(
+            bedrock_custom_name.py_str, BedrockSectionParser
+        )
+        custom_name = component_to_raw(component)
+    elif isinstance(
+        (bedrock_extended_custom_name := utags.get(BedrockExtendedSectionText)),
+        StringTag,
+    ):
+        component = RawTextComponent.from_section_text(
+            bedrock_extended_custom_name.py_str, ExtendedBedrockSectionParser
+        )
+        custom_name = component_to_raw(component)
+    else:
+        custom_name = StringTag()
+
+    dst.nbt.append(
+        (
+            "",
+            CompoundTag,
+            (),
+            "CustomName",
+            custom_name,
+        )
+    )
+
+
+def java_section_from_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    def component_to_raw(component: RawTextComponent) -> StringTag:
+        return StringTag(component.to_section_text(JavaSectionParser))
+
+    set_custom_name(src, dst, JavaSectionText, component_to_raw)
+
+
+def java_raw_from_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    def component_to_raw(component: RawTextComponent) -> StringTag:
+        return StringTag(json.dumps(component.to_java_raw_text()))
+
+    set_custom_name(src, dst, JavaSectionText, component_to_raw)
+
+
+def bedrock_from_universal(src: SrcData, state: StateData, dst: DstData) -> None:
+    def component_to_raw(component: RawTextComponent) -> StringTag:
+        return StringTag(component.to_section_text(BedrockSectionParser))
+
+    set_custom_name(src, dst, BedrockSectionText, component_to_raw)
+
+
+def bedrock_extended_from_universal(
+    src: SrcData, state: StateData, dst: DstData
+) -> None:
+    def component_to_raw(component: RawTextComponent) -> StringTag:
+        return StringTag(component.to_section_text(ExtendedBedrockSectionParser))
+
+    set_custom_name(src, dst, BedrockExtendedSectionText, component_to_raw)

amulet/game/translate/_functions/_frozen.py

@@ -0,0 +1,66 @@
+from typing import TypeVar, Any
+from collections.abc import Mapping, Iterator, Hashable, Set, Iterable
+
+K = TypeVar("K", bound=Hashable)
+V = TypeVar("V", bound=Hashable)
+
+
+class FrozenMapping(Mapping[K, V], Hashable):
+    """
+    A hashable Mapping class.
+    All values in the mapping must be hashable.
+    """
+
+    _map: Mapping[K, V]
+    _h: int | None
+
+    def __init__(self, mapping: Mapping) -> None:
+        self._map: dict[K, V] = dict(mapping)
+        self._h = None
+
+    def __getitem__(self, k: K) -> V:
+        return self._map[k]
+
+    def __len__(self) -> int:
+        return len(self._map)
+
+    def __iter__(self) -> Iterator[K]:
+        return iter(self._map)
+
+    def __hash__(self) -> int:
+        if self._h is None:
+            self._h = hash(frozenset(self._map.items()))
+        return self._h
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        return self._map == other
+
+
+class OrderedFrozenSet(Set[K], Hashable):
+    _map: dict[K, None]
+    _h: int | None
+
+    def __init__(self, items: Iterable[K]) -> None:
+        self._map = dict.fromkeys(items)
+        self._h = None
+
+    def __contains__(self, item: Any) -> bool:
+        return item in self._map
+
+    def __len__(self) -> int:
+        return len(self._map)
+
+    def __iter__(self) -> Iterator[K]:
+        yield from self._map
+
+    def __hash__(self) -> int:
+        if self._h is None:
+            self._h = hash(tuple(self._map))
+        return self._h
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Set):
+            return NotImplemented
+        return self._map.keys() == other

amulet/game/translate/_functions/_state.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Union, Callable
+from dataclasses import dataclass, field
+
+from amulet_nbt import (
+    NamedTag,
+    ListTag,
+    CompoundTag,
+)
+
+from amulet.block import Block, PropertyValueType
+from amulet.block_entity import BlockEntity
+from amulet.entity import Entity
+from amulet.data_types import BlockCoordinates
+from ._typing import NBTTagT, NBTPath
+
+
+@dataclass(frozen=True)
+class SrcDataExtra:
+    absolute_coordinates: BlockCoordinates
+    get_block_callback: Callable[[BlockCoordinates], tuple[Block, BlockEntity | None]]
+
+
+@dataclass(frozen=True)
+class SrcData:
+    block: Block | None
+    nbt: NamedTag | None
+    extra: SrcDataExtra | None
+
+
+@dataclass
+class StateData:
+    relative_location: BlockCoordinates = (0, 0, 0)
+    # nbt_path is only set when within walk_input_nbt
+    nbt_path: tuple[str, type[ListTag] | type[CompoundTag], NBTPath] | None = None
+
+
+@dataclass
+class DstData:
+    cls: type[Block] | type[Entity] | None = None
+    resource_id: tuple[str, str] | None = None
+    properties: dict[str, PropertyValueType] = field(default_factory=dict)
+    nbt: list[
+        tuple[
+            str,
+            type[ListTag] | type[CompoundTag],
+            NBTPath,
+            Union[str, int],
+            NBTTagT,
+        ]
+    ] = field(default_factory=list)
+    extra_needed: bool = False
+    cacheable: bool = True