amulet-core 2.0.3a2__tar.gz → 2.0.3a3__tar.gz

{amulet_core-2.0.3a2/src/amulet_core.egg-info → amulet_core-2.0.3a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amulet-core
-Version: 2.0.3a2
+Version: 2.0.3a3
 Summary: A Python library for reading/writing Minecraft's various save formats.
 Author: James Clare, Ben Gothard
 Project-URL: Homepage, https://www.amuletmc.com

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/src/amulet/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-06-27T16:04:02+0100",
+ "date": "2025-06-30T07:54:37+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "e066fffa9dd7f65769e62a638a8b55659eae70d0",
- "version": "2.0.3a2"
+ "full-revisionid": "3d4ebbe5b281a06285d5e207cbbe5909f0e22a75",
+ "version": "2.0.3a3"
 }
 '''  # END VERSION_JSON
 

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/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));
     }
 }
 

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/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);

amulet_core-2.0.3a3/src/amulet/core/block_entity/block_entity.cpp

@@ -0,0 +1,51 @@
+#include <amulet/nbt/nbt_encoding/binary.hpp>
+
+#include <amulet/core/dll.hpp>
+
+#include "block_entity.hpp"
+
+namespace Amulet {
+
+void BlockEntity::serialise(BinaryWriter& writer) const
+{
+    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& reader)
+{
+    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
+{
+    return (
+        PlatformVersionContainer::operator==(other)
+        && _namespace == other._namespace
+        && _base_name == other._base_name
+        && Amulet::NBT::NBTTag_eq(*_nbt, *other._nbt));
+}
+
+}

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/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";

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/src/amulet/core/chunk/component/biome_3d_component.hpp

@@ -59,6 +59,9 @@ public:
     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 {

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/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

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/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;
 }

amulet_core-2.0.3a3/src/amulet/core/entity/entity.cpp

@@ -0,0 +1,64 @@
+#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& writer) const
+{
+    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& reader)
+{
+    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
+{
+    return (
+        PlatformVersionContainer::operator==(other)
+        && _namespace == other._namespace
+        && _base_name == other._base_name
+        && _x == other._x
+        && _y == other._y
+        && _z == other._z
+        && Amulet::NBT::NBTTag_eq(*_nbt, *other._nbt));
+}
+
+} // namespace Amulet

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3}/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));
     }
 }
 

{amulet_core-2.0.3a2 → amulet_core-2.0.3a3/src/amulet_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amulet-core
-Version: 2.0.3a2
+Version: 2.0.3a3
 Summary: A Python library for reading/writing Minecraft's various save formats.
 Author: James Clare, Ben Gothard
 Project-URL: Homepage, https://www.amuletmc.com

amulet_core-2.0.3a2/src/amulet/core/block_entity/block_entity.cpp

@@ -1,26 +0,0 @@
-#include <amulet/core/dll.hpp>
-
-#include "block_entity.hpp"
-
-namespace Amulet {
-
-void BlockEntity::serialise(BinaryWriter&) const
-{
-    throw std::runtime_error("NotImplementedError");
-}
-
-BlockEntity BlockEntity::deserialise(BinaryReader&)
-{
-    throw std::runtime_error("NotImplementedError");
-}
-
-bool BlockEntity::operator==(const BlockEntity& other) const
-{
-    return (
-        PlatformVersionContainer::operator==(other)
-        && _namespace == other._namespace
-        && _base_name == other._base_name
-        && Amulet::NBT::NBTTag_eq(*_nbt, *other._nbt));
-}
-
-}

amulet_core-2.0.3a2/src/amulet/core/entity/entity.cpp

@@ -1,29 +0,0 @@
-#include <amulet/core/dll.hpp>
-#include <amulet/core/version/version.hpp>
-
-#include "entity.hpp"
-
-namespace Amulet {
-
-void Entity::serialise(BinaryWriter&) const
-{
-    throw std::runtime_error("NotImplementedError");
-}
-Entity Entity::deserialise(BinaryReader&)
-{
-    throw std::runtime_error("NotImplementedError");
-}
-
-bool Entity::operator==(const Entity& other) const
-{
-    return (
-        PlatformVersionContainer::operator==(other)
-        && _namespace == other._namespace
-        && _base_name == other._base_name
-        && _x == other._x
-        && _y == other._y
-        && _z == other._z
-        && Amulet::NBT::NBTTag_eq(*_nbt, *other._nbt));
-}
-
-} // namespace Amulet