amulet-core 2.0a5__cp311-cp311-win_amd64.whl → 2.0a7__cp311-cp311-win_amd64.whl

amulet/level/java/chunk_components/java_raw_chunk_component.cpp

@@ -0,0 +1,56 @@
+#include <optional>
+#include <stdexcept>
+
+#include <amulet/io/binary_writer.hpp>
+#include <amulet/io/binary_reader.hpp>
+
+#include <amulet_nbt/nbt_encoding/binary.hpp>
+
+#include <amulet/level/java/chunk_components/java_raw_chunk_component.hpp>
+
+namespace Amulet {
+	const std::string JavaRawChunkComponent::ComponentID = "Amulet::JavaRawChunkComponent";
+
+	std::optional<std::string> JavaRawChunkComponent::serialise() const {
+		if (_raw_data) {
+			BinaryWriter writer;
+			writer.writeNumeric<std::uint8_t>(1);
+			const auto& raw_data = _raw_data.value();
+			writer.writeNumeric<std::uint64_t>(raw_data->size());
+			for (const auto& [k, v] : *raw_data) {
+				writer.writeSizeAndBytes(k);
+				AmuletNBT::write_nbt(writer, *v);
+			}
+			return writer.getBuffer();
+		}
+		else {
+			return std::nullopt;
+		}
+	}
+	void JavaRawChunkComponent::deserialise(std::optional<std::string> data) {
+		if (data) {
+			size_t position = 0;
+			BinaryReader reader(data.value(), position);
+			auto version = reader.readNumeric<std::uint8_t>();
+			switch (version) {
+				case 1:
+					{
+						auto raw_data = std::make_shared<Amulet::JavaRawChunkType>();
+						auto count = reader.readNumeric<std::uint64_t>();
+						for (auto i = 0; i < count; i++) {
+							auto key = reader.readSizeAndBytes();
+							auto tag = std::make_shared<AmuletNBT::NamedTag>(AmuletNBT::read_nbt(reader));
+							raw_data->emplace(key, tag);
+						}
+						_raw_data = raw_data;
+					}
+					break;
+				default:
+					throw std::invalid_argument("Unsupported JavaRawChunkComponent version " + std::to_string(version));
+			}
+		}
+		else {
+			_raw_data = std::nullopt;
+		}
+	}
+}

amulet/level/java/chunk_components/java_raw_chunk_component.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <optional>
+#include <cstdint>
+#include <string>
+#include <stdexcept>
+#include <memory>
+#include <map>
+#include <amulet_nbt/tag/named_tag.hpp>
+
+
+namespace Amulet {
+	typedef std::map<std::string, std::shared_ptr<AmuletNBT::NamedTag>> JavaRawChunkType;
+
+	class JavaRawChunkComponent {
+	private:
+		std::optional<std::shared_ptr<JavaRawChunkType>> _raw_data;
+	protected:
+		// Null constructor
+		JavaRawChunkComponent() {};
+		// Default constructor
+		void init(std::shared_ptr<JavaRawChunkType> raw_data) { _raw_data = raw_data; }
+		void init() { _raw_data = std::make_shared<JavaRawChunkType>(); }
+		// 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<JavaRawChunkType> get_raw_data() {
+			if (_raw_data) {
+				return *_raw_data;
+			}
+			throw std::runtime_error("JavaRawChunkComponent has not been loaded.");
+		};
+		void set_raw_data(std::shared_ptr<JavaRawChunkType> raw_data) {
+			if (_raw_data) {
+				_raw_data = raw_data;
+			}
+			else {
+				throw std::runtime_error("JavaRawChunkComponent has not been loaded.");
+			}
+		}
+	};
+}

amulet/level/java/java_chunk.cpp

