Implement serialisation formats (#412)

Author: gentlegiantJGC

src/amulet/core/biome/biome.cpp

@@ -34,7 +34,7 @@ Biome Biome::deserialise(BinaryReader& reader)
         return { platform, version, namespace_, base_name };
     }
     default:
-        throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+        throw std::invalid_argument("Unsupported Biome version " + std::to_string(version_number));
     }
 }
 

src/amulet/core/block/block.py.cpp

@@ -291,6 +291,15 @@ void init_block(py::module m_parent)
                 py::tuple(py::cast(self.get_blocks())));
         });
 
+    BlockStack.def(
+        py::pickle(
+            [](const Amulet::BlockStack& self) -> py::bytes {
+                return py::bytes(Amulet::serialise(self));
+            },
+            [](py::bytes state) {
+                return Amulet::deserialise<Amulet::BlockStack>(state.cast<std::string>());
+            }));
+
     pyext::collections::def_Sequence_getitem_slice(BlockStack);
     pyext::collections::def_Sequence_contains(BlockStack);
     pyext::collections::def_Sequence_iter<Amulet::Block>(BlockStack);

src/amulet/core/block_entity/block_entity.cpp

@@ -1,17 +1,42 @@
+#include <amulet/nbt/nbt_encoding/binary.hpp>
+
 #include <amulet/core/dll.hpp>
 
 #include "block_entity.hpp"
 
 namespace Amulet {
 
-void BlockEntity::serialise(BinaryWriter&) const
+void BlockEntity::serialise(BinaryWriter& writer) const
 {
-    throw std::runtime_error("NotImplementedError");
+    writer.write_numeric<std::uint8_t>(1);
+    writer.write_size_and_bytes(get_platform());
+    get_version().serialise(writer);
+    writer.write_size_and_bytes(_namespace);
+    writer.write_size_and_bytes(_base_name);
+    Amulet::NBT::encode_nbt(writer, *_nbt);
 }
 
-BlockEntity BlockEntity::deserialise(BinaryReader&)
+BlockEntity BlockEntity::deserialise(BinaryReader& reader)
 {
-    throw std::runtime_error("NotImplementedError");
+    auto version_number = reader.read_numeric<std::uint8_t>();
+    switch (version_number) {
+    case 1: {
+        std::string platform { reader.read_size_and_bytes() };
+        VersionNumber version = VersionNumber::deserialise(reader);
+        std::string namespace_ { reader.read_size_and_bytes() };
+        std::string base_name { reader.read_size_and_bytes() };
+        auto named_tag = std::make_shared<Amulet::NBT::NamedTag>(Amulet::NBT::decode_nbt(reader));
+        return BlockEntity {
+            std::move(platform),
+            std::move(version),
+            std::move(namespace_),
+            std::move(base_name),
+            std::move(named_tag)
+        };
+    }
+    default:
+        throw std::invalid_argument("Unsupported BlockEntity version " + std::to_string(version_number));
+    }
 }
 
 bool BlockEntity::operator==(const BlockEntity& other) const

src/amulet/core/chunk/component/biome_3d_component.cpp

@@ -6,14 +6,42 @@ namespace Amulet {
 
 // Biome3DComponent
 
+void Biome3DComponentData::serialise(BinaryWriter& writer) const
+{
+    writer.write_numeric<std::uint8_t>(1);
+    _palette->serialise(writer);
+    _sections->serialise(writer);
+}
+Biome3DComponentData Biome3DComponentData::deserialise(BinaryReader& reader)
+{
+    auto version_number = reader.read_numeric<std::uint8_t>();
+    switch (version_number) {
+    case 1: {
+        auto palette = std::make_shared<BiomePalette>(BiomePalette::deserialise(reader));
+        auto sections = std::make_shared<SectionArrayMap>(SectionArrayMap::deserialise(reader));
+        return Biome3DComponentData { std::move(palette), std::move(sections) };
+    }
+    default:
+        throw std::invalid_argument("Unsupported Biome3DComponentData version " + std::to_string(version_number));
+    }
+}
+
 std::optional<std::string> Biome3DComponent::serialise() const
 {
-    throw std::runtime_error("NotImplementedError");
+    if (_value) {
+        return Amulet::serialise(**_value);
+    } else {
+        return std::nullopt;
+    }
 }
 // Deserialise the component
-void Biome3DComponent::deserialise(std::optional<std::string>)
+void Biome3DComponent::deserialise(std::optional<std::string> data)
 {
-    throw std::runtime_error("NotImplementedError");
+    if (data) {
+        _value = std::make_shared<Biome3DComponentData>(Amulet::deserialise<Biome3DComponentData>(*data));
+    } else {
+        _value = std::nullopt;
+    }
 }
 
 const std::string Biome3DComponent::ComponentID = "Amulet::Biome3DComponent";

src/amulet/core/chunk/component/biome_3d_component.hpp

@@ -59,6 +59,9 @@ class Biome3DComponentData {
     std::shared_ptr<BiomePalette> get_palette_ptr() { return _palette; }
     SectionArrayMap& get_sections() { return *_sections; }
     std::shared_ptr<SectionArrayMap> get_sections_ptr() { return _sections; }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static Biome3DComponentData deserialise(BinaryReader&);
 };
 
 class Biome3DComponent {

src/amulet/core/chunk/component/block_entity_component.cpp

@@ -6,13 +6,47 @@ namespace Amulet {
 
 // BlockEntityComponentData
 
-void BlockEntityComponentData::serialise(BinaryWriter&) const
+void BlockEntityComponentData::serialise(BinaryWriter& writer) const
 {
-    throw std::runtime_error("NotImplementedError");
+    writer.write_numeric<std::uint8_t>(1);
+    get_version_range().serialise(writer);
+    writer.write_numeric<std::uint16_t>(get_x_size());
+    writer.write_numeric<std::uint16_t>(get_z_size());
+
+    writer.write_numeric<std::uint64_t>(get_block_entities().size());
+    for (const auto& [coord, block_entity] : get_block_entities()) {
+        writer.write_numeric<std::uint16_t>(std::get<0>(coord));
+        writer.write_numeric<std::int64_t>(std::get<1>(coord));
+        writer.write_numeric<std::uint16_t>(std::get<2>(coord));
+        block_entity->serialise(writer);
+    }
 }
-BlockEntityComponentData BlockEntityComponentData::deserialise(BinaryReader&)
+BlockEntityComponentData BlockEntityComponentData::deserialise(BinaryReader& reader)
 {
-    throw std::runtime_error("NotImplementedError");
+    auto version_number = reader.read_numeric<std::uint8_t>();
+    switch (version_number) {
+    case 1: {
+        auto version_range = VersionRange::deserialise(reader);
+        auto x_size = reader.read_numeric<std::uint16_t>();
+        auto z_size = reader.read_numeric<std::uint16_t>();
+        BlockEntityComponentData block_entities {
+            std::move(version_range),
+            x_size,
+            z_size
+        };
+        auto block_entity_count = reader.read_numeric<std::uint64_t>();
+        for (std::uint16_t i = 0; i < block_entity_count; i++) {
+            auto dx = reader.read_numeric<std::uint16_t>();
+            auto y = reader.read_numeric<std::int64_t>();
+            auto dz = reader.read_numeric<std::uint16_t>();
+            auto block_entity = std::make_shared<BlockEntity>(BlockEntity::deserialise(reader));
+            block_entities.set({ dx, y, dz }, std::move(block_entity));
+        }
+        return block_entities;
+    }
+    default:
+        throw std::invalid_argument("Unsupported BlockEntityComponentData version " + std::to_string(version_number));
+    }
 }
 
 // BlockEntityComponent

src/amulet/core/chunk/component/section_array_map.py.cpp

@@ -233,5 +233,14 @@ py::module init_section_array_map(py::module m_parent)
     pyext::collections::def_MutableMapping_setdefault<std::int64_t, pyext::numpy::array_t<std::uint32_t>>(SectionArrayMap);
     pyext::collections::register_MutableMapping(SectionArrayMap);
 
+    SectionArrayMap.def(
+        py::pickle(
+            [](const Amulet::SectionArrayMap& self) -> py::bytes {
+                return py::bytes(Amulet::serialise(self));
+            },
+            [](py::bytes state) {
+                return Amulet::deserialise<Amulet::SectionArrayMap>(state.cast<std::string>());
+            }));
+
     return m;
 }

src/amulet/core/entity/entity.cpp

@@ -1,17 +1,52 @@
+#include <amulet/nbt/nbt_encoding/binary.hpp>
+
 #include <amulet/core/dll.hpp>
 #include <amulet/core/version/version.hpp>
 
 #include "entity.hpp"
 
 namespace Amulet {
 
-void Entity::serialise(BinaryWriter&) const
+void Entity::serialise(BinaryWriter& writer) const
 {
-    throw std::runtime_error("NotImplementedError");
+    writer.write_numeric<std::uint8_t>(1);
+    writer.write_size_and_bytes(get_platform());
+    get_version().serialise(writer);
+    writer.write_size_and_bytes(_namespace);
+    writer.write_size_and_bytes(_base_name);
+    writer.write_numeric<double>(_x);
+    writer.write_numeric<double>(_y);
+    writer.write_numeric<double>(_z);
+    Amulet::NBT::encode_nbt(writer, *_nbt);
 }
-Entity Entity::deserialise(BinaryReader&)
+
+Entity Entity::deserialise(BinaryReader& reader)
 {
-    throw std::runtime_error("NotImplementedError");
+    auto version_number = reader.read_numeric<std::uint8_t>();
+    switch (version_number) {
+    case 1: {
+        std::string platform { reader.read_size_and_bytes() };
+        VersionNumber version = VersionNumber::deserialise(reader);
+        std::string namespace_ { reader.read_size_and_bytes() };
+        std::string base_name { reader.read_size_and_bytes() };
+        double x = reader.read_numeric<double>();
+        double y = reader.read_numeric<double>();
+        double z = reader.read_numeric<double>();
+        auto named_tag = std::make_shared<Amulet::NBT::NamedTag>(Amulet::NBT::decode_nbt(reader));
+        return Entity {
+            std::move(platform),
+            std::move(version),
+            std::move(namespace_),
+            std::move(base_name),
+            x,
+            y,
+            z,
+            std::move(named_tag)
+        };
+    }
+    default:
+        throw std::invalid_argument("Unsupported BlockEntity version " + std::to_string(version_number));
+    }
 }
 
 bool Entity::operator==(const Entity& other) const

src/amulet/core/version/version.cpp

@@ -31,7 +31,7 @@ VersionNumber VersionNumber::deserialise(BinaryReader& reader)
         return vec;
     }
     default:
-        throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+        throw std::invalid_argument("Unsupported VersionNumber version " + std::to_string(version_number));
     }
 }
 
@@ -89,7 +89,7 @@ PlatformVersionContainer PlatformVersionContainer::deserialise(BinaryReader& rea
         return { platform, version };
     }
     default:
-        throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+        throw std::invalid_argument("Unsupported PlatformVersionContainer version " + std::to_string(version_number));
     }
 }
 
@@ -112,7 +112,7 @@ VersionRange VersionRange::deserialise(BinaryReader& reader)
         return { platform, min_version, max_version };
     }
     default:
-        throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+        throw std::invalid_argument("Unsupported VersionRange version " + std::to_string(version_number));
     }
 }
 
@@ -140,7 +140,7 @@ VersionRangeContainer VersionRangeContainer::deserialise(BinaryReader& reader)
         return VersionRange::deserialise(reader);
     }
     default:
-        throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+        throw std::invalid_argument("Unsupported VersionRangeContainer version " + std::to_string(version_number));
     }
 }