amulet-core 2.0.7a0__cp312-cp312-macosx_10_15_universal2.whl

amulet/core/palette/biome_palette.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <map>
+#include <stdexcept>
+
+#include <amulet/core/biome/biome.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+
+class BiomePalette : public VersionRangeContainer {
+private:
+    std::vector<Biome> _index_to_biome;
+    std::map<Biome, size_t> _biome_to_index;
+
+public:
+    const std::vector<Biome>& get_biomes() const { return _index_to_biome; }
+
+    template <typename VersionRangeT>
+    BiomePalette(VersionRangeT&& version_range)
+        : VersionRangeContainer(std::forward<VersionRangeT>(version_range))
+        , _index_to_biome()
+        , _biome_to_index()
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BiomePalette deserialise(BinaryReader&);
+
+    bool operator==(const BiomePalette& other) const
+    {
+        return _index_to_biome == other._index_to_biome;
+    }
+
+    size_t size() const { return _index_to_biome.size(); }
+
+    const Biome& index_to_biome(size_t index) const
+    {
+        return _index_to_biome.at(index);
+    }
+
+    size_t biome_to_index(const Biome& biome)
+    {
+        auto it = _biome_to_index.find(biome);
+        if (it != _biome_to_index.end()) {
+            return it->second;
+        }
+        const auto& version_range = get_version_range();
+        if (!version_range.contains(biome.get_platform(), biome.get_version())) {
+            throw std::invalid_argument(
+                "Biome(\"" + biome.get_platform() + "\", " + biome.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_biome.size();
+        _index_to_biome.push_back(biome);
+        _biome_to_index[biome] = index;
+        return index;
+    }
+
+    bool contains_biome(const Biome& biome) const
+    {
+        return _biome_to_index.contains(biome);
+    }
+};
+
+}

amulet/core/palette/biome_palette.pyi

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

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,52 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import amulet.core.block
+import amulet.core.version
+
+__all__: list[str] = ["BlockPalette"]
+
+class BlockPalette(amulet.core.version.VersionRangeContainer):
+    @typing.overload
+    def __contains__(self, arg0: typing.SupportsInt) -> bool: ...
+    @typing.overload
+    def __contains__(self, arg0: amulet.core.block.BlockStack) -> bool: ...
+    @typing.overload
+    def __getitem__(self, arg0: typing.SupportsInt) -> amulet.core.block.BlockStack: ...
+    @typing.overload
+    def __getitem__(self, item: slice) -> list[amulet.core.block.BlockStack]: ...
+    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: amulet.core.block.BlockStack) -> int: ...
+    def index(
+        self,
+        value: amulet.core.block.BlockStack,
+        start: typing.SupportsInt = 0,
+        stop: typing.SupportsInt = 9223372036854775807,
+    ) -> int: ...
+    def index_to_block_stack(
+        self, arg0: typing.SupportsInt
+    ) -> 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,25 @@
+from __future__ import annotations
+
+from amulet.core.selection.box import SelectionBox
+from amulet.core.selection.box_group import SelectionBoxGroup
+from amulet.core.selection.cuboid import SelectionCuboid
+from amulet.core.selection.ellipsoid import SelectionEllipsoid
+from amulet.core.selection.shape import SelectionShape
+from amulet.core.selection.shape_group import SelectionShapeGroup
+
+from . import box, box_group, cuboid, ellipsoid, shape, shape_group
+
+__all__: list[str] = [
+    "SelectionBox",
+    "SelectionBoxGroup",
+    "SelectionCuboid",
+    "SelectionEllipsoid",
+    "SelectionShape",
+    "SelectionShapeGroup",
+    "box",
+    "box_group",
+    "cuboid",
+    "ellipsoid",
+    "shape",
+    "shape_group",
+]

amulet/core/selection/box.hpp

@@ -0,0 +1,97 @@
+#pragma once
+#include <array>
+#include <cstdint>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+class Matrix4x4;
+class SelectionBoxGroup;
+
+// An axis aligned cuboid selection box.
+class AMULET_CORE_EXPORT 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;
+    }
+
+    SelectionBox(const SelectionBox& other)
+        : SelectionBox(
+              other.min_x(),
+              other.min_y(),
+              other.min_z(),
+              other.size_x(),
+              other.size_y(),
+              other.size_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 }; }
+    std::uint64_t volume() const { return _size_x * _size_y * _size_z; }
+
+    // Contains and intersects
+    bool contains_block(std::int64_t x, std::int64_t y, std::int64_t z) const;
+    bool contains_point(double x, double y, double z) const;
+    bool contains_box(const SelectionBox& other) const;
+    bool intersects(const SelectionBox& other) const;
+    bool intersects(const SelectionBoxGroup& other) const;
+    bool touches_or_intersects(const SelectionBox& other) const;
+    bool touches(const SelectionBox& other) const;
+
+    // Transform
+    SelectionBox translate(std::int64_t dx, std::int64_t dy, std::int64_t dz) const;
+    SelectionBoxGroup transform(const Matrix4x4&) const;
+
+    // Operators
+    std::strong_ordering operator<=>(const SelectionBox&) const;
+    bool operator==(const SelectionBox&) const;
+};
+
+} // namespace Amulet

