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

amulet/block.py.cpp

@@ -1,377 +0,0 @@
-#include <span>
-#include <memory>
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/operators.h>
-#include <pybind11/typing.h>
-
-#include <amulet/collections/sequence.py.hpp>
-#include <amulet/collections/eq.py.hpp>
-#include <amulet/pybind11/types.hpp>
-#include <amulet/block.hpp>
-
-namespace py = pybind11;
-
-void init_block(py::module m_parent) {
-    auto m = m_parent.def_submodule("block");
-    py::options options;
-
-    py::object PySorted = py::module::import("builtins").attr("sorted");
-
-    // Required for docstrings
-    py::object amulet_nbt = py::module::import("amulet_nbt");
-    py::object ByteTag = amulet_nbt.attr("ByteTag");
-    py::object ShortTag = amulet_nbt.attr("ShortTag");
-    py::object IntTag = amulet_nbt.attr("IntTag");
-    py::object LongTag = amulet_nbt.attr("LongTag");
-    py::object StringTag = amulet_nbt.attr("StringTag");
-
-    m.attr("PropertyValueType") = ByteTag | ShortTag | IntTag | LongTag | StringTag;
-
-    py::class_<Amulet::Block, Amulet::PlatformVersionContainer, std::shared_ptr<Amulet::Block>> Block(m, "Block",
-        "A class to manage the state of a block.\n"
-        "\n"
-        "It is an immutable object that contains the platform, version, namespace, base name and properties.\n"
-        "\n"
-        "Here's a few examples on how create a Block object:\n"
-        "\n"
-        ">>> # Create a stone block for Java 1.20.2\n"
-        ">>> stone = Block(\"java\", VersionNumber(3578), \"minecraft\", \"stone\")\n"
-        ">>> # The Java block version number is the Java data version\n"
-        "\n"
-        ">>> # Create a stone block for Bedrock \n"
-        ">>> stone = Block(\"bedrock\", VersionNumber(1, 21, 0, 3), \"minecraft\", \"stone\")\n"
-        ">>> # The Bedrock block version number is the value stored as an int with the block data.\n"
-        "\n"
-        ">>> # Create a Java water block with the level property\n"
-        ">>> water = Block(\n"
-        ">>>     \"java\", VersionNumber(3578),\n"
-        ">>>     \"minecraft\",  # the namespace\n"
-        ">>>     \"water\",  # the base name\n"
-        ">>>     {  # A dictionary of properties.\n"
-        ">>>         # Keys must be strings and values must be a numerical or string NBT type.\n"
-        ">>>         \"level\": StringTag(\"0\")  # define a property `level` with a string value `0`\n"
-        ">>>     }\n"
-        ">>> )"
-    );
-        Block.def(
-            py::init<
-                const Amulet::PlatformType&,
-                std::shared_ptr<Amulet::VersionNumber>,
-                const std::string&,
-                const std::string&,
-                const std::map<std::string, Amulet::PropertyValueType>&
-            >(),
-            py::arg("platform"),
-            py::arg("version"),
-            py::arg("namespace"),
-            py::arg("base_name"),
-            py::arg("properties") = py::dict()
-        );
-        Block.def_property_readonly(
-            "namespaced_name",
-            [](const Amulet::Block& self) {
-                return self.get_namespace() + ":" + self.get_base_name();
-            },
-            py::doc(
-                "The namespace:base_name of the blockstate represented by the :class:`Block` object.\n"
-                "\n"
-                ">>> block: Block\n"
-                ">>> block.namespaced_name\n"
-                "\n"
-                ":return: The namespace:base_name of the blockstate"
-            )
-        );
-        Block.def_property_readonly(
-            "namespace",
-            &Amulet::Block::get_namespace,
-            py::doc(
-                "The namespace of the blockstate represented by the :class:`Block` object.\n"
-                "\n"
-                ">>> block: Block\n"
-                ">>> water.namespace\n"
-                "\n"
-                ":return: The namespace of the blockstate"
-            )
-        );
-        Block.def_property_readonly(
-            "base_name",
-            &Amulet::Block::get_base_name,
-            py::doc(
-                "The base name of the blockstate represented by the :class:`Block` object.\n"
-                "\n"
-                ">>> block: Block\n"
-                ">>> block.base_name\n"
-                "\n"
-                ":return: The base name of the blockstate"
-            )
-        );
-        Block.def_property_readonly(
-            "properties",
-            &Amulet::Block::get_properties,
-            py::doc(
-                "The properties of the blockstate represented by the :class:`Block` object as a dictionary.\n"
-                ">>> block: Block\n"
-                ">>> block.properties\n"
-                "\n"
-                ":return: A mapping of the properties of the blockstate"
-            )
-        );
-        Block.def(
-            "__repr__",
-            [](const Amulet::Block& self){
-                return "Block(" +
-                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_version())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_namespace())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_base_name())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_properties())).cast<std::string>() +
-                ")";
-            }
-        );
-        Block.def(
-            "__hash__",
-            [PySorted](const Amulet::Block& self) {
-                return py::hash(
-                    py::make_tuple(
-                        py::cast(self.get_platform()),
-                        py::cast(self.get_version()),
-                        py::cast(self.get_namespace()),
-                        py::cast(self.get_base_name()),
-                        py::tuple(PySorted(py::cast(self.get_properties()).attr("items")()))
-                    )
-                );
-            }
-        );
-        Block.def(
-            py::pickle(
-                [](const Amulet::Block& self) -> py::bytes {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::Block>(state.cast<std::string>());
-                }
-            )
-        );
-
-        Eq(Block);
-        Eq_default(Block);
-        Block.def(py::self > py::self);
-        Block.def(py::self < py::self);
-        Block.def(py::self >= py::self);
-        Block.def(py::self <= py::self);
-
-        Block.def_static(
-            "from_java_blockstate",
-            &Amulet::Block::from_java_blockstate,
-            py::doc(
-                "Parse a Java format blockstate where values are all strings and populate a :class:`Block` class with the data.\n"
-                "\n"
-                ">>> stone = Block.from_java_blockstate(\"minecraft:stone\")\n"
-                ">>> water = Block.from_java_blockstate(\"minecraft:water[level=0]\")\n"
-                "\n"
-                ":param platform: The platform the block is defined in.\n"
-                ":param version: The version the block is defined in.\n"
-                ":param blockstate: The Java blockstate string to parse.\n"
-                ":return: A Block instance containing the state."
-            ),
-            py::arg("platform"),
-            py::arg("version"),
-            py::arg("blockstate")
-        );
-        Block.def_static(
-            "from_bedrock_blockstate",
-            &Amulet::Block::from_bedrock_blockstate,
-            py::doc(
-                "Parse a Bedrock format blockstate where values are all strings and populate a :class:`Block` class with the data.\n"
-                "\n"
-                ">>> stone = Block.from_bedrock_blockstate(\"minecraft:stone\")\n"
-                ">>> water = Block.from_bedrock_blockstate(\"minecraft:water[\"liquid_depth\"=0]\")\n"
-                "\n"
-                ":param platform: The platform the block is defined in.\n"
-                ":param version: The version the block is defined in.\n"
-                ":param blockstate: The Bedrock blockstate string to parse.\n"
-                ":return: A Block instance containing the state."
-            ),
-            py::arg("platform"),
-            py::arg("version"),
-            py::arg("blockstate")
-        );
-
-        Block.def_property_readonly(
-            "java_blockstate",
-            &Amulet::Block::java_blockstate,
-            py::doc(
-                "The Java blockstate string of this :class:`Block` object.\n"
-                "Note this will only contain properties with StringTag values.\n"
-                "\n"
-                ">>> stone = Block(\"java\", VersionNumber(3578), \"minecraft\", \"stone\")\n"
-                ">>> stone.java_blockstate\n"
-                "minecraft:stone\n"
-                ">>> water = Block(\"java\", VersionNumber(3578), \"minecraft\", \"water\", {\"level\": StringTag(\"0\")})\n"
-                ">>> water.java_blockstate\n"
-                "minecraft:water[level=0]\n"
-                "\n"
-                ":return: The blockstate string"
-            )
-        );
-        Block.def_property_readonly(
-            "bedrock_blockstate",
-            &Amulet::Block::bedrock_blockstate,
-            py::doc(
-                "The Bedrock blockstate string of this :class:`Block` object.\n"
-                "Converts the property values to the SNBT format to preserve type.\n"
-                "\n"
-                ">>> bell = Block(\n"
-                ">>>     \"java\", VersionNumber(3578),\n"
-                ">>>     \"minecraft\",\n"
-                ">>>     \"bell\",\n"
-                ">>>     {\n"
-                ">>>         \"attachment\":StringTag(\"standing\"),\n"
-                ">>>         \"direction\":IntTag(0),\n"
-                ">>>         \"toggle_bit\":ByteTag(0)\n"
-                ">>>     }\n"
-                ">>> )\n"
-                ">>> bell.bedrock_blockstate\n"
-                "minecraft:bell[\"attachment\"=\"standing\",\"direction\"=0,\"toggle_bit\"=false]\n"
-                "\n"
-                ":return: The SNBT blockstate string"
-            )
-        );
-
-    py::class_<Amulet::BlockStack, std::shared_ptr<Amulet::BlockStack>> BlockStack(m, "BlockStack",
-        "A stack of block objects.\n"
-        "\n"
-        "Java 1.13 added the concept of waterlogging blocks whereby some blocks have a `waterlogged` property.\n"
-        "Bedrock achieved the same behaviour by added a layering system which allows the second block to be any block.\n"
-        "\n"
-        "Amulet supports both implementations with a stack of one or more block objects similar to how Bedrock handles it.\n"
-        "Amulet places no restrictions on which blocks can be extra blocks.\n"
-        "Extra block may be discarded if the format does not support them.\n"
-        "\n"
-        "Create a waterlogged stone block.\n"
-        ">>> waterlogged_stone = BlockStack(\n"
-        ">>>     Block(\"java\", VersionNumber(3578), \"minecraft\", \"stone\"),\n"
-        ">>>     Block(\"java\", VersionNumber(3578), \"minecraft\", \"water\", {\"level\": StringTag(\"0\")})\n"
-        ">>> )\n"
-        "\n"
-        "Get a block at an index\n"
-        ">>> stone = waterlogged_stone[0]\n"
-        ">>> water = waterlogged_stone[1]\n"
-        "\n"
-        "Get the blocks as a list\n"
-        ">>> blocks = list(waterlogged_stone)"
-    );
-        options.disable_function_signatures();
-        BlockStack.def(
-            py::init(
-                [](std::shared_ptr<Amulet::Block> block, py::args py_extra_blocks){
-                    std::vector<std::shared_ptr<Amulet::Block>> blocks;
-                    blocks.push_back(block);
-                    auto extra_blocks = py_extra_blocks.cast<std::vector<std::shared_ptr<Amulet::Block>>>();
-                    blocks.insert(blocks.end(), extra_blocks.begin(), extra_blocks.end());
-                    return Amulet::BlockStack(blocks);
-                }
-            ),
-            py::doc("__init__(self, block: amulet.block.Block, *extra_blocks: amulet.block.Block) -> None")
-        );
-        options.enable_function_signatures();
-
-        BlockStack.def(
-            "__repr__",
-            [](const Amulet::BlockStack& self) {
-                const auto& blocks = self.get_blocks();
-                std::string repr = "BlockStack(";
-                for (size_t i = 0; i < blocks.size(); i++) {
-                    if (i != 0) {
-                        repr += ", ";
-                    }
-                    repr += py::repr(py::cast(blocks[i])).cast<std::string>();
-                }
-                repr += ")";
-                return repr;
-            }
-        );
-
-        BlockStack.def(
-            "__len__",
-            &Amulet::BlockStack::size
-        );
-
-        BlockStack.def(
-            "__getitem__",
-            [](const Amulet::BlockStack& self, Py_ssize_t index) {
-                if (index < 0) {
-                    index += self.size();
-                    if (index < 0) {
-                        throw py::index_error("");
-                    }
-                }
-                if (index >= self.size()) {
-                    throw py::index_error("");
-                }
-                return self[index];
-            }
-        );
-        BlockStack.def(
-            "__hash__",
-            [](const Amulet::BlockStack& self) {
-                return py::hash(
-                    py::tuple(py::cast(self.get_blocks()))
-                );
-            }
-        );
-
-        Amulet::collections::Sequence<Amulet::Block>(BlockStack);
-
-        Eq(BlockStack);
-        Eq_default(BlockStack);
-
-        BlockStack.def(py::self > py::self);
-        BlockStack.def(py::self < py::self);
-        BlockStack.def(py::self >= py::self);
-        BlockStack.def(py::self <= py::self);
-
-        BlockStack.def_property_readonly(
-            "base_block",
-            [](const Amulet::BlockStack& self) -> std::shared_ptr<Amulet::Block> {
-                return self.get_blocks()[0];
-            },
-            py::doc(
-                "The first block in the stack.\n"
-                "\n"
-                ">>> waterlogged_stone = BlockStack(\n"
-                ">>>     Block(\"java\", VersionNumber(3578), \"minecraft\", \"stone\"),\n"
-                ">>>     Block(\"java\", VersionNumber(3578), \"minecraft\", \"water\", {\"level\": StringTag(\"0\")})\n"
-                ">>> )\n"
-                ">>> waterlogged_stone.base_block\n"
-                "Block(\"java\", VersionNumber(3578), \"minecraft\", \"stone\")\n"
-                "\n"
-                ":return: A Block object"
-            )
-        );
-        BlockStack.def_property_readonly(
-            "extra_blocks",
-            [](const Amulet::BlockStack& self) -> py::tuple {
-                const auto& blocks = self.get_blocks();
-                py::tuple py_blocks(blocks.size() - 1);
-                for (size_t i = 1; i < blocks.size(); i++) {
-                    py_blocks[i - 1] = py::cast(blocks[i]);
-                }
-                return py_blocks;
-            },
-            py::doc(
-                "The extra blocks in the stack.\n"
-                "\n"
-                ">>> waterlogged_stone = BlockStack(\n"
-                ">>>     Block(\"java\", VersionNumber(3578), \"minecraft\", \"stone\"),\n"
-                ">>>     Block(\"java\", VersionNumber(3578), \"minecraft\", \"water\", {\"level\": StringTag(\"0\")})\n"
-                ">>> )\n"
-                ">>> waterlogged_stone.extra_blocks\n"
-                "(Block(\"java\", VersionNumber(3578), \"minecraft\", \"water\", {\"level\": StringTag(\"0\")}),)\n"
-                "\n"
-                ":return: A tuple of :class:`Block` objects"
-            )
-        );
-}

