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

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_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.");
+			}
+		};
+	};
+}

amulet/chunk_components/section_array_map.cpp

@@ -0,0 +1,129 @@
+#include <string>
+
+#include <amulet/io/binary_writer.hpp>
+#include <amulet/io/binary_reader.hpp>
+
+#include "section_array_map.hpp"
+
+namespace Amulet {
+	void IndexArray3D::serialise(BinaryWriter& writer) const {
+		writer.writeNumeric<std::uint8_t>(1);
+		
+		// Write array shape
+		const auto& array_shape = get_shape();
+		writer.writeNumeric<std::uint16_t>(std::get<0>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<1>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<2>(array_shape));
+
+		// Write array
+		const auto& size = get_size();
+		const auto* buffer = get_buffer();
+		for (auto i = 0; i < size; i++) {
+			writer.writeNumeric<std::uint32_t>(buffer[i]);
+		}
+	}
+	std::shared_ptr<IndexArray3D> IndexArray3D::deserialise(BinaryReader& reader) {
+		auto version = reader.readNumeric<std::uint8_t>();
+		switch (version) {
+		case 1:
+		{
+			// Read array shape
+			auto array_shape = std::make_tuple(
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>()
+			);
+
+			// Construct instance
+			auto self = std::make_shared<IndexArray3D>(array_shape);
+
+			// Read array
+			const auto& size = self->get_size();
+			auto* buffer = self->get_buffer();
+			for (auto i = 0; i < size; i++) {
+				buffer[i] = reader.readNumeric<std::uint32_t>();
+			}
+
+			return self;
+		}
+		default:
+			throw std::invalid_argument("Unsupported IndexArray3D version " + std::to_string(version));
+		}
+	}
+
+	void SectionArrayMap::serialise(BinaryWriter& writer) const {
+		writer.writeNumeric<std::uint8_t>(1);
+		
+		// Write array shape
+		const auto& array_shape = get_array_shape();
+		writer.writeNumeric<std::uint16_t>(std::get<0>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<1>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<2>(array_shape));
+		
+		// Write default array
+		std::visit(
+			[&writer](auto&& arg) {
+				using T = std::decay_t<decltype(arg)>;
+				if constexpr (std::is_same_v<T, std::uint32_t>) {
+					writer.writeNumeric<std::uint8_t>(0);
+					writer.writeNumeric<std::uint32_t>(arg);
+				}
+				else {
+					writer.writeNumeric<std::uint8_t>(1);
+					arg->serialise(writer);
+				}
+			}, 
+			get_default_array()
+		);
+
+		// Write arrays
+		const auto& arrays = get_arrays();
+		writer.writeNumeric<std::uint64_t>(arrays.size());
+		for (const auto& [cy, arr] : arrays) {
+			writer.writeNumeric<std::int64_t>(cy);
+			arr->serialise(writer);
+		}
+	}
+	std::shared_ptr<SectionArrayMap> SectionArrayMap::deserialise(BinaryReader& reader) {
+		auto version = reader.readNumeric<std::uint8_t>();
+		switch (version) {
+		case 1:
+		{
+			// Read array shape
+			auto array_shape = std::make_tuple(
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>()
+			);
+
+			// Read default array
+			auto default_array_state = reader.readNumeric<std::uint8_t>();
+			std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> default_array;
+			switch (default_array_state) {
+			case 0:
+				default_array = reader.readNumeric<std::uint32_t>();
+				break;
+			case 1:
+				default_array = IndexArray3D::deserialise(reader);
+				break;
+			default:
+				throw std::invalid_argument("Invalid default array state value " + std::to_string(default_array_state));
+			}
+
+			// Construct instance
+			auto self = std::make_shared<SectionArrayMap>(array_shape, default_array);
+			
+			// Populate arrays
+			auto array_count = reader.readNumeric<std::uint64_t>();
+			for (auto i = 0; i < array_count; i++) {
+				auto cy = reader.readNumeric<std::int64_t>();
+				self->set_section(cy, IndexArray3D::deserialise(reader));
+			}
+			
+			return self;
+		}
+		default:
+			throw std::invalid_argument("Unsupported BlockComponentData version " + std::to_string(version));
+		}
+	}
+}