amulet-core 2.0.7a0__cp312-cp312-macosx_10_15_universal2.whl

amulet/core/block_entity/__init__.pyi

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.core.version
+import amulet.nbt
+
+__all__: list[str] = ["BlockEntity"]
+
+class BlockEntity(amulet.core.version.PlatformVersionContainer):
+    """
+    A class to contain all the data to define a BlockEntity.
+    """
+
+    @typing.overload
+    def __eq__(self, other: BlockEntity) -> 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,
+        nbt: amulet.nbt.NamedTag,
+    ) -> None: ...
+    def __repr__(self) -> str: ...
+    @property
+    def base_name(self) -> str:
+        """
+        The base name of the block entity represented by the :class:`BlockEntity` object.
+
+        >>> block_entity: BlockEntity
+        >>> block_entity.base_name
+
+        :return: The base name of the block entity
+        """
+
+    @base_name.setter
+    def base_name(self, arg1: str) -> None: ...
+    @property
+    def namespace(self) -> str:
+        """
+        The namespace of the block entity represented by the :class:`BlockEntity` object.
+
+        >>> block_entity: BlockEntity
+        >>> block_entity.namespace
+
+        :return: The namespace of the block entity
+        """
+
+    @namespace.setter
+    def namespace(self, arg1: str) -> None: ...
+    @property
+    def namespaced_name(self) -> str:
+        """
+        The namespace:base_name of the block entity represented by the :class:`BlockEntity` object.
+
+        >>> block_entity: BlockEntity
+        >>> block_entity.namespaced_name
+
+        :return: The namespace:base_name of the block entity
+        """
+
+    @property
+    def nbt(self) -> amulet.nbt.NamedTag:
+        """
+        The nbt data for the block entity.
+        >>> block_entity: BlockEntity
+        >>> block_entity.nbt
+
+        :return: The NamedTag of the block entity
+        """
+
+    @nbt.setter
+    def nbt(self, arg1: amulet.nbt.NamedTag) -> None: ...

amulet/core/block_entity/block_entity.hpp

@@ -0,0 +1,84 @@
+#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 BlockEntity : public PlatformVersionContainer {
+private:
+    std::string _namespace;
+    std::string _base_name;
+    std::shared_ptr<Amulet::NBT::NamedTag> _nbt;
+
+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));
+        }
+    }
+
+    template <
+        typename PlatformT,
+        typename VersionNumberT,
+        typename NamespaceT,
+        typename BaseNameT>
+    BlockEntity(
+        PlatformT&& platform,
+        VersionNumberT&& version,
+        NamespaceT&& namespace_,
+        BaseNameT&& base_name,
+        std::shared_ptr<Amulet::NBT::NamedTag> nbt)
+        : PlatformVersionContainer(std::forward<PlatformT>(platform), std::forward<VersionNumberT>(version))
+        , _namespace(std::forward<NamespaceT>(namespace_))
+        , _base_name(std::forward<BaseNameT>(base_name))
+        , _nbt(std::move(nbt))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BlockEntity deserialise(BinaryReader&);
+
+    AMULET_CORE_EXPORT bool operator==(const BlockEntity& other) const;
+};
+}