amulet/block_entity.cpp

@@ -1,12 +0,0 @@
-#include <amulet/block_entity.hpp>
-
-namespace Amulet {
-
-	void BlockEntity::serialise(BinaryWriter&) const {
-		throw std::runtime_error("NotImplemented");
-	}
-	std::shared_ptr<BlockEntity> BlockEntity::deserialise(BinaryReader&) {
-		throw std::runtime_error("NotImplemented");
-	}
-
-}

amulet/block_entity.hpp

@@ -1,56 +0,0 @@
-#pragma once
-
-#include <map>
-#include <variant>
-#include <string>
-
-#include <amulet/io/binary_reader.hpp>
-#include <amulet/io/binary_writer.hpp>
-#include <amulet/version.hpp>
-#include <amulet_nbt/tag/named_tag.hpp>
-#include <amulet_nbt/tag/eq.hpp>
-
-
-namespace Amulet {
-    class BlockEntity: public PlatformVersionContainer {
-        private:
-            std::string _namespace;
-            std::string _base_name;
-            std::shared_ptr<AmuletNBT::NamedTag> _nbt;
-            
-        public:
-            const std::string& get_namespace() const { return _namespace; }
-            void set_namespace(const std::string& namespace_) { _namespace = namespace_; }
-            
-            const std::string& get_base_name() const { return _base_name; }
-            void set_base_name(const std::string& base_name) { _base_name = base_name; }
-            
-            std::shared_ptr<AmuletNBT::NamedTag> get_nbt() const { return _nbt; }
-            void set_nbt(std::shared_ptr<AmuletNBT::NamedTag> nbt) { _nbt = nbt; }
-
-            BlockEntity(
-                const PlatformType& platform,
-                std::shared_ptr<VersionNumber> version,
-                const std::string& namespace_,
-                const std::string& base_name,
-                std::shared_ptr<AmuletNBT::NamedTag> nbt
-            ):
-                PlatformVersionContainer(platform, version),
-                _namespace(namespace_),
-                _base_name(base_name),
-                _nbt(nbt)
-            {}
-
-            void serialise(BinaryWriter&) const;
-            static std::shared_ptr<BlockEntity> deserialise(BinaryReader&);
-
-            bool operator==(const BlockEntity& other) const {
-                return (
-                    PlatformVersionContainer::operator==(other) &&
-                    _namespace == other._namespace &&
-                    _base_name == other._base_name &&
-                    AmuletNBT::NBTTag_eq(*_nbt, *other._nbt)
-                );
-            };
-    };
-}

