amulet-core 2.0a5__cp312-cp312-win_amd64.whl → 2.0a7__cp312-cp312-win_amd64.whl

amulet/block_entity.py.cpp

@@ -0,0 +1,115 @@
+#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/block_entity.pyi

@@ -17,7 +17,6 @@ class BlockEntity(amulet.version.PlatformVersionContainer):
     def __eq__(self, arg0: BlockEntity) -> bool: ...
     @typing.overload
     def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
-    def __getstate__(self) -> bytes: ...
     def __hash__(self) -> int: ...
     def __init__(
         self,
@@ -28,7 +27,6 @@ class BlockEntity(amulet.version.PlatformVersionContainer):
         nbt: amulet_nbt.NamedTag,
     ) -> None: ...
     def __repr__(self) -> str: ...
-    def __setstate__(self, arg0: bytes) -> None: ...
     @property
     def base_name(self) -> str:
         """

amulet/chunk.py.cpp

@@ -0,0 +1,80 @@
+#include <amulet/chunk.hpp>
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/operators.h>
+#include <pybind11/typing.h>
+
+
+namespace py = pybind11;
+
+void init_chunk(py::module m_parent) {
+    auto m = m_parent.def_submodule("chunk");
+    py::class_<Amulet::Chunk, std::shared_ptr<Amulet::Chunk>> Chunk(m, "Chunk",
+        "A base class for all chunk classes."
+    );
+        Chunk.def_property_readonly(
+            "chunk_id",
+            &Amulet::Chunk::get_chunk_id
+        );
+        Chunk.def_property_readonly(
+            "component_ids",
+            &Amulet::Chunk::get_component_ids
+        );
+        auto py_serialise = [](const Amulet::Chunk& self) -> py::typing::Dict<py::str, py::typing::Optional<py::bytes>> {
+            py::dict data;
+            for (const auto& [k, v] : self.serialise_chunk()) {
+                if (v) {
+                    data[py::str(k)] = py::bytes(v.value());
+                }
+                else {
+                    data[py::str(k)] = py::none();
+                }
+            }
+            return data;
+        };
+        Chunk.def(
+            "serialise_chunk",
+            py_serialise,
+            py::doc("This is private. Do not use this. It will be removed in the future.")
+        );
+        auto py_deserialise = [](Amulet::Chunk& self, py::typing::Dict<py::str, py::typing::Optional<py::bytes>> data) {
+            Amulet::SerialisedComponents component_data;
+            for (const auto& [k, v] : data) {
+                if (v.is(py::none())) {
+                    component_data[k.cast<std::string>()];
+                }
+                else {
+                    component_data[k.cast<std::string>()] = v.cast<std::string>();
+                }
+            }
+            self.reconstruct_chunk(component_data);
+        };
+        Chunk.def(
+            "reconstruct_chunk",
+            py_deserialise,
+            py::doc("This is private. Do not use this. It will be removed in the future.")
+        );
+        Chunk.def(
+            py::pickle(
+                [py_serialise](const Amulet::Chunk& self) {
+                    return py::make_tuple(
+                        self.get_chunk_id(),
+                        py_serialise(self)
+                    );
+                },
+                [py_deserialise](py::tuple state) {
+                    if (state.size() != 2) { throw std::runtime_error("Invalid state!"); }
+                    auto self = Amulet::get_null_chunk(state[0].cast<std::string>());
+                    py_deserialise(*self, state[1]);
+                    return self;
+                }
+            )
+        );
+
+    m.def(
+        "get_null_chunk", 
+        &Amulet::get_null_chunk,
+        py::doc("This is a private function")
+    );
+}

amulet/chunk.pyi

@@ -7,8 +7,6 @@ class Chunk:
     A base class for all chunk classes.
     """
 