amulet/core/chunk/__init__.pyi

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from . import component
+
+__all__: list[str] = [
+    "Chunk",
+    "ChunkDoesNotExist",
+    "ChunkLoadError",
+    "component",
+    "get_null_chunk",
+]
+
+class Chunk:
+    """
+    A base class for all chunk classes.
+    """
+
+    def reconstruct_chunk(self, arg0: dict[str, bytes | None]) -> None:
+        """
+        This is private. Do not use this. It will be removed in the future.
+        """
+
+    def serialise_chunk(self) -> dict[str, bytes | None]:
+        """
+        This is private. Do not use this. It will be removed in the future.
+        """
+
+    @property
+    def chunk_id(self) -> str: ...
+    @property
+    def component_ids(self) -> set[str]: ...
+
+class ChunkDoesNotExist(ChunkLoadError):
+    """
+    An error thrown if a chunk does not exist and therefor cannot be loaded.
+
+    >>> try:
+    >>>     # get chunk
+    >>>     chunk = world.get_chunk(cx, cz, dimension)
+    >>> except ChunkDoesNotExist:
+    >>>     # will catch all chunks that do not exist
+    >>>     # will not catch corrupt chunks
+    >>> except ChunkLoadError:
+    >>>     # will only catch chunks that errored during loading
+    >>>     # chunks that do not exist were caught by the previous except section.
+    """
+
+class ChunkLoadError(RuntimeError):
+    """
+    An error thrown if a chunk failed to load for some reason.
+
+    This may be due to a corrupt chunk, an unsupported chunk format or just because the chunk does not exist to be loaded.
+
+    Catching this error will also catch :class:`ChunkDoesNotExist`
+
+    >>> try:
+    >>>     # get chunk
+    >>>     chunk = world.get_chunk(cx, cz, dimension)
+    >>> except ChunkLoadError:
+    >>>     # will catch all chunks that have failed to load
+    >>>     # either because they do not exist or errored during loading.
+    """
+
+def get_null_chunk(arg0: str) -> Chunk:
+    """
+    This is a private function
+    """

amulet/core/chunk/chunk.hpp

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+
+#include <amulet/core/dll.hpp>
+
+// Requirements:
+// Split chunk data into components that are orthogonal to each other.
+// create a chunk with all components default initialised.
+// reconstruct a chunk from a subset of its components.
+// reconstruct a chunk with all components.
+// query if a chunk has a component. (isinstance/is_base_of/dynamic_cast or has_component)
+// get a component. (method/property or get_component)
+// set and validate a component. (method/property or set_component)
+// serialise loaded components.
+
+namespace Amulet {
+typedef std::unordered_map<std::string, std::optional<std::string>> SerialisedChunkComponents;
+
+// The abstract chunk class
+class Chunk {
+public:
+    virtual ~Chunk() = default;
+    virtual std::string get_chunk_id() const = 0;
+    virtual std::set<std::string> get_component_ids() const = 0;
+    // private:
+    //  These are public but may become private one day
+    virtual SerialisedChunkComponents serialise_chunk() const = 0;
+    virtual void reconstruct_chunk(SerialisedChunkComponents) = 0;
+};
+
+namespace detail {
+    using ChunkContructor = std::function<std::shared_ptr<Chunk>()>;
+    AMULET_CORE_EXPORT void add_null_chunk_constructor(const std::string& id, ChunkContructor constructor);
+    AMULET_CORE_EXPORT void remove_null_chunk_constructor(const std::string& id);
+}
+
+AMULET_CORE_EXPORT std::shared_ptr<Chunk> get_null_chunk(std::string chunk_id);
+
+// An object that concrete chunk classes must be registered with.
+// This enables reconstructing the chunk class.
+template <typename ChunkT>
+class ChunkNullConstructor {
+public:
+    ChunkNullConstructor()
+    {
+        detail::add_null_chunk_constructor(ChunkT::ChunkID, []() {
+            return std::make_shared<ChunkT>();
+        });
+    }
+    ~ChunkNullConstructor()
+    {
+        detail::remove_null_chunk_constructor(ChunkT::ChunkID);
+    }
+};
+
+// A utility class to simplify component serialisation and deserialisation.
+template <class ChunkBaseClass, class... Components>
+class ChunkComponentHelper : public ChunkBaseClass, public Components... {
+public:
+    // Component list
+    std::set<std::string> get_component_ids() const override
+    {
+        std::set<std::string> component_ids;
+        (
+            [&] {
+                component_ids.emplace(Components::ComponentID);
+            }(),
+            ...);
+        return component_ids;
+    }
+    // These are public but may become private one day
+    // Null constructor
+    ChunkComponentHelper()
+        : Components()...
+    {
+    }
+    // private:
+    // Serialiser
+    SerialisedChunkComponents serialise_chunk() const override
+    {
+        SerialisedChunkComponents component_data;
+        (
+            [&] {
+                component_data[Components::ComponentID] = Components::serialise();
+            }(),
+            ...);
+        return component_data;
+    }
+    // Deserialiser
+    void reconstruct_chunk(SerialisedChunkComponents component_data) override
+    {
+        (
+            [&] {
+                auto node = component_data.extract(Components::ComponentID);
+                Components::deserialise(node ? node.mapped() : std::nullopt);
+            }(),
+            ...);
+    }
+};
+
+class AMULET_CORE_EXPORT_EXCEPTION ChunkLoadError : public std::runtime_error {
+public:
+    using std::runtime_error::runtime_error;
+    ChunkLoadError()
+        : ChunkLoadError("ChunkLoadError")
+    {
+    }
+};
+
+class AMULET_CORE_EXPORT_EXCEPTION ChunkDoesNotExist : public ChunkLoadError {
+public:
+    using ChunkLoadError::ChunkLoadError;
+    ChunkDoesNotExist()
+        : ChunkDoesNotExist("ChunkDoesNotExist")
+    {
+    }
+};
+
+} // namespace Amulet

