amulet-core 2.0.1a2.post250529084552__cp312-cp312-macosx_10_15_universal2.whl

amulet/core/palette/block_palette.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <map>
+#include <stdexcept>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/core/block/block.hpp>
+#include <amulet/core/dll.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+
+class BlockPalette : public VersionRangeContainer {
+private:
+    std::vector<BlockStack> _index_to_block;
+    std::map<BlockStack, size_t> _block_to_index;
+
+public:
+    const std::vector<BlockStack>& get_blocks() const { return _index_to_block; }
+
+    template <typename VersionRangeT>
+    BlockPalette(VersionRangeT&& version_range)
+        : VersionRangeContainer(std::forward<VersionRangeT>(version_range))
+        , _index_to_block()
+        , _block_to_index()
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BlockPalette deserialise(BinaryReader&);
+
+    bool operator==(const BlockPalette& other) const
+    {
+        return _index_to_block == other._index_to_block;
+    }
+
+    size_t size() const { return _index_to_block.size(); }
+
+    const BlockStack& index_to_block_stack(size_t index) const
+    {
+        return _index_to_block.at(index);
+    }
+
+    size_t block_stack_to_index(const BlockStack& block_stack)
+    {
+        auto it = _block_to_index.find(block_stack);
+        if (it != _block_to_index.end()) {
+            return it->second;
+        }
+        auto version_range = get_version_range();
+        for (const auto& block : block_stack.get_blocks()) {
+            if (!version_range.contains(block.get_platform(), block.get_version())) {
+                throw std::invalid_argument(
+                    "BlockStack(\"" + block.get_platform() + "\", " + block.get_version().toString() + ") is incompatible with VersionRange(\"" + version_range.get_platform() + "\", " + version_range.get_min_version().toString() + ", " + version_range.get_max_version().toString() + ").");
+            }
+        }
+        size_t index = _index_to_block.size();
+        _index_to_block.push_back(block_stack);
+        _block_to_index.emplace(block_stack, index);
+        return index;
+    }
+
+    bool contains_block(const BlockStack& block) const
+    {
+        return _block_to_index.contains(block);
+    }
+};
+
+}

amulet/core/palette/block_palette.pyi

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import amulet.core.block
+import amulet.core.version
+
+__all__ = ["BlockPalette"]
+
+class BlockPalette(amulet.core.version.VersionRangeContainer):
+    @typing.overload
+    def __contains__(self, arg0: int) -> bool: ...
+    @typing.overload
+    def __contains__(self, arg0: amulet.core.block.BlockStack) -> bool: ...
+    @typing.overload
+    def __getitem__(self, arg0: int) -> amulet.core.block.BlockStack: ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> list: ...
+    def __init__(self, arg0: amulet.core.version.VersionRange) -> None: ...
+    def __iter__(self) -> collections.abc.Iterator[amulet.core.block.BlockStack]: ...
+    def __len__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __reversed__(
+        self,
+    ) -> collections.abc.Iterator[amulet.core.block.BlockStack]: ...
+    def block_stack_to_index(self, arg0: amulet.core.block.BlockStack) -> int:
+        """
+        Get the index of the block stack in the palette.
+        If it is not in the palette already it will be added first.
+
+        :param block_stack: The block stack to get the index of.
+        :return: The index of the block stack in the palette.
+        """
+
+    def count(self, value: typing.Any) -> int: ...
+    def index(
+        self, value: typing.Any, start: int = 0, stop: int = 9223372036854775807
+    ) -> int: ...
+    def index_to_block_stack(self, arg0: int) -> amulet.core.block.BlockStack:
+        """
+        Get the block stack at the specified palette index.
+
+        :param index: The index to get
+        :return: The block stack at that index
+        :raises IndexError if there is no block stack at that index.
+        """

amulet/core/selection/__init__.pyi

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from amulet.core.selection.box import SelectionBox
+from amulet.core.selection.group import SelectionGroup
+
+from . import box, group
+
+__all__ = ["SelectionBox", "SelectionGroup", "box", "group"]

amulet/core/selection/box.hpp