-    def __getstate__(self) -> tuple: ...
-    def __setstate__(self, arg0: tuple) -> None: ...
     def reconstruct_chunk(self, arg0: dict[str, bytes | None]) -> None:
         """
         This is private. Do not use this. It will be removed in the future.

amulet/chunk_components/biome_3d_component.cpp

@@ -0,0 +1,5 @@
+#include <amulet/chunk_components/biome_3d_component.hpp>
+
+namespace Amulet {
+	const std::string Biome3DComponent::ComponentID = "Amulet::Biome3DComponent";
+}

amulet/chunk_components/biome_3d_component.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <memory>
+#include <tuple>
+#include <optional>
+#include <cstdint>
+#include <memory>
+
+#include <amulet/version.hpp>
+#include <amulet/biome.hpp>
+#include <amulet/palette/biome_palette.hpp>
+#include <amulet/chunk_components/section_array_map.hpp>
+
+
+namespace Amulet {
+	class Biome3DComponentData {
+	private:
+		std::shared_ptr<BiomePalette> _palette;
+		std::shared_ptr<SectionArrayMap> _sections;
+	public:
+		Biome3DComponentData(
+			std::shared_ptr<VersionRange> version_range,
+			const SectionShape& array_shape,
+			std::shared_ptr<Biome> default_biome
+		):
+			_palette(std::make_shared<BiomePalette>(version_range)),
+			_sections(std::make_shared<SectionArrayMap>(array_shape, static_cast<std::uint32_t>(0)))
+		{
+			_palette->biome_to_index(default_biome);
+		}
+		std::shared_ptr<BiomePalette> get_palette() {
+			return _palette;
+		}
+		std::shared_ptr<SectionArrayMap> get_sections() {
+			return _sections;
+		}
+	};
+
+	class Biome3DComponent {
+	private:
+		std::optional<std::shared_ptr<Biome3DComponentData>> _value;
+	protected:
+		// Null constructor
+		Biome3DComponent() {};
+		// Default constructor
+		void init(
+			std::shared_ptr<VersionRange> version_range,
+			const SectionShape& array_shape,
+			std::shared_ptr<Biome> default_biome
+		) { _value = std::make_shared<Biome3DComponentData>(version_range, array_shape, default_biome); }
+		
+		// Serialise the component data
+		std::optional<std::string> serialise() const;
+		// Deserialise the component
+		void deserialise(std::optional<std::string>);
+	public:
+		static const std::string ComponentID;
+		std::shared_ptr<Biome3DComponentData> get_biome() {
+			if (_value) {
+				return *_value;
+			}
+			throw std::runtime_error("BiomeComponent has not been loaded.");
+		};
+		void set_biome(std::shared_ptr<Biome3DComponentData> component) {
+			if (_value) {
+				if ((*_value)->get_sections()->get_array_shape() != component->get_sections()->get_array_shape()) {
+					throw std::invalid_argument("New biome array shape does not match old array shape.");
+				}
+				if ((*_value)->get_palette()->get_version_range() != component->get_palette()->get_version_range()) {
+					throw std::invalid_argument("New biome version range does not match old version range.");
+				}
+				_value = component;
+			}
+			else {
+				throw std::runtime_error("BiomeComponent has not been loaded.");
+			}
+		};
+	};
+}

amulet/chunk_components/block_component.cpp

@@ -0,0 +1,41 @@
+#include <amulet/chunk_components/block_component.hpp>
+
+namespace Amulet {
+	void BlockComponentData::serialise(BinaryWriter& writer) const {
+		writer.writeNumeric<std::uint8_t>(1);
+		get_palette()->serialise(writer);
+		get_sections()->serialise(writer);
+	}
+	std::shared_ptr<BlockComponentData> BlockComponentData::deserialise(BinaryReader& reader) {
+		auto version = reader.readNumeric<std::uint8_t>();
+		switch (version) {
+		case 1:
+		{
+			auto palette = BlockPalette::deserialise(reader);
+			auto sections = SectionArrayMap::deserialise(reader);
+			return std::make_shared<BlockComponentData>(palette, sections);
+		}
+		default:
+			throw std::invalid_argument("Unsupported BlockComponentData version " + std::to_string(version));
+		}
+	}
+
+	const std::string BlockComponent::ComponentID = "Amulet::BlockComponent";
+
+	std::optional<std::string> BlockComponent::serialise() const {
+		if (_value) {
+			return Amulet::serialise(**_value);
+		}
+		else {
+			return std::nullopt;
+		}
+	}
+	void BlockComponent::deserialise(std::optional<std::string> data) {
+		if (data) {
+			_value = Amulet::deserialise<BlockComponentData>(*data);
+		}
+		else {
+			_value = std::nullopt;
+		}
+	}
+}

amulet/chunk_components/block_component.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <memory>
+#include <tuple>
+#include <optional>
+
+#include <amulet/version.hpp>
+#include <amulet/block.hpp>
+#include <amulet/palette/block_palette.hpp>
+#include <amulet/chunk_components/section_array_map.hpp>
+#include <amulet/io/binary_writer.hpp>
+#include <amulet/io/binary_reader.hpp>
+
+
+namespace Amulet {
+	class BlockComponentData {
+	private:
+		std::shared_ptr<BlockPalette> _palette;
+		std::shared_ptr<SectionArrayMap> _sections;
+	public:
+		BlockComponentData(
+			std::shared_ptr<VersionRange> version_range,
+			const SectionShape& array_shape,
+			std::shared_ptr<BlockStack> default_block
+		):
+			_palette(std::make_shared<BlockPalette>(version_range)),
+			_sections(std::make_shared<SectionArrayMap>(array_shape, static_cast<std::uint32_t>(0)))
+		{
+			_palette->block_stack_to_index(default_block);
+		}
+		BlockComponentData(
+			std::shared_ptr<BlockPalette> palette,
+			std::shared_ptr<SectionArrayMap> sections
+		): _palette(palette), _sections(sections){}
+
+		void serialise(BinaryWriter&) const;
+		static std::shared_ptr<BlockComponentData> deserialise(BinaryReader&);
+
+		std::shared_ptr<BlockPalette> get_palette() const {
+			return _palette;
+		}
+		std::shared_ptr<SectionArrayMap> get_sections() const {
+			return _sections;
+		}
+		
+	};
+
+	class BlockComponent {
+	private:
+		std::optional<std::shared_ptr<BlockComponentData>> _value;
+	protected:
+		// Null constructor
+		BlockComponent() {};
+		// Default constructor
+		void init(
+			std::shared_ptr<VersionRange> version_range,
+			const SectionShape& array_shape,
+			std::shared_ptr<BlockStack> default_block
+		) { _value = std::make_shared<BlockComponentData>(version_range, array_shape, default_block); }
+		
+		// Serialise the component data
+		std::optional<std::string> serialise() const;
+		// Deserialise the component
+		void deserialise(std::optional<std::string>);
+	public:
+		static const std::string ComponentID;
+		std::shared_ptr<BlockComponentData> get_block() {
+			if (_value) {
+				return *_value;
+			}
+			throw std::runtime_error("BlockComponent has not been loaded.");
+		};
+		void set_block(std::shared_ptr<BlockComponentData> component) {
+			if (_value) {
+				if ((*_value)->get_sections()->get_array_shape() != component->get_sections()->get_array_shape()) {
+					throw std::invalid_argument("New block array shape does not match old array shape.");
+				}
+				if ((*_value)->get_palette()->get_version_range() != component->get_palette()->get_version_range()) {
+					throw std::invalid_argument("New block version range does not match old version range.");
+				}
+				_value = component;
+			}
+			else {
+				throw std::runtime_error("BlockComponent has not been loaded.");
+			}
+		};
+	};
+}

amulet/chunk_components/block_entity_component.cpp

@@ -0,0 +1,5 @@
+#include <amulet/chunk_components/block_entity_component.hpp>
+
+namespace Amulet {
+	const std::string BlockEntityComponent::ComponentID = "Amulet::BlockEntityComponent";
+}

amulet/chunk_components/block_entity_component.hpp

@@ -0,0 +1,147 @@
+#pragma once
+
+#include <memory>
+#include <tuple>
+#include <optional>
+#include <cstdint>
+#include <memory>
+#include <map>
+
+#include <amulet/version.hpp>
+#include <amulet/block_entity.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:
+		BlockEntityComponentData(
+			std::shared_ptr<VersionRange> version_range,
+			const std::uint16_t& x_size,
+			const std::uint16_t& z_size
+		) :
+			VersionRangeContainer(version_range),
+			_x_size(x_size),
+			_z_size(z_size),
+			_block_entities()
+		{}
+
+		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);
+		}
+
+		void set(
+			const BlockEntityChunkCoord& coord,
+			std::shared_ptr<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[coord] = 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 constructor
+		void init(
+			std::shared_ptr<VersionRange> version_range,
+			const std::uint16_t& x_size,
+			const std::uint16_t& z_size
+		) {
+			_value = std::make_shared<BlockEntityComponentData>(version_range, x_size, z_size);
+		}
+
+		// Serialise the component data
+		std::optional<std::string> serialise() const;
+		// Deserialise the component
+		void deserialise(std::optional<std::string>);
+	public:
+		static const std::string ComponentID;
+		std::shared_ptr<BlockEntityComponentData> get_block_entity() {
+			if (_value) {
+				return *_value;
+			}
+			throw std::runtime_error("BlockEntityComponent has not been loaded.");
+		};
+		void set_block_entity(std::shared_ptr<BlockEntityComponentData> component) {
+			if (_value) {
+				if (
+					(*_value)->get_x_size() != component->get_x_size() ||
+					(*_value)->get_z_size() != component->get_z_size()
+				) {
+					throw std::invalid_argument("New BlockEntityComponent shape does not match old shape.");
+				}
+				if ((*_value)->get_version_range() != component->get_version_range()) {
+					throw std::invalid_argument("New BlockEntityComponent version range does not match old version range.");
+				}
+				_value = component;
+			}
+			else {
+				throw std::runtime_error("BlockEntityComponent has not been loaded.");
+			}
+		};
+	};
+}