amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a1__cp311-cp311-win_amd64.whl

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,18 @@
+from __future__ import annotations
+
+from amulet.core.chunk.component.block_component import (
+    BlockComponent,
+    BlockComponentData,
+)
+from amulet.core.chunk.component.section_array_map import IndexArray3D, SectionArrayMap
+
+from . import block_component, section_array_map
+
+__all__ = [
+    "BlockComponent",
+    "BlockComponentData",
+    "IndexArray3D",
+    "SectionArrayMap",
+    "block_component",
+    "section_array_map",
+]

amulet/core/chunk/component/biome_3d_component.hpp

@@ -0,0 +1,96 @@
+#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 Biome3DComponentData {
+private:
+    std::shared_ptr<BiomePalette> _palette;
+    std::shared_ptr<SectionArrayMap> _sections;
+
+public:
+    template <typename PaletteT, typename SectionsT>
+    Biome3DComponentData(
+        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>
+    Biome3DComponentData(
+        VersionRangeT&& version_range,
+        const SectionShape& array_shape,
+        const Biome& default_biome)
+        : Biome3DComponentData(
+              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; }
+};
+
+class Biome3DComponent {
+private:
+    std::optional<std::shared_ptr<Biome3DComponentData>> _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<Biome3DComponentData>(
+            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<Biome3DComponentData> get_biome();
+    AMULET_CORE_EXPORT void set_biome(std::shared_ptr<Biome3DComponentData> 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 BlockComponentData {
+private:
+    std::shared_ptr<BlockPalette> _palette;
+    std::shared_ptr<SectionArrayMap> _sections;
+
+public:
+    template <typename PaletteT, typename SectionsT>
+    BlockComponentData(
+        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>
+    BlockComponentData(
+        VersionRangeT&& version_range,
+        const SectionShape& array_shape,
+        const BlockStack& default_block)
+        : BlockComponentData(
+              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 BlockComponentData 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<BlockComponentData>> _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<BlockComponentData>(
+            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<BlockComponentData> get_block();
+    AMULET_CORE_EXPORT void set_block(std::shared_ptr<BlockComponentData> 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__ = ["BlockComponent", "BlockComponentData"]
+
+class BlockComponent:
+    ComponentID: typing.ClassVar[str] = "Amulet::BlockComponent"
+    block: BlockComponentData
+
+class BlockComponentData:
+    def __init__(
+        self,
+        version_range: amulet.core.version.VersionRange,
+        array_shape: tuple[int, int, int],
+        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: ...

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/{chunk_components.pyi → core/chunk/component/section_array_map.pyi}

@@ -4,31 +4,11 @@ import collections.abc
 import types
 import typing
 
-import amulet.block
-import amulet.collections
-import amulet.palette.block_palette
-import amulet.version
 import numpy
 import numpy.typing
 import typing_extensions
 
-__all__ = ["BlockComponent", "BlockComponentData", "IndexArray3D", "SectionArrayMap"]
-
-class BlockComponent:
-    ComponentID: typing.ClassVar[str] = "Amulet::BlockComponent"
-    block: BlockComponentData
-
-class BlockComponentData:
-    def __init__(
-        self,
-        version_range: amulet.version.VersionRange,
-        array_shape: tuple[int, int, int],
-        default_block: amulet.block.BlockStack,
-    ) -> None: ...
-    @property
-    def palette(self) -> amulet.palette.block_palette.BlockPalette: ...
-    @property
-    def sections(self) -> SectionArrayMap: ...
+__all__ = ["IndexArray3D", "SectionArrayMap"]
 
 class IndexArray3D:
     """
@@ -63,13 +43,13 @@ class SectionArrayMap:
         array_shape: tuple[int, int, int],
         default_array: int | IndexArray3D | typing_extensions.Buffer,
     ) -> None: ...
-    def __iter__(self) -> amulet.collections.Iterator: ...
+    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, arg0: int, arg1: numpy.typing.NDArray[numpy.uint32] | None
+        self, key: int, default: numpy.typing.NDArray[numpy.uint32] | None = None
     ) -> numpy.typing.NDArray[numpy.uint32] | None: ...
     def items(
         self,
@@ -83,7 +63,7 @@ class SectionArrayMap:
     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) -> None: ...
+    def update(self, other: typing.Any = (), **kwargs: typing.Any) -> None: ...
     def values(
         self,
     ) -> collections.abc.ValuesView[numpy.typing.NDArray[numpy.uint32]]: ...

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