@@ -0,0 +1,170 @@
+#include <string>
+#include <optional>
+#include <vector>
+#include <unordered_map>
+#include <cstdint>
+
+#include <amulet/chunk.hpp>
+#include <amulet/level/java/java_chunk.hpp>
+#include <amulet/chunk_components/block_component.hpp>
+
+namespace Amulet {
+	const std::string JavaChunkNA::ChunkID = "Amulet::JavaChunkNA";
+	const std::string JavaChunk0::ChunkID = "Amulet::JavaChunk0";
+	const std::string JavaChunk1444::ChunkID = "Amulet::JavaChunk1444";
+	const std::string JavaChunk1466::ChunkID = "Amulet::JavaChunk1466";
+	const std::string JavaChunk2203::ChunkID = "Amulet::JavaChunk2203";
+	
+	std::string JavaChunkNA::get_chunk_id() const { return ChunkID; }
+	std::string JavaChunk0::get_chunk_id() const { return ChunkID; }
+	std::string JavaChunk1444::get_chunk_id() const { return ChunkID; }
+	std::string JavaChunk1466::get_chunk_id() const { return ChunkID; }
+	std::string JavaChunk2203::get_chunk_id() const { return ChunkID; }
+	
+	JavaChunkNA::JavaChunkNA(
+		std::shared_ptr<BlockStack> default_block,
+		std::shared_ptr<Biome> default_biome
+	) : ChunkComponentHelper() {
+		auto version_number = std::make_shared<VersionNumber>(
+			std::initializer_list<std::int64_t>{ -1 }
+		);
+		auto version_range = std::make_shared<VersionRange>(
+			"java",
+			version_number,
+			version_number
+		);
+		JavaRawChunkComponent::init();
+		DataVersionComponent::init(-1);
+		BlockComponent::init(
+			version_range,
+			SectionShape(
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16)
+			),
+			default_block
+		);
+	}
+
+	JavaChunk0::JavaChunk0(
+		std::int64_t data_version,
+		std::shared_ptr<BlockStack> default_block,
+		std::shared_ptr<Biome> default_biome
+	) : ChunkComponentHelper() {
+		if (data_version < 0 || 1443 < data_version) {
+			throw std::invalid_argument("data version must be between 0 and 1443");
+		}
+		auto version_number = std::make_shared<VersionNumber>(
+			std::initializer_list<std::int64_t>{ data_version }
+		);
+		auto version_range = std::make_shared<VersionRange>(
+			"java",
+			version_number,
+			version_number
+			);
+		JavaRawChunkComponent::init();
+		DataVersionComponent::init(data_version);
+		BlockComponent::init(
+			version_range,
+			SectionShape(
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16)
+			),
+			default_block
+		);
+	}
+
+	JavaChunk1444::JavaChunk1444(
+		std::int64_t data_version,
+		std::shared_ptr<BlockStack> default_block,
+		std::shared_ptr<Biome> default_biome
+	) : ChunkComponentHelper() {
+		if (data_version < 1444 || 1465 < data_version) {
+			throw std::invalid_argument("data version must be between 1443 and 1465");
+		}
+		auto version_number = std::make_shared<VersionNumber>(
+			std::initializer_list<std::int64_t>{ data_version }
+		);
+		auto version_range = std::make_shared<VersionRange>(
+			"java",
+			version_number,
+			version_number
+			);
+		JavaRawChunkComponent::init();
+		DataVersionComponent::init(data_version);
+		BlockComponent::init(
+			version_range,
+			SectionShape(
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16)
+			),
+			default_block
+		);
+	}
+
+	JavaChunk1466::JavaChunk1466(
+		std::int64_t data_version,
+		std::shared_ptr<BlockStack> default_block,
+		std::shared_ptr<Biome> default_biome
+	) : ChunkComponentHelper() {
+		if (data_version < 1466 || 2202 < data_version) {
+			throw std::invalid_argument("data version must be between 1466 and 2202");
+		}
+		auto version_number = std::make_shared<VersionNumber>(
+			std::initializer_list<std::int64_t>{ data_version }
+		);
+		auto version_range = std::make_shared<VersionRange>(
+			"java",
+			version_number,
+			version_number
+			);
+		JavaRawChunkComponent::init();
+		DataVersionComponent::init(data_version);
+		BlockComponent::init(
+			version_range,
+			SectionShape(
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16)
+			),
+			default_block
+		);
+	}
+
+	JavaChunk2203::JavaChunk2203(
+		std::int64_t data_version,
+		std::shared_ptr<BlockStack> default_block,
+		std::shared_ptr<Biome> default_biome
+	) : ChunkComponentHelper() {
+		if (data_version < 2203) {
+			throw std::invalid_argument("data version must be at least 2203");
+		}
+		auto version_number = std::make_shared<VersionNumber>(
+			std::initializer_list<std::int64_t>{ data_version }
+		);
+		auto version_range = std::make_shared<VersionRange>(
+			"java",
+			version_number,
+			version_number
+			);
+		JavaRawChunkComponent::init();
+		DataVersionComponent::init(data_version);
+		BlockComponent::init(
+			version_range,
+			SectionShape(
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16),
+				static_cast<std::uint16_t>(16)
+			),
+			default_block
+		);
+	}
+
+	static const ChunkNullConstructor<JavaChunkNA> _jcna;
+	static const ChunkNullConstructor<JavaChunk0> _jc0;
+	static const ChunkNullConstructor<JavaChunk1444> _jc1444;
+	static const ChunkNullConstructor<JavaChunk1466> _jc1466;
+	static const ChunkNullConstructor<JavaChunk2203> _jc2203;
+}