amulet/core/chunk/component/__init__.pyi

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from amulet.core.chunk.component.block_component import BlockComponent, BlockStorage
+from amulet.core.chunk.component.section_array_map import IndexArray3D, SectionArrayMap
+
+from . import block_component, section_array_map
+
+__all__: list[str] = [
+    "BlockComponent",
+    "BlockStorage",
+    "IndexArray3D",
+    "SectionArrayMap",
+    "block_component",
+    "section_array_map",
+]

amulet/core/chunk/component/biome_3d_component.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <tuple>
+
+#include <amulet/core/biome/biome.hpp>
+#include <amulet/core/dll.hpp>
+#include <amulet/core/palette/biome_palette.hpp>
+#include <amulet/core/version/version.hpp>
+
+#include "section_array_map.hpp"
+
+namespace Amulet {
+
+class Biome3DStorage {
+private:
+    std::shared_ptr<BiomePalette> _palette;
+    std::shared_ptr<SectionArrayMap> _sections;
+
+public:
+    template <typename PaletteT, typename SectionsT>
+    Biome3DStorage(
+        PaletteT&& palette,
+        SectionsT&& sections)
+        : _palette(
+              [&palette] {
+                  if constexpr (std::is_same_v<std::shared_ptr<BiomePalette>, std::decay_t<PaletteT>>) {
+                      return std::forward<PaletteT>(palette);
+                  } else {
+                      return std::make_shared<BiomePalette>(palette);
+                  }
+              }())
+        , _sections(
+              [&sections] {
+                  if constexpr (std::is_same_v<std::shared_ptr<SectionArrayMap>, std::decay_t<SectionsT>>) {
+                      return std::forward<SectionsT>(sections);
+                  } else {
+                      return std::make_shared<SectionArrayMap>(sections);
+                  }
+              }())
+    {
+    }
+
+    template <typename VersionRangeT>
+    Biome3DStorage(
+        VersionRangeT&& version_range,
+        const SectionShape& array_shape,
+        const Biome& default_biome)
+        : Biome3DStorage(
+              std::make_shared<BiomePalette>(std::forward<VersionRangeT>(version_range)),
+              std::make_shared<SectionArrayMap>(array_shape, static_cast<std::uint32_t>(0)))
+    {
+        _palette->biome_to_index(default_biome);
+    }
+
+    BiomePalette& get_palette() { return *_palette; }
+    std::shared_ptr<BiomePalette> get_palette_ptr() { return _palette; }
+    SectionArrayMap& get_sections() { return *_sections; }
+    std::shared_ptr<SectionArrayMap> get_sections_ptr() { return _sections; }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static Biome3DStorage deserialise(BinaryReader&);
+};
+
+class Biome3DComponent {
+private:
+    std::optional<std::shared_ptr<Biome3DStorage>> _value;
+
+protected:
+    // Null constructor
+    Biome3DComponent() = default;
+
+    // Default constructor
+    template <typename VersionRangeT>
+    void init(
+        VersionRangeT&& version_range,
+        const SectionShape& array_shape,
+        const Biome& default_biome)
+    {
+        _value = std::make_shared<Biome3DStorage>(
+            std::forward<VersionRangeT>(version_range),
+            array_shape,
+            default_biome);
+    }
+
+    // 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<Biome3DStorage> get_biome_storage();
+    AMULET_CORE_EXPORT void set_biome_storage(std::shared_ptr<Biome3DStorage> component);
+};
+
+} // namespace Amulet

