amulet-core 2.0a9__1.MSVC.19.43.34808.0-cp311-cp311-win_amd64.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 BlockEntityComponentData : 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>
+    BlockEntityComponentData(
+        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 BlockEntityComponentData 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->get_platform(),
+                    block_entity->get_version()))) {
+            throw std::invalid_argument(
+                "BlockEntity is incompatible with VersionRange.");
+        }
+        _block_entities.insert_or_assign(coord, std::move(block_entity));
+    }
+
+    void del(const BlockEntityChunkCoord& coord)
+    {
+        _block_entities.erase(coord);
+    }
+};
+
+class BlockEntityComponent {
+private:
+    std::optional<std::shared_ptr<BlockEntityComponentData>> _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<BlockEntityComponentData> get_block_entity();
+    AMULET_CORE_EXPORT void set_block_entity(std::shared_ptr<BlockEntityComponentData> component);
+};
+}

amulet/core/chunk/component/section_array_map.hpp

@@ -0,0 +1,129 @@
+#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/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; }
+    const size_t& get_size() const { return _size; }
+    std::uint32_t* get_buffer() const { return _buffer; }
+    std::span<std::uint32_t> get_span() const { 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<IndexArray3D>> get_default_array() const
+    {
+        return _default_array;
+    }
+
+    void set_default_array(std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> default_array)
+    {
+        validate_array_shape(default_array);
+        _default_array = std::move(default_array);
+    }
+
+    const std::unordered_map<std::int64_t, std::shared_ptr<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) 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));
+    }
+
+    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,77 @@
+from __future__ import annotations
+
+import collections.abc
+import types
+import typing
+
+import numpy
+import numpy.typing
+import typing_extensions
+
+__all__ = ["IndexArray3D", "SectionArrayMap"]
+
+class IndexArray3D:
+    """
+    A 3D index array.
+    """
+
+    @typing.overload
+    def __init__(self, shape: tuple[int, int, int]) -> None: ...
+    @typing.overload
+    def __init__(self, shape: tuple[int, int, int], value: int) -> None: ...
+    @typing.overload
+    def __init__(self, other: IndexArray3D) -> None: ...
+    @typing.overload
+    def __init__(self, arg0: typing_extensions.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: int) -> bool: ...
+    def __delitem__(self, arg0: int) -> None: ...
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __getitem__(self, arg0: int) -> numpy.typing.NDArray[numpy.uint32]: ...
+    def __hash__(self) -> int: ...
+    def __init__(
+        self,
+        array_shape: tuple[int, int, int],
+        default_array: int | IndexArray3D | typing_extensions.Buffer,
+    ) -> None: ...
+    def __iter__(self) -> collections.abc.Iterator[int]: ...
+    def __len__(self) -> int: ...
+    def __setitem__(
+        self, arg0: int, arg1: IndexArray3D | typing_extensions.Buffer
+    ) -> None: ...
+    def get(
+        self, key: int, default: numpy.typing.NDArray[numpy.uint32] | None = None
+    ) -> numpy.typing.NDArray[numpy.uint32] | None: ...
+    def items(
+        self,
+    ) -> collections.abc.ItemsView[int, numpy.typing.NDArray[numpy.uint32]]: ...
+    def keys(self) -> collections.abc.KeysView[int]: ...
+    def pop(
+        self, key: int, default: numpy.typing.NDArray[numpy.uint32] = ...
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    def popitem(self) -> tuple[int, numpy.typing.NDArray[numpy.uint32]]: ...
+    def populate(self, arg0: int) -> None: ...
+    def setdefault(
+        self, arg0: int, arg1: numpy.typing.NDArray[numpy.uint32] | None
+    ) -> numpy.typing.NDArray[numpy.uint32] | None: ...
+    def update(self, other: typing.Any = (), **kwargs: typing.Any) -> 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: int | IndexArray3D | typing_extensions.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__ = ["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/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__ = ["BiomePalette", "BlockPalette", "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/core/palette/biome_palette.pyi

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import amulet.core.biome
+import amulet.core.version
+
+__all__ = ["BiomePalette"]
+
+class BiomePalette(amulet.core.version.VersionRangeContainer):
+    @typing.overload
+    def __contains__(self, arg0: int) -> bool: ...
+    @typing.overload
+    def __contains__(self, arg0: amulet.core.biome.Biome) -> bool: ...
+    @typing.overload
+    def __getitem__(self, arg0: int) -> amulet.core.biome.Biome: ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> list: ...
+    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.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: typing.Any) -> int: ...
+    def index(
+        self, value: typing.Any, start: int = 0, stop: int = 9223372036854775807
+    ) -> int: ...
+    def index_to_biome(self, arg0: int) -> 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.
+        """