amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1a2.post250529084738__cp311-cp311-win_amd64.whl

amulet/chunk.py.cpp

@@ -1,80 +0,0 @@
-#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

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-__all__ = ["Chunk", "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) -> list[str]: ...
-
-def get_null_chunk(arg0: str) -> Chunk:
-    """
-    This is a private function
-    """

amulet/chunk_components/biome_3d_component.cpp

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

amulet/chunk_components/biome_3d_component.hpp

@@ -1,79 +0,0 @@
-#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

@@ -1,41 +0,0 @@
-#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

@@ -1,88 +0,0 @@
-#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

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

amulet/chunk_components/block_entity_component.hpp

@@ -1,147 +0,0 @@
-#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

@@ -1,129 +0,0 @@
-#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));
-		}
-	}
-}