@@ -0,0 +1,86 @@
+#pragma once
+#include <array>
+#include <cstdint>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+class SelectionGroup;
+
+// The SelectionBox class represents a single cuboid selection.
+class SelectionBox {
+private:
+    std::int64_t _min_x;
+    std::int64_t _min_y;
+    std::int64_t _min_z;
+    std::uint64_t _size_x;
+    std::uint64_t _size_y;
+    std::uint64_t _size_z;
+
+public:
+    SelectionBox(
+        std::int64_t min_x,
+        std::int64_t min_y,
+        std::int64_t min_z,
+        std::uint64_t size_x,
+        std::uint64_t size_y,
+        std::uint64_t size_z)
+        : _min_x(min_x)
+        , _min_y(min_y)
+        , _min_z(min_z)
+        , _size_x(size_x)
+        , _size_y(size_y)
+        , _size_z(size_z)
+    {
+    }
+
+    SelectionBox(
+        std::array<std::int64_t, 3> point_1,
+        std::array<std::int64_t, 3> point_2)
+    {
+        _min_x = std::min(point_1[0], point_2[0]);
+        _min_y = std::min(point_1[1], point_2[1]);
+        _min_z = std::min(point_1[2], point_2[2]);
+        _size_x = std::max(point_1[0], point_2[0]) - _min_x;
+        _size_y = std::max(point_1[1], point_2[1]) - _min_y;
+        _size_z = std::max(point_1[2], point_2[2]) - _min_z;
+    }
+
+    // Accessors
+    std::int64_t min_x() const { return _min_x; }
+    std::int64_t min_y() const { return _min_y; }
+    std::int64_t min_z() const { return _min_z; }
+    std::int64_t max_x() const { return _min_x + _size_x; }
+    std::int64_t max_y() const { return _min_y + _size_y; }
+    std::int64_t max_z() const { return _min_z + _size_z; }
+    std::array<std::int64_t, 3> min() const { return { _min_x, _min_y, _min_z }; }
+    std::array<std::int64_t, 3> max() const { return { max_x(), max_y(), max_z() }; }
+
+    // Shape and volume
+    std::uint64_t size_x() const { return _size_x; }
+    std::uint64_t size_y() const { return _size_y; }
+    std::uint64_t size_z() const { return _size_z; }
+    std::array<std::uint64_t, 3> shape() const { return { _size_x, _size_y, _size_z }; }
+    size_t volume() const { return _size_x * _size_y * _size_z; }
+
+    // Contains and intersects
+    AMULET_CORE_EXPORT bool contains_block(std::int64_t x, std::int64_t y, std::int64_t z) const;
+    AMULET_CORE_EXPORT bool contains_point(double x, double y, double z) const;
+    AMULET_CORE_EXPORT bool contains_box(const SelectionBox& other) const;
+    AMULET_CORE_EXPORT bool intersects(const SelectionBox& other) const;
+    AMULET_CORE_EXPORT bool intersects(const SelectionGroup& other) const;
+    AMULET_CORE_EXPORT bool touches_or_intersects(const SelectionBox& other) const;
+    AMULET_CORE_EXPORT bool touches(const SelectionBox& other) const;
+
+    // Transform
+    AMULET_CORE_EXPORT SelectionBox translate(std::int64_t dx, std::int64_t dy, std::int64_t dz) const;
+    // AMULET_CORE_EXPORT SelectionGroup transform() const;
+
+    // Operators
+    auto operator<=>(const SelectionBox&) const = default;
+};
+
+} // namespace Amulet
+
+#include "group.hpp"

