amulet-core 2.0.7a0__cp312-cp312-macosx_10_15_universal2.whl

amulet/core/chunk/component/block_entity_component.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+#include <tuple>
+
+#include <amulet/core/block_entity/block_entity.hpp>
+#include <amulet/core/dll.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+typedef std::tuple<std::uint16_t, std::int64_t, std::uint16_t> BlockEntityChunkCoord;
+class BlockEntityStorage : public VersionRangeContainer {
+private:
+    std::uint16_t _x_size;
+    std::uint16_t _z_size;
+    std::map<
+        BlockEntityChunkCoord,
+        std::shared_ptr<BlockEntity>>
+        _block_entities;
+
+public:
+    template <typename VersionRangeT>
+    BlockEntityStorage(
+        VersionRangeT&& version_range,
+        std::uint16_t x_size,
+        std::uint16_t z_size)
+        : VersionRangeContainer(std::forward<VersionRangeT>(version_range))
+        , _x_size(x_size)
+        , _z_size(z_size)
+        , _block_entities()
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BlockEntityStorage deserialise(BinaryReader&);
+
+    std::uint16_t get_x_size() const { return _x_size; }
+    std::uint16_t get_z_size() const { return _z_size; }
+
+    const std::map<BlockEntityChunkCoord, std::shared_ptr<BlockEntity>>&
+    get_block_entities() const
+    {
+        return _block_entities;
+    }
+
+    size_t get_size() const { return _block_entities.size(); }
+
+    bool contains(
+        const BlockEntityChunkCoord& coord) const
+    {
+        return _block_entities.contains(coord);
+    }
+
+    std::shared_ptr<BlockEntity> get(
+        const BlockEntityChunkCoord& coord) const
+    {
+        return _block_entities.at(coord);
+    }
+
+    template <typename BlockEntityT>
+    void set(
+        const BlockEntityChunkCoord& coord,
+        BlockEntityT&& block_entity)
+    {
+        std::shared_ptr<BlockEntity> block_entity_ptr;
+        if constexpr (std::is_same_v<std::shared_ptr<BlockEntity>, std::decay_t<BlockEntityT>>) {
+            block_entity_ptr = std::forward<BlockEntityT>(block_entity);
+        } else {
+            block_entity_ptr = std::make_shared<BlockEntity>(block_entity);
+        }
+
+        if (
+            std::get<0>(coord) < 0 || std::get<2>(coord) < 0 || _x_size <= std::get<0>(coord) || _z_size <= std::get<2>(coord)) {
+            throw std::invalid_argument(
+                "Coord must be 0 <= " + std::to_string(std::get<0>(coord)) + " < " + std::to_string(_x_size) + "and 0 <= " + std::to_string(std::get<1>(coord)) + " < " + std::to_string(_z_size));
+        }
+        if (!(
+                get_version_range().contains(
+                    block_entity_ptr->get_platform(),
+                    block_entity_ptr->get_version()))) {
+            throw std::invalid_argument(
+                "BlockEntity is incompatible with VersionRange.");
+        }
+        _block_entities.insert_or_assign(coord, std::move(block_entity_ptr));
+    }
+
+    void del(const BlockEntityChunkCoord& coord)
+    {
+        _block_entities.erase(coord);
+    }
+};
+
+class BlockEntityComponent {
+private:
+    std::optional<std::shared_ptr<BlockEntityStorage>> _value;
+
+protected:
+    // Null constructor
+    BlockEntityComponent() = default;
+    // Default constructor
+    AMULET_CORE_EXPORT void init(
+        const VersionRange& version_range,
+        std::uint16_t x_size,
+        std::uint16_t z_size);
+
+    // Serialise the component data
+    AMULET_CORE_EXPORT std::optional<std::string> serialise() const;
+    // Deserialise the component
+    AMULET_CORE_EXPORT void deserialise(std::optional<std::string>);
+
+public:
+    AMULET_CORE_EXPORT static const std::string ComponentID;
+    AMULET_CORE_EXPORT std::shared_ptr<BlockEntityStorage> get_block_entities();
+    AMULET_CORE_EXPORT void set_block_entities(std::shared_ptr<BlockEntityStorage> component);
+};
+}

amulet/core/chunk/component/section_array_map.hpp