amulet/core/selection/box.pyi

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.core.selection.box_group
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionBox"]
+
+class SelectionBox:
+    """
+    The SelectionBox class represents a single cuboid selection.
+
+    When combined with :class:`~amulet.api.selection.SelectionBoxGroup` it can represent any arbitrary shape.
+    """
+
+    @typing.overload
+    def __eq__(self, other: SelectionBox) -> bool: ...
+    @typing.overload
+    def __eq__(self, other: 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: typing.SupportsInt,
+        min_y: typing.SupportsInt,
+        min_z: typing.SupportsInt,
+        size_x: typing.SupportsInt,
+        size_y: typing.SupportsInt,
+        size_z: typing.SupportsInt,
+    ) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt],
+        point_2: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt],
+    ) -> 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: typing.SupportsInt, y: typing.SupportsInt, z: typing.SupportsInt
+    ) -> 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: typing.SupportsFloat, y: typing.SupportsFloat, z: typing.SupportsFloat
+    ) -> 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.box_group.SelectionBoxGroup
+    ) -> 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 transform(
+        self, matrix: amulet.utils.matrix.Matrix4x4
+    ) -> amulet.core.selection.box_group.SelectionBoxGroup:
+        """
+        Transform this box by the given transformation matrix.
+        """
+
+    def translate(
+        self, dx: typing.SupportsInt, dy: typing.SupportsInt, dz: typing.SupportsInt
+    ) -> SelectionBox:
+        """
+        Create a new :class:`SelectionBox` based on this one with the coordinates moved by the given offset.
+
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: 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/box_group.hpp

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <array>
+#include <concepts>
+#include <ranges>
+#include <set>
+
+#include <amulet/core/dll.hpp>
+
+#include "box.hpp"
+
+namespace Amulet {
+
+class AMULET_CORE_EXPORT SelectionBoxGroup {
+private:
+    std::set<SelectionBox> _boxes;
+
+public:
+    // Forwarding constructor
+    template <typename... Args>
+    SelectionBoxGroup(Args&&... args)
+        : _boxes(std::forward<Args>(args)...)
+    {
+    }
+
+    SelectionBoxGroup(std::initializer_list<SelectionBox> boxes)
+        : _boxes(boxes)
+    {
+    }
+
+    // Accessors
+    const std::set<SelectionBox>& get_boxes() const
+    {
+        return _boxes;
+    }
+    size_t count() const
+    {
+        return _boxes.size();
+    }
+    std::set<SelectionBox>::const_iterator begin() const
+    {
+        return _boxes.begin();
+    }
+    std::set<SelectionBox>::const_iterator end() const
+    {
+        return _boxes.end();
+    }
+
+    // Bounds
+    std::int64_t min_x() const;
+    std::int64_t min_y() const;
+    std::int64_t min_z() const;
+    std::int64_t max_x() const;
+    std::int64_t max_y() const;
+    std::int64_t max_z() const;
+    std::array<std::int64_t, 3> min() const;
+    std::array<std::int64_t, 3> max() const;
+    std::pair<
+        std::array<std::int64_t, 3>,
+        std::array<std::int64_t, 3>>
+    bounds() const;
+    SelectionBox bounding_box() const;
+
+    // Contains and intersects
+    bool contains_block(std::int64_t x, std::int64_t y, std::int64_t z) const;
+    bool contains_point(double x, double y, double z) const;
+    bool intersects(const SelectionBox& other) const;
+    bool intersects(const SelectionBoxGroup& other) const;
+
+    // Transform
+    SelectionBoxGroup translate(std::int64_t dx, std::int64_t dy, std::int64_t dz) const;
+    SelectionBoxGroup transform(const Matrix4x4&) const;
+
+    // Operators
+    operator bool() const
+    {
+        return !_boxes.empty();
+    }
+    std::strong_ordering operator<=>(const SelectionBoxGroup& other) const = default;
+    bool operator==(const SelectionBoxGroup& rhs) const = default;
+    bool operator!=(const SelectionBoxGroup& rhs) const = default;
+
+    operator std::set<SelectionBox>() const
+    {
+        return _boxes;
+    }
+};
+
+}