amulet/core/selection/box.pyi

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.core.selection.group
+
+__all__ = ["SelectionBox"]
+
+class SelectionBox:
+    """
+    The SelectionBox class represents a single cuboid selection.
+
+    When combined with :class:`~amulet.api.selection.SelectionGroup` it can represent any arbitrary shape.
+    """
+
+    @typing.overload
+    def __eq__(self, arg0: SelectionBox) -> bool: ...
+    @typing.overload
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __ge__(self, arg0: SelectionBox) -> bool: ...
+    def __gt__(self, arg0: SelectionBox) -> bool: ...
+    def __hash__(self) -> int: ...
+    @typing.overload
+    def __init__(
+        self, min_x: int, min_y: int, min_z: int, size_x: int, size_y: int, size_z: int
+    ) -> None:
+        """
+        Construct a new SelectionBox instance.
+
+        >>> # a selection box that selects one block.
+        >>> box = SelectionBox(0, 0, 0, 1, 1, 1)
+
+        :param min_x: The minimum x coordinate of the box.
+        :param min_y: The minimum y coordinate of the box.
+        :param min_z: The minimum z coordinate of the box.
+        :param size_x: The size of the box in the x axis.
+        :param size_y: The size of the box in the y axis.
+        :param size_z: The size of the box in the z axis.
+        """
+
+    @typing.overload
+    def __init__(
+        self, point_1: tuple[int, int, int], point_2: tuple[int, int, int]
+    ) -> None:
+        """
+        Construct a new SelectionBox instance.
+
+        >>> # a selection box that selects one block.
+        >>> box = SelectionBox((0, 0, 0), (1, 1, 1))
+
+        :param point_1: The first coordinate of the box.
+        :param point_2: The second coordinate of the box.
+        """
+
+    def __le__(self, arg0: SelectionBox) -> bool: ...
+    def __lt__(self, arg0: SelectionBox) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def contains_block(self, x: int, y: int, z: int) -> bool:
+        """
+        Is the block contained within the selection.
+
+        >>> selection1: AbstractBaseSelection
+        >>> (1, 2, 3) in selection1
+        True
+
+        :param x: The x coordinate of the block. Defined by the most negative corner.
+        :param y: The y coordinate of the block. Defined by the most negative corner.
+        :param z: The z coordinate of the block. Defined by the most negative corner.
+        :return: True if the block is in the selection.
+        """
+
+    def contains_box(self, other: SelectionBox) -> bool:
+        """
+        Does the other SelectionBox other fit entirely within this SelectionBox.
+
+        :param other: The SelectionBox to test.
+        :return: True if other fits in self, False otherwise.
+        """
+
+    def contains_point(self, x: float, y: float, z: float) -> bool:
+        """
+        Is the point contained within the selection.
+
+        >>> selection1: AbstractBaseSelection
+        >>> (1.5, 2.5, 3.5) in selection1
+        True
+
+        :param x: The x coordinate of the point.
+        :param y: The y coordinate of the point.
+        :param z: The z coordinate of the point.
+        :return: True if the point is in the selection.
+        """
+
+    @typing.overload
+    def intersects(self, other: SelectionBox) -> bool:
+        """
+        Does this selection intersect ``other``.
+
+        :param other: The other selection.
+        :return: True if the selections intersect, False otherwise.
+        """
+
+    @typing.overload
+    def intersects(self, other: amulet.core.selection.group.SelectionGroup) -> bool: ...
+    def touches(self, other: SelectionBox) -> bool:
+        """
+        Method to check if this instance of :class:`SelectionBox` touches but does not intersect another SelectionBox.
+
+        :param other: The other SelectionBox
+        :return: True if the two :class:`SelectionBox` instances touch, False otherwise
+        """
+
+    def touches_or_intersects(self, other: SelectionBox) -> bool:
+        """
+        Does this SelectionBox touch or intersect the other SelectionBox.
+
+        :param other: The other SelectionBox.
+        :return: True if the two :class:`SelectionBox` instances touch or intersect, False otherwise.
+        """
+
+    def translate(self, x: int, y: int, z: int) -> SelectionBox:
+        """
+        Create a new :class:`SelectionBox` based on this one with the coordinates moved by the given offset.
+
+        :param x: The x offset.
+        :param y: The y offset.
+        :param z: The z offset.
+        :return: The new selection with the given offset.
+        """
+
+    @property
+    def max(self) -> tuple[int, int, int]:
+        """
+        The maximum coordinate of the box.
+        """
+
+    @property
+    def max_x(self) -> int:
+        """
+        The maximum x coordinate of the box.
+        """
+
+    @property
+    def max_y(self) -> int:
+        """
+        The maximum y coordinate of the box.
+        """
+
+    @property
+    def max_z(self) -> int:
+        """
+        The maximum z coordinate of the box.
+        """
+
+    @property
+    def min(self) -> tuple[int, int, int]:
+        """
+        The minimum coordinate of the box.
+        """
+
+    @property
+    def min_x(self) -> int:
+        """
+        The minimum x coordinate of the box.
+        """
+
+    @property
+    def min_y(self) -> int:
+        """
+        The minimum y coordinate of the box.
+        """
+
+    @property
+    def min_z(self) -> int:
+        """
+        The minimum z coordinate of the box.
+        """
+
+    @property
+    def shape(self) -> tuple[int, int, int]:
+        """
+        The length of the box in the x, y and z axis.
+
+        >>> SelectionBox(0, 0, 0, 1, 1, 1).shape
+        (1, 1, 1)
+        """
+
+    @property
+    def size_x(self) -> int:
+        """
+        The length of the box in the x axis.
+        """
+
+    @property
+    def size_y(self) -> int:
+        """
+        The length of the box in the y axis.
+        """
+
+    @property
+    def size_z(self) -> int:
+        """
+        The length of the box in the z axis.
+        """
+
+    @property
+    def volume(self) -> int:
+        """
+        The number of blocks in the box.
+
+        >>> SelectionBox(0, 0, 0, 1, 1, 1).volume
+        1
+        """