@@ -0,0 +1,178 @@
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/utils/view/map_view.hpp>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+typedef std::tuple<std::uint16_t, std::uint16_t, std::uint16_t> SectionShape;
+
+class IndexArray3D {
+private:
+    SectionShape _shape;
+    size_t _size;
+    std::uint32_t* _buffer;
+
+public:
+    AMULET_CORE_EXPORT IndexArray3D(const SectionShape& shape);
+    AMULET_CORE_EXPORT IndexArray3D(const SectionShape& shape, std::uint32_t value);
+
+    AMULET_CORE_EXPORT IndexArray3D(const IndexArray3D& other);
+    AMULET_CORE_EXPORT IndexArray3D(IndexArray3D&& other) noexcept;
+    AMULET_CORE_EXPORT IndexArray3D& operator=(const IndexArray3D& other);
+    AMULET_CORE_EXPORT IndexArray3D& operator=(IndexArray3D&& other) noexcept;
+
+    AMULET_CORE_EXPORT ~IndexArray3D();
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static IndexArray3D deserialise(BinaryReader&);
+
+    const SectionShape& get_shape() const { return _shape; }
+    size_t get_size() const { return _size; }
+    std::uint32_t* get_buffer() { return _buffer; }
+    const std::uint32_t* get_buffer() const { return _buffer; }
+    std::span<std::uint32_t> get_span() { return { _buffer, _size }; }
+};
+
+class SectionArrayMap {
+private:
+    SectionShape _array_shape;
+    std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> _default_array;
+    std::unordered_map<std::int64_t, std::shared_ptr<IndexArray3D>> _arrays;
+
+    void validate_array_shape(const IndexArray3D& array)
+    {
+        if (_array_shape != array.get_shape()) {
+            throw std::invalid_argument("Array shape does not match stored shape.");
+        }
+    }
+
+    void validate_array_shape(
+        const std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>>& array)
+    {
+        if (auto* arr = std::get_if<std::shared_ptr<IndexArray3D>>(&array)) {
+            return validate_array_shape(**arr);
+        }
+    }
+
+public:
+    template <typename DefaultArrayT>
+    SectionArrayMap(
+        const SectionShape& array_shape,
+        DefaultArrayT&& default_array)
+        : _array_shape(array_shape)
+        , _default_array(std::forward<DefaultArrayT>(default_array))
+        , _arrays()
+    {
+        validate_array_shape(_default_array);
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static SectionArrayMap deserialise(BinaryReader&);
+
+    const SectionShape& get_array_shape() const { return _array_shape; }
+
+    std::variant<std::uint32_t, std::shared_ptr<const IndexArray3D>> get_default_array() const
+    {
+        return std::visit(
+            [](auto&& arg) -> std::variant<std::uint32_t, std::shared_ptr<const IndexArray3D>> {
+                return arg;
+            },
+            _default_array);
+    }
+
+    std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> get_default_array()
+    {
+        return _default_array;
+    }
+
+    void set_default_array(std::uint32_t default_array)
+    {
+        _default_array = default_array;
+    }
+
+    void set_default_array(std::shared_ptr<IndexArray3D> default_array)
+    {
+        validate_array_shape(*default_array);
+        _default_array = std::move(default_array);
+    }
+
+    void set_default_array(const IndexArray3D& default_array)
+    {
+        validate_array_shape(default_array);
+        _default_array = std::make_shared<IndexArray3D>(default_array);
+    }
+
+    const std::unordered_map<std::int64_t, std::shared_ptr<IndexArray3D>>& get_arrays()
+    {
+        return _arrays;
+    }
+
+    const MapView<std::unordered_map<std::int64_t, std::shared_ptr<IndexArray3D>>, std::shared_ptr<const IndexArray3D>> get_arrays() const
+    {
+        return _arrays;
+    }
+
+    size_t get_size() const { return _arrays.size(); }
+
+    bool contains_section(std::int64_t cy) const
+    {
+        return _arrays.contains(cy);
+    }
+
+    std::shared_ptr<IndexArray3D> get_section(std::int64_t cy)
+    {
+        return _arrays.at(cy);
+    }
+
+    std::shared_ptr<const IndexArray3D> get_section(std::int64_t cy) const
+    {
+        return _arrays.at(cy);
+    }
+
+    IndexArray3D& get_section_ref(std::int64_t cy)
+    {
+        return *_arrays.at(cy);
+    }
+
+    const IndexArray3D& get_section_ref(std::int64_t cy) const
+    {
+        return *_arrays.at(cy);
+    }
+
+    void set_section(std::int64_t cy, std::shared_ptr<IndexArray3D> section)
+    {
+        validate_array_shape(*section);
+        _arrays.insert_or_assign(cy, std::move(section));
+    }
+
+    void set_section(std::int64_t cy, const IndexArray3D& section)
+    {
+        validate_array_shape(section);
+        _arrays.insert_or_assign(cy, std::make_shared<IndexArray3D>(section));
+    }
+
+    AMULET_CORE_EXPORT void populate_section(std::int64_t cy);
+
+    void del_section(std::int64_t cy)
+    {
+        _arrays.erase(cy);
+    }
+};
+
+} // namespace Amulet