amulet/block_entity.py.cpp

@@ -1,115 +0,0 @@
-#include <memory>
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/operators.h>
-#include <pybind11/typing.h>
-
-#include <amulet/collections/eq.py.hpp>
-#include <amulet/collections/hash.py.hpp>
-#include <amulet_nbt/tag/named_tag.hpp>
-#include <amulet/version.hpp>
-#include <amulet/block_entity.hpp>
-
-
-namespace py = pybind11;
-
-void init_block_entity(py::module m_parent) {
-    auto m = m_parent.def_submodule("block_entity");
-
-    py::class_<Amulet::BlockEntity, Amulet::PlatformVersionContainer, std::shared_ptr<Amulet::BlockEntity>> BlockEntity(m, "BlockEntity",
-        "A class to contain all the data to define a BlockEntity."
-    );
-        BlockEntity.def(
-            py::init<
-                const Amulet::PlatformType&,
-                std::shared_ptr<Amulet::VersionNumber>,
-                const std::string&,
-                const std::string&,
-                std::shared_ptr<AmuletNBT::NamedTag>
-            >(),
-            py::arg("platform"),
-            py::arg("version"),
-            py::arg("namespace"),
-            py::arg("base_name"),
-            py::arg("nbt")
-        );
-        BlockEntity.def_property_readonly(
-            "namespaced_name",
-            [](const Amulet::BlockEntity& self) {
-                return self.get_namespace() + ":" + self.get_base_name();
-            },
-            py::doc(
-                "The namespace:base_name of the block entity represented by the :class:`BlockEntity` object.\n"
-                "\n"
-                ">>> block_entity: BlockEntity\n"
-                ">>> block_entity.namespaced_name\n"
-                "\n"
-                ":return: The namespace:base_name of the block entity"
-            )
-        );
-        BlockEntity.def_property(
-            "namespace",
-            &Amulet::BlockEntity::get_namespace,
-            &Amulet::BlockEntity::set_namespace,
-            py::doc(
-                "The namespace of the block entity represented by the :class:`BlockEntity` object.\n"
-                "\n"
-                ">>> block_entity: BlockEntity\n"
-                ">>> block_entity.namespace\n"
-                "\n"
-                ":return: The namespace of the block entity"
-            )
-        );
-        BlockEntity.def_property(
-            "base_name",
-            &Amulet::BlockEntity::get_base_name,
-            &Amulet::BlockEntity::set_base_name,
-            py::doc(
-                "The base name of the block entity represented by the :class:`BlockEntity` object.\n"
-                "\n"
-                ">>> block_entity: BlockEntity\n"
-                ">>> block_entity.base_name\n"
-                "\n"
-                ":return: The base name of the block entity"
-            )
-        );
-        BlockEntity.def_property(
-            "nbt",
-            &Amulet::BlockEntity::get_nbt,
-            &Amulet::BlockEntity::set_nbt,
-            py::doc(
-                "The nbt data for the block entity.\n"
-                ">>> block_entity: BlockEntity\n"
-                ">>> block_entity.nbt\n"
-                "\n"
-                ":return: The NamedTag of the block entity"
-            )
-        );
-        BlockEntity.def(
-            "__repr__",
-            [](const Amulet::BlockEntity& self){
-                return "Block(" +
-                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_version())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_namespace())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_base_name())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_nbt())).cast<std::string>() +
-                ")";
-            }
-        );
-        BlockEntity.def(
-            py::pickle(
-                [](const Amulet::BlockEntity& self) -> py::bytes {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::BlockEntity>(state.cast<std::string>());
-                }
-            )
-        );
-
-        Eq(BlockEntity);
-        Eq_default(BlockEntity);
-        hash_default(BlockEntity);
-}