amulet/level/java/java_chunk.hpp

@@ -0,0 +1,141 @@
+#pragma once
+
+#include <string>
+#include <optional>
+#include <stdexcept>
+#include <vector>
+#include <amulet/block.hpp>
+#include <amulet/biome.hpp>
+#include <amulet/chunk.hpp>
+#include <amulet/chunk_components/block_component.hpp>
+#include "chunk_components/java_raw_chunk_component.hpp"
+#include "chunk_components/data_version_component.hpp"
+
+namespace Amulet {
+	class JavaChunk : public Chunk {};
+
+	class JavaChunkNA : public ChunkComponentHelper<
+		JavaChunk,
+		JavaRawChunkComponent,
+		DataVersionComponent,
+		// LastUpdateComponent,
+		// JavaLegacyVersionComponent,
+		BlockComponent//,
+		// BlockEntityComponent,
+		// EntityComponent,
+		// Biome2DComponent,
+		// Height2DComponent,
+	> {
+	public:
+		static const std::string ChunkID;
+
+		std::string get_chunk_id() const override;
+
+		using ChunkComponentHelper::ChunkComponentHelper;
+		JavaChunkNA(
+			std::shared_ptr<BlockStack> default_block,
+			std::shared_ptr<Biome> default_biome
+		);
+	};
+
+	class JavaChunk0 : public ChunkComponentHelper<
+		JavaChunk,
+		JavaRawChunkComponent,
+		DataVersionComponent,
+		// LastUpdateComponent,
+		// TerrainPopulatedComponent,
+		// LightPopulatedComponent,
+		BlockComponent//,
+		// BlockEntityComponent,
+		// EntityComponent,
+		// Biome2DComponent,
+		// Height2DComponent,
+	> {
+	public:
+		static const std::string ChunkID;
+
+		std::string get_chunk_id() const override;
+
+		using ChunkComponentHelper::ChunkComponentHelper;
+		JavaChunk0(
+			std::int64_t data_version,
+			std::shared_ptr<BlockStack> default_block,
+			std::shared_ptr<Biome> default_biome
+		);
+	};
+
+	class JavaChunk1444 : public ChunkComponentHelper<
+		JavaChunk,
+		JavaRawChunkComponent,
+		DataVersionComponent,
+		// LastUpdateComponent,
+		// StatusStringComponent,
+		BlockComponent//,
+		// BlockEntityComponent,
+		// EntityComponent,
+		// Biome2DComponent,
+		// Height2DComponent,
+	> {
+	public:
+		static const std::string ChunkID;
+
+		std::string get_chunk_id() const override;
+
+		using ChunkComponentHelper::ChunkComponentHelper;
+		JavaChunk1444(
+			std::int64_t data_version,
+			std::shared_ptr<BlockStack> default_block,
+			std::shared_ptr<Biome> default_biome
+		);
+	};
+
+	class JavaChunk1466 : public ChunkComponentHelper<
+		JavaChunk,
+		JavaRawChunkComponent,
+		DataVersionComponent,
+		// LastUpdateComponent,
+		// StatusStringComponent,
+		BlockComponent//,
+		// BlockEntityComponent,
+		// EntityComponent,
+		// Biome2DComponent,
+		// NamedHeight2DComponent,
+	> {
+	public:
+		static const std::string ChunkID;
+
+		std::string get_chunk_id() const override;
+
+		using ChunkComponentHelper::ChunkComponentHelper;
+		JavaChunk1466(
+			std::int64_t data_version,
+			std::shared_ptr<BlockStack> default_block,
+			std::shared_ptr<Biome> default_biome
+		);
+	};
+
+	class JavaChunk2203 : public ChunkComponentHelper<
+		JavaChunk,
+		JavaRawChunkComponent,
+		DataVersionComponent,
+		// LastUpdateComponent,
+		// StatusStringComponent,
+		BlockComponent//,
+		// BlockEntityComponent,
+		// EntityComponent,
+		// Biome3DComponent,
+		// NamedHeight2DComponent,
+	> {
+	public:
+		static const std::string ChunkID;
+
+		std::string get_chunk_id() const override;
+
+		using ChunkComponentHelper::ChunkComponentHelper;
+		JavaChunk2203(
+			std::int64_t data_version,
+			std::shared_ptr<BlockStack> default_block,
+			std::shared_ptr<Biome> default_biome
+		);
+	};
+}

