amulet-core 2.0a7__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp312-cp312-win_amd64.whl

amulet/core/entity/__init__.pyi

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.core.version
+import amulet.nbt
+
+__all__ = ["Entity"]
+
+class Entity(amulet.core.version.PlatformVersionContainer):
+    """
+    A class to contain all the data to define an Entity.
+    """
+
+    @typing.overload
+    def __eq__(self, arg0: Entity) -> bool: ...
+    @typing.overload
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __hash__(self) -> int: ...
+    def __init__(
+        self,
+        platform: str,
+        version: amulet.core.version.VersionNumber,
+        namespace: str,
+        base_name: str,
+        x: float,
+        y: float,
+        z: float,
+        nbt: amulet.nbt.NamedTag,
+    ) -> None: ...
+    def __repr__(self) -> str: ...
+    @property
+    def base_name(self) -> str:
+        """
+        The base name of the entity represented by the :class:`Entity` object.
+
+        >>> entity: Entity
+        >>> entity.base_name
+
+        :return: The base name of the entity
+        """
+
+    @base_name.setter
+    def base_name(self, arg1: str) -> None: ...
+    @property
+    def namespace(self) -> str:
+        """
+        The namespace of the entity represented by the :class:`Entity` object.
+
+        >>> entity: Entity
+        >>> entity.namespace
+
+        :return: The namespace of the entity
+        """
+
+    @namespace.setter
+    def namespace(self, arg1: str) -> None: ...
+    @property
+    def namespaced_name(self) -> str:
+        """
+        The namespace:base_name of the entity represented by the :class:`Entity` object.
+
+        >>> entity: Entity
+        >>> entity.namespaced_name
+
+        :return: The namespace:base_name of the entity
+        """
+
+    @property
+    def nbt(self) -> amulet.nbt.NamedTag:
+        """
+        The nbt data for the entity.
+        >>> entity: Entity
+        >>> entity.nbt
+
+        :return: The NamedTag of the entity
+        """
+
+    @nbt.setter
+    def nbt(self, arg1: amulet.nbt.NamedTag) -> None: ...
+    @property
+    def x(self) -> float:
+        """
+        The x coordinate of the entity.
+        """
+
+    @x.setter
+    def x(self, arg1: float) -> None: ...
+    @property
+    def y(self) -> float:
+        """
+        The y coordinate of the entity.
+        """
+
+    @y.setter
+    def y(self, arg1: float) -> None: ...
+    @property
+    def z(self) -> float:
+        """
+        The z coordinate of the entity.
+        """
+
+    @z.setter
+    def z(self, arg1: float) -> None: ...

amulet/core/entity/entity.hpp

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <variant>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/nbt/tag/eq.hpp>
+#include <amulet/nbt/tag/named_tag.hpp>
+
+#include <amulet/core/dll.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+
+class Entity : public PlatformVersionContainer {
+private:
+    std::string _namespace;
+    std::string _base_name;
+    std::shared_ptr<Amulet::NBT::NamedTag> _nbt;
+    double _x;
+    double _y;
+    double _z;
+
+public:
+    const std::string& get_namespace() const { return _namespace; }
+
+    template <typename NamespaceT>
+    void set_namespace(NamespaceT&& namespace_) { _namespace = std::forward<NamespaceT>(namespace_); }
+
+    const std::string& get_base_name() const { return _base_name; }
+
+    template <typename BaseNameT>
+    void set_base_name(BaseNameT&& base_name) { _base_name = std::forward<BaseNameT>(base_name); }
+
+    std::shared_ptr<Amulet::NBT::NamedTag> get_nbt() const { return _nbt; }
+
+    template <typename NBTT>
+    void set_nbt(NBTT&& nbt)
+    {
+        if constexpr (std::is_same_v<std::shared_ptr<Amulet::NBT::NamedTag>, std::decay_t<NBTT>>) {
+            _nbt = std::forward<NBTT>(nbt);
+        } else {
+            _nbt = std::make_shared<Amulet::NBT::NamedTag>(std::forward<NBTT>(nbt));
+        }
+    }
+
+    double get_x() const { return _x; }
+
+    double get_y() const { return _y; }
+
+    double get_z() const { return _z; }
+
+    void set_x(double x) { _x = x; }
+
+    void set_y(double y) { _y = y; }
+
+    void set_z(double z) { _z = z; }
+
+    template <
+        typename PlatformT,
+        typename VersionNumberT,
+        typename NamespaceT,
+        typename BaseNameT,
+        typename NBTT>
+    Entity(
+        PlatformT&& platform,
+        VersionNumberT&& version,
+        NamespaceT&& namespace_,
+        BaseNameT&& base_name,
+        double x,
+        double y,
+        double z,
+        NBTT&& nbt)
+        : PlatformVersionContainer(std::forward<PlatformT>(platform), std::forward<VersionNumberT>(version))
+        , _namespace(std::forward<NamespaceT>(namespace_))
+        , _base_name(std::forward<BaseNameT>(base_name))
+        , _nbt(
+              [&nbt]() {
+                  if constexpr (std::is_same_v<std::shared_ptr<Amulet::NBT::NamedTag>, NBTT>) {
+                      return std::forward<NBTT>(nbt);
+                  } else {
+                      return std::make_shared<Amulet::NBT::NamedTag>(std::forward<NBTT>(nbt));
+                  }
+              }())
+        , _x(x)
+        , _y(y)
+        , _z(z)
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static Entity deserialise(BinaryReader&);
+
+    AMULET_CORE_EXPORT bool operator==(const Entity& other) const;
+};
+
+} // namespace Amulet