amulet/chunk.cpp

@@ -1,16 +0,0 @@
-#include <string>
-#include <unordered_map>
-#include <optional>
-#include <functional>
-#include <memory>
-
-#include <amulet/chunk.hpp>
-
-namespace Amulet {
-	namespace detail {
-		std::unordered_map<std::string, std::function<std::shared_ptr<Chunk>()>> chunk_constructors;
-	}
-	std::shared_ptr<Chunk> get_null_chunk(std::string chunk_id) {
-		return detail::chunk_constructors.at(chunk_id)();
-	}
-}

amulet/chunk.hpp

@@ -1,100 +0,0 @@
-#pragma once
-
-#include <string>
-#include <unordered_map>
-#include <optional>
-#include <functional>
-#include <memory>
-#include <stdexcept>
-
-// 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>> SerialisedComponents;
-
-    // The abstract chunk class
-	class Chunk {
-	public:
-		virtual ~Chunk() {}
-		virtual std::string get_chunk_id() const = 0;
-		virtual std::vector<std::string> get_component_ids() const = 0;
-	//private:
-	// These are public but may become private one day
-		virtual SerialisedComponents serialise_chunk() const = 0;
-		virtual void reconstruct_chunk(SerialisedComponents) = 0;
-	};
-
-	namespace detail {
-		extern std::unordered_map<std::string, std::function<std::shared_ptr<Chunk>()>> chunk_constructors;
-	}
-
-	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() {
-			if (detail::chunk_constructors.contains(ChunkT::ChunkID)) {
-				throw std::runtime_error("A chunk class has already been registered with ID " + ChunkT::ChunkID);
-			}
-			detail::chunk_constructors[ChunkT::ChunkID] = []() {
-				return std::make_shared<ChunkT>();
-			};
-		};
-		~ChunkNullConstructor() {
-			detail::chunk_constructors.erase(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::vector<std::string> get_component_ids() const override {
-			std::vector<std::string> component_ids;
-			(
-				[&]{
-					component_ids.push_back(Components::ComponentID);
-				}(),
-				...
-			);
-			return component_ids;
-		}
-	// These are public but may become private one day
-		// Null constructor
-		ChunkComponentHelper() : Components()... {}
-	//private:
-		// Serialiser
-		SerialisedComponents serialise_chunk() const override {
-			SerialisedComponents component_data;
-			(
-				[&]{
-					component_data[Components::ComponentID] = Components::serialise();
-				}(),
-				...
-			);
-			return component_data;
-		}
-		// Deserialiser
-		void reconstruct_chunk(SerialisedComponents component_data) override {
-			(
-				[&]{
-					auto node = component_data.extract(Components::ComponentID);
-					Components::deserialise(node ? node.mapped() : std::nullopt);
-				}(),
-				...
-			);
-		}
-	};
-}