amulet/level/java/long_array.hpp

@@ -0,0 +1,175 @@
+#pragma once
+#include <span>
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <cmath>
+#include <algorithm>
+#include <bit>
+#include <type_traits>
+
+namespace Amulet {
+	/*
+	Minecraft Java edition stores the block and height arrays in a compacted long array format.
+	The format stores one or more entries per long, using the fewest number of bits required to store the data.
+	There are two storage methods, the compact version was used prior to 1.16 and the less compact version in 1.16 and above.
+	Apparently the less compact version is quicker to pack and unpack.
+	The compact version effectively stores the values as a bit array spanning one or more values in the long array.
+	There may be some padding if the bit array does not fill all the long values. (The letter "P" signifies an unused padding bit)
+	HGGGGGGGGGFFFFFFFFFEEEEEEEEEDDDDDDDDDCCCCCCCCCBBBBBBBBBAAAAAAAAA PPNNNNNNNNNMMMMMMMMMLLLLLLLLLKKKKKKKKKJJJJJJJJJIIIIIIIIIHHHHHHHH
+	The less compact version does not allow entries to straddle long values. Instead, if required, there is padding within each long.
+	PGGGGGGGGGFFFFFFFFFEEEEEEEEEDDDDDDDDDCCCCCCCCCBBBBBBBBBAAAAAAAAA PNNNNNNNNNMMMMMMMMMLLLLLLLLLKKKKKKKKKJJJJJJJJJIIIIIIIIIHHHHHHHHH
+	*/
+
+	template <typename decodedT>
+	void decode_long_array(
+		const std::span<std::uint64_t>& encoded,  // The long array to decode
+		std::span<decodedT>& decoded,  // The array to unpack values into
+		std::uint8_t bits_per_entry,  // The number of bits per entry
+		bool dense = true
+	) {
+		static_assert(std::is_unsigned_v<decodedT>, "decodedT must be unsigned");
+		if (bits_per_entry < 1 || 64 < bits_per_entry) {
+			throw std::invalid_argument("bits_per_entry must be between 1 and 64 inclusive. Got " + std::to_string(bits_per_entry));
+		}
+
+		size_t expected_len = std::ceil(
+			dense ? static_cast<float>(decoded.size()) * bits_per_entry / 64 : static_cast<float>(decoded.size()) / (64 / bits_per_entry)
+		);
+
+		if (encoded.size() != expected_len) {
+			throw std::invalid_argument(
+				dense ? "Dense encoded long array with " : "Encoded long array with " +
+				std::to_string(bits_per_entry) +
+				" bits per entry should contain " +
+				std::to_string(expected_len) +
+				" longs but got " +
+				std::to_string(encoded.size()) +
+				"."
+			);
+		}
+
+		const std::uint64_t mask = ~0ull >> (64 - bits_per_entry);
+		if (dense) {
+			for (size_t decoded_index = 0; decoded_index < decoded.size(); decoded_index++) {
+				size_t bit_start = decoded_index * bits_per_entry;
+				size_t bit_stop = (decoded_index + 1) * bits_per_entry;
+				size_t long_start = bit_start / 64;
+				decodedT& value = decoded[decoded_index];
+				value = (encoded[long_start] >> (bit_start % 64)) & mask;
+				if ((long_start + 1) * 64 < bit_stop) {
+					// Overflows into the next long
+					size_t overflow_bits = bit_stop - (long_start + 1) * 64;
+					size_t previous_bits = bits_per_entry - overflow_bits;
+					value |= (encoded[long_start + 1] & (mask >> previous_bits)) << previous_bits;
+				}
+			}
+		}
+		else {
+			size_t entries_per_long = 64 / bits_per_entry;
+			size_t decoded_index = 0;
+			for (const auto& encoded_value : encoded) {
+				for (
+					size_t offset = 0;
+					offset < entries_per_long && decoded_index < decoded.size();
+					offset++, decoded_index++
+				) {
+					decoded[decoded_index] = (encoded_value >> (bits_per_entry * offset)) & mask;
+				}
+			}
+		}
+	}
+
+	// Get the number of longs required to store the encoded long array.
+	inline size_t encoded_long_array_size(
+		size_t decoded_size,  // The number of elements to encode
+		std::uint8_t bits_per_entry,  // The number of bits of each number to use
+		bool dense = true
+	) {
+		if (dense) {
+			return std::ceil(static_cast<float>(decoded_size * bits_per_entry) / 64);
+		}
+		else {
+			size_t entries_per_long = 64 / bits_per_entry;
+			return std::ceil(static_cast<float>(decoded_size) / entries_per_long);
+		}
+	}
+
+	// Encode the array to a long array with the specified number of bits. Extra bits are ignored.
+	template <typename decodedT>
+	void encode_long_array(
+		const std::span<decodedT>& decoded,  // The array to encode
+		std::span<std::uint64_t> encoded,  // The array to encode into. This must be large enough.
+		std::uint8_t bits_per_entry,  // The number of bits of each number to use
+		bool dense = true
+	) {
+		static_assert(std::is_unsigned_v<decodedT>, "decodedT must be unsigned");
+		if (bits_per_entry < 1 || 64 < bits_per_entry) {
+			throw std::invalid_argument("bits_per_entry must be between 1 and 64 inclusive. Got " + std::to_string(bits_per_entry));
+		}
+
+		// Set all values to 0
+		std::fill(encoded.begin(), encoded.end(), 0);
+		const std::uint64_t mask = ~0ull >> (64 - bits_per_entry);
+		if (dense) {
+			for (size_t decoded_index = 0; decoded_index < decoded.size(); decoded_index++) {
+				// The bit in the array where the value starts
+				size_t bit_start = decoded_index * bits_per_entry;
+				// The bit in the array where the value stops
+				size_t bit_stop = bit_start + bits_per_entry;
+				// The long number that the value starts in
+				size_t long_start = bit_start / 64;
+				// The bit offset in the long where the value starts
+				size_t long_bit_offset = bit_start % 64;
+				// The bit in the array where the long stops
+				size_t long_bit_stop = (long_start + 1) * 64;
+				decodedT& value = decoded[decoded_index];
+				encoded[long_start] = (encoded[long_start] & ~(mask << long_bit_offset)) + ((value & mask) << long_bit_offset);
+				if (long_bit_stop < bit_stop) {
+					// Overflows into the next long
+					// The number of bits that overflow into the next long
+					size_t overflow_bits = bit_stop - long_bit_stop;
+					// The number of bits in the previous long
+					size_t previous_bits = bits_per_entry - overflow_bits;
+					encoded[long_start + 1] = (encoded[long_start + 1] & ~(mask >> previous_bits)) + ((value & mask) >> previous_bits);
+				}
+			}
+		}
+		else {
+			size_t entries_per_long = 64 / bits_per_entry;
+			size_t decoded_index = 0;
+			size_t long_count = std::ceil(static_cast<float>(decoded.size()) / entries_per_long);
+			for (size_t encoded_index = 0; encoded_index < long_count; encoded_index++) {
+				auto& encoded_value = encoded[encoded_index];
+				encoded_value = 0;
+				for (
+					size_t offset = 0;
+					offset < entries_per_long && decoded_index < decoded.size();
+					offset++, decoded_index++
+				) {
+					std::uint64_t value = decoded[decoded_index] & mask;
+					encoded_value += value << (bits_per_entry * offset);
+				}
+			}
+		}
+	}
+
+	// Encode the array to a long aray with at least this number of bits. The number of required bits is computed before encoding.
+	template <typename decodedT>
+	void encode_long_array_min(
+		const std::span<decodedT>& decoded,  // The array to encode
+		std::span<std::uint64_t> encoded,  // The array to encode into
+		std::uint8_t min_bits_per_entry,  // The minimum number of bits of each number to use
+		bool dense = true
+	) {
+		static_assert(std::is_unsigned_v<decodedT>, "decodedT must be unsigned");
+		if (min_bits_per_entry < 1 || 64 < min_bits_per_entry) {
+			throw std::invalid_argument("min_bits_per_entry must be between 1 and 64 inclusive. Got " + std::to_string(min_bits_per_entry));
+		}
+		std::uint8_t bits_per_entry = std::max(
+			min_bits_per_entry, 
+			std::bit_width(*std::max_element(decoded.begin(), decoded.end()))
+		);
+		encode_long_array(decoded, encoded, bits_per_entry, dense);
+	}
+}

amulet/level/java/long_array.pyi

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import numpy
+import numpy.typing
 import typing_extensions
 
 __all__ = ["decode_long_array", "encode_long_array"]
@@ -26,7 +27,7 @@ def encode_long_array(
     bits_per_entry: None | int = None,
     dense: bool = True,
     min_bits_per_entry: int = 1,
-) -> numpy.ndarray[numpy.uint64]:
+) -> numpy.typing.NDArray[numpy.uint64]:
     """
     Encode a long array (from BlockStates or Heightmaps)
 

amulet/mesh/block/__init__.py

@@ -0,0 +1 @@
+from .block_mesh import BlockMesh