amulet/core/chunk/component/block_component.hpp

@@ -0,0 +1,101 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <tuple>
+
+#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/palette/block_palette.hpp>
+#include <amulet/core/version/version.hpp>
+
+#include "section_array_map.hpp"
+
+namespace Amulet {
+
+class BlockStorage {
+private:
+    std::shared_ptr<BlockPalette> _palette;
+    std::shared_ptr<SectionArrayMap> _sections;
+
+public:
+    template <typename PaletteT, typename SectionsT>
+    BlockStorage(
+        PaletteT&& palette,
+        SectionsT&& sections)
+        : _palette(
+              [&palette] {
+                  if constexpr (std::is_same_v<std::shared_ptr<BlockPalette>, std::decay_t<PaletteT>>) {
+                      return std::forward<PaletteT>(palette);
+                  } else {
+                      return std::make_shared<BlockPalette>(palette);
+                  }
+              }())
+        , _sections(
+              [&sections] {
+                  if constexpr (std::is_same_v<std::shared_ptr<SectionArrayMap>, std::decay_t<SectionsT>>) {
+                      return std::forward<SectionsT>(sections);
+                  } else {
+                      return std::make_shared<SectionArrayMap>(sections);
+                  }
+              }())
+    {
+    }
+
+    template <typename VersionRangeT>
+    BlockStorage(
+        VersionRangeT&& version_range,
+        const SectionShape& array_shape,
+        const BlockStack& default_block)
+        : BlockStorage(
+              std::make_shared<BlockPalette>(std::forward<VersionRangeT>(version_range)),
+              std::make_shared<SectionArrayMap>(array_shape, static_cast<std::uint32_t>(0)))
+    {
+        _palette->block_stack_to_index(default_block);
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BlockStorage deserialise(BinaryReader&);
+
+    BlockPalette& get_palette() const { return *_palette; }
+    std::shared_ptr<BlockPalette> get_palette_ptr() const { return _palette; }
+    SectionArrayMap& get_sections() const { return *_sections; }
+    std::shared_ptr<SectionArrayMap> get_sections_ptr() const { return _sections; }
+};
+
+class BlockComponent {
+private:
+    std::optional<std::shared_ptr<BlockStorage>> _value;
+
+protected:
+    // Null constructor
+    BlockComponent() = default;
+
+    // Default constructor
+    template <typename VersionRangeT>
+    void init(
+        VersionRangeT&& version_range,
+        const SectionShape& array_shape,
+        const BlockStack& default_block)
+    {
+        _value = std::make_shared<BlockStorage>(
+            std::forward<VersionRangeT>(version_range),
+            array_shape,
+            default_block);
+    }
+
+    // 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<BlockStorage> get_block_storage();
+    AMULET_CORE_EXPORT void set_block_storage(std::shared_ptr<BlockStorage> component);
+};
+
+} // namespace Amulet

amulet/core/chunk/component/block_component.pyi

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import typing
+
+import amulet.core.block
+import amulet.core.chunk.component.section_array_map
+import amulet.core.palette.block_palette
+import amulet.core.version
+
+__all__: list[str] = ["BlockComponent", "BlockStorage"]
+
+class BlockComponent:
+    ComponentID: typing.ClassVar[str] = "Amulet::BlockComponent"
+    block_storage: BlockStorage
+
+class BlockStorage:
+    def __init__(
+        self,
+        version_range: amulet.core.version.VersionRange,
+        array_shape: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt],
+        default_block: amulet.core.block.BlockStack,
+    ) -> None: ...
+    @property
+    def palette(self) -> amulet.core.palette.block_palette.BlockPalette: ...
+    @property
+    def sections(
+        self,
+    ) -> amulet.core.chunk.component.section_array_map.SectionArrayMap: ...