amulet/core/chunk/component/section_array_map.pyi

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import collections.abc
+import types
+import typing
+
+import numpy
+import numpy.typing
+
+__all__: list[str] = ["IndexArray3D", "SectionArrayMap"]
+
+class IndexArray3D:
+    """
+    A 3D index array.
+    """
+
+    @typing.overload
+    def __init__(
+        self, shape: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]
+    ) -> None: ...
+    @typing.overload
+    def __init__(
+        self,
+        shape: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt],
+        value: typing.SupportsInt,
+    ) -> None: ...
+    @typing.overload
+    def __init__(self, other: IndexArray3D) -> None: ...
+    @typing.overload
+    def __init__(self, arg0: collections.abc.Buffer) -> None: ...
+    @property
+    def shape(self) -> tuple[int, int, int]: ...
+    @property
+    def size(self) -> int: ...
+
+class SectionArrayMap:
+    """
+    A container of sub-chunk arrays.
+    """
+
+    def __contains__(self, arg0: typing.SupportsInt) -> bool: ...
+    def __delitem__(self, arg0: typing.SupportsInt) -> None: ...
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
+    def __getitem__(
+        self, arg0: typing.SupportsInt
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    def __hash__(self) -> int: ...
+    def __init__(
+        self,
+        array_shape: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt],
+        default_array: typing.SupportsInt | IndexArray3D | collections.abc.Buffer,
+    ) -> None: ...
+    def __iter__(self) -> collections.abc.Iterator[int]: ...
+    def __len__(self) -> int: ...
+    def __setitem__(
+        self, arg0: typing.SupportsInt, arg1: IndexArray3D | collections.abc.Buffer
+    ) -> None: ...
+    @typing.overload
+    def get(
+        self, key: typing.SupportsInt
+    ) -> numpy.typing.NDArray[numpy.uint32] | None: ...
+    @typing.overload
+    def get(
+        self, key: typing.SupportsInt, default: numpy.typing.NDArray[numpy.uint32]
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    @typing.overload
+    def get[T](
+        self, key: typing.SupportsInt, default: T
+    ) -> numpy.typing.NDArray[numpy.uint32] | T: ...
+    def items(
+        self,
+    ) -> collections.abc.ItemsView[int, numpy.typing.NDArray[numpy.uint32]]: ...
+    def keys(self) -> collections.abc.KeysView[int]: ...
+    @typing.overload
+    def pop(self, key: typing.SupportsInt) -> numpy.typing.NDArray[numpy.uint32]: ...
+    @typing.overload
+    def pop(
+        self, key: typing.SupportsInt, default: numpy.typing.NDArray[numpy.uint32]
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    @typing.overload
+    def pop[T](
+        self, key: typing.SupportsInt, default: T
+    ) -> numpy.typing.NDArray[numpy.uint32] | T: ...
+    def popitem(self) -> tuple[int, numpy.typing.NDArray[numpy.uint32]]: ...
+    def populate(self, arg0: typing.SupportsInt) -> None: ...
+    @typing.overload
+    def setdefault(
+        self, key: typing.SupportsInt
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    @typing.overload
+    def setdefault(
+        self, key: typing.SupportsInt, default: numpy.typing.NDArray[numpy.uint32]
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    def update(
+        self,
+        other: (
+            collections.abc.Mapping[int, numpy.typing.NDArray[numpy.uint32]]
+            | collections.abc.Iterable[tuple[int, numpy.typing.NDArray[numpy.uint32]]]
+        ) = (),
+        **kwargs: numpy.typing.NDArray[numpy.uint32],
+    ) -> None: ...
+    def values(
+        self,
+    ) -> collections.abc.ValuesView[numpy.typing.NDArray[numpy.uint32]]: ...
+    @property
+    def array_shape(self) -> tuple[int, int, int]: ...
+    @property
+    def default_array(self) -> int | numpy.ndarray: ...
+    @default_array.setter
+    def default_array(
+        self, arg1: typing.SupportsInt | IndexArray3D | collections.abc.Buffer
+    ) -> None: ...

amulet/core/dll.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef AMULET_CORE_EXPORT
+    #if defined(WIN32) || defined(_WIN32)
+        #ifdef ExportAmuletCore
+            #define AMULET_CORE_EXPORT __declspec(dllexport)
+        #else
+            #define AMULET_CORE_EXPORT __declspec(dllimport)
+        #endif
+    #else
+        #define AMULET_CORE_EXPORT
+    #endif
+#endif
+
+#if !defined(AMULET_CORE_EXPORT_EXCEPTION)
+    #if defined(_LIBCPP_EXCEPTION)
+        #define AMULET_CORE_EXPORT_EXCEPTION __attribute__((visibility("default")))
+    #else
+        #define AMULET_CORE_EXPORT_EXCEPTION
+    #endif
+#endif

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__: list[str] = ["Entity"]
+
+class Entity(amulet.core.version.PlatformVersionContainer):
+    """
+    A class to contain all the data to define an Entity.
+    """
+
+    @typing.overload
+    def __eq__(self, other: Entity) -> bool: ...
+    @typing.overload
+    def __eq__(self, other: 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: typing.SupportsFloat,
+        y: typing.SupportsFloat,
+        z: typing.SupportsFloat,
+        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: typing.SupportsFloat) -> None: ...
+    @property
+    def y(self) -> float:
+        """
+        The y coordinate of the entity.
+        """
+
+    @y.setter
+    def y(self, arg1: typing.SupportsFloat) -> None: ...
+    @property
+    def z(self) -> float:
+        """
+        The z coordinate of the entity.
+        """
+
+    @z.setter
+    def z(self, arg1: typing.SupportsFloat) -> 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/core/palette/__init__.pyi

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from amulet.core.palette.biome_palette import BiomePalette
+from amulet.core.palette.block_palette import BlockPalette
+
+from . import biome_palette, block_palette
+
+__all__: list[str] = ["BiomePalette", "BlockPalette", "biome_palette", "block_palette"]