amulet/core/selection/group.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <array>
+#include <concepts>
+#include <ranges>
+#include <set>
+
+#include <amulet/core/dll.hpp>
+
+#include "box.hpp"
+
+namespace Amulet {
+
+class SelectionBox;
+
+class SelectionGroup {
+private:
+    std::set<SelectionBox> _boxes;
+
+public:
+    // Constructors
+    SelectionGroup() {};
+    SelectionGroup(const SelectionBox& box)
+    {
+        _boxes.insert(box);
+    }
+
+    template <typename Iterable>
+        requires std::ranges::input_range<Iterable> && std::convertible_to<std::ranges::range_value_t<Iterable>, const SelectionBox&>
+    SelectionGroup(const Iterable& boxes)
+    {
+        for (const SelectionBox& box : boxes) {
+            _boxes.emplace(box);
+        }
+    }
+
+    // Accessors
+    const std::set<SelectionBox>& selection_boxes() const
+    {
+        return _boxes;
+    }
+    size_t size() const
+    {
+        return _boxes.size();
+    }
+
+    // Bounds
+    AMULET_CORE_EXPORT std::int64_t min_x() const;
+    AMULET_CORE_EXPORT std::int64_t min_y() const;
+    AMULET_CORE_EXPORT std::int64_t min_z() const;
+    AMULET_CORE_EXPORT std::int64_t max_x() const;
+    AMULET_CORE_EXPORT std::int64_t max_y() const;
+    AMULET_CORE_EXPORT std::int64_t max_z() const;
+    AMULET_CORE_EXPORT std::array<std::int64_t, 3> min() const;
+    AMULET_CORE_EXPORT std::array<std::int64_t, 3> max() const;
+    AMULET_CORE_EXPORT std::pair<
+        std::array<std::int64_t, 3>,
+        std::array<std::int64_t, 3>>
+    bounds() const;
+    AMULET_CORE_EXPORT SelectionBox bounding_box() const;
+
+    // Contains and intersects
+    AMULET_CORE_EXPORT bool contains_block(std::int64_t x, std::int64_t y, std::int64_t z) const;
+    AMULET_CORE_EXPORT bool contains_point(double x, double y, double z) const;
+    AMULET_CORE_EXPORT bool intersects(const SelectionBox& other) const;
+    AMULET_CORE_EXPORT bool intersects(const SelectionGroup& other) const;
+
+    // Transform
+    AMULET_CORE_EXPORT SelectionGroup translate(std::int64_t dx, std::int64_t dy, std::int64_t dz) const;
+
+    // Operators
+    operator bool() const
+    {
+        return !_boxes.empty();
+    }
+    bool operator==(const SelectionGroup& rhs) const = default;
+    bool operator!=(const SelectionGroup& rhs) const = default;
+};
+
+}