amulet/{palette → core/palette}/__init__.pyi

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from amulet.palette.biome_palette import BiomePalette
-from amulet.palette.block_palette import BlockPalette
+from amulet.core.palette.biome_palette import BiomePalette
+from amulet.core.palette.block_palette import BlockPalette
 
 from . import biome_palette, block_palette
 

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/{palette → core/palette}/biome_palette.pyi

@@ -3,26 +3,26 @@ from __future__ import annotations
 import collections.abc
 import typing
 
-import amulet.biome
-import amulet.version
+import amulet.core.biome
+import amulet.core.version
 
 __all__ = ["BiomePalette"]
 
-class BiomePalette(amulet.version.VersionRangeContainer):
+class BiomePalette(amulet.core.version.VersionRangeContainer):
     @typing.overload
     def __contains__(self, arg0: int) -> bool: ...
     @typing.overload
-    def __contains__(self, arg0: amulet.biome.Biome) -> bool: ...
+    def __contains__(self, arg0: amulet.core.biome.Biome) -> bool: ...
     @typing.overload
-    def __getitem__(self, arg0: int) -> amulet.biome.Biome: ...
+    def __getitem__(self, arg0: int) -> amulet.core.biome.Biome: ...
     @typing.overload
     def __getitem__(self, arg0: slice) -> list: ...
-    def __init__(self, arg0: amulet.version.VersionRange) -> None: ...
+    def __init__(self, arg0: amulet.core.version.VersionRange) -> None: ...
     def __iter__(self) -> collections.abc.Iterator[typing.Any]: ...
     def __len__(self) -> int: ...
     def __repr__(self) -> str: ...
     def __reversed__(self) -> collections.abc.Iterator[typing.Any]: ...
-    def biome_to_index(self, arg0: amulet.biome.Biome) -> int:
+    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.
@@ -35,7 +35,7 @@ class BiomePalette(amulet.version.VersionRangeContainer):
     def index(
         self, value: typing.Any, start: int = 0, stop: int = 9223372036854775807
     ) -> int: ...
-    def index_to_biome(self, arg0: int) -> amulet.biome.Biome:
+    def index_to_biome(self, arg0: int) -> amulet.core.biome.Biome:
         """
         Get the biome at the specified palette 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/{palette → core/palette}/block_palette.pyi

@@ -3,26 +3,28 @@ from __future__ import annotations
 import collections.abc
 import typing
 
-import amulet.block
-import amulet.version
+import amulet.core.block
+import amulet.core.version
 
 __all__ = ["BlockPalette"]
 
-class BlockPalette(amulet.version.VersionRangeContainer):
+class BlockPalette(amulet.core.version.VersionRangeContainer):
     @typing.overload
     def __contains__(self, arg0: int) -> bool: ...
     @typing.overload
-    def __contains__(self, arg0: amulet.block.BlockStack) -> bool: ...
+    def __contains__(self, arg0: amulet.core.block.BlockStack) -> bool: ...
     @typing.overload
-    def __getitem__(self, arg0: int) -> amulet.block.BlockStack: ...
+    def __getitem__(self, arg0: int) -> amulet.core.block.BlockStack: ...
     @typing.overload
     def __getitem__(self, arg0: slice) -> list: ...
-    def __init__(self, arg0: amulet.version.VersionRange) -> None: ...
-    def __iter__(self) -> collections.abc.Iterator[typing.Any]: ...
+    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[typing.Any]: ...
-    def block_stack_to_index(self, arg0: amulet.block.BlockStack) -> int:
+    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.
@@ -35,7 +37,7 @@ class BlockPalette(amulet.version.VersionRangeContainer):
     def index(
         self, value: typing.Any, start: int = 0, stop: int = 9223372036854775807
     ) -> int: ...
-    def index_to_block_stack(self, arg0: int) -> amulet.block.BlockStack:
+    def index_to_block_stack(self, arg0: int) -> amulet.core.block.BlockStack:
         """
         Get the block stack at the specified palette 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"