amulet-core 2.0a3__cp311-cp311-win_amd64.whl

amulet/__init__.pyi

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from . import (
+    biome,
+    block,
+    block_entity,
+    chunk,
+    chunk_components,
+    collections,
+    level,
+    palette,
+    utils,
+    version,
+)
+
+__all__ = [
+    "IMG_DIRECTORY",
+    "biome",
+    "block",
+    "block_entity",
+    "chunk",
+    "chunk_components",
+    "collections",
+    "level",
+    "palette",
+    "utils",
+    "version",
+]
+IMG_DIRECTORY: str
+__version__: str

amulet/__pyinstaller/__init__.py

@@ -0,0 +1,2 @@
+def get_hook_dirs() -> list[str]:
+    return __path__

amulet/__pyinstaller/hook-amulet.py

@@ -0,0 +1,4 @@
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+hiddenimports = collect_submodules("amulet")
+datas = collect_data_files("amulet")

amulet/_init.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+
+def init(m: Any) -> None:
+    import os
+    import logging
+    import platformdirs
+
+    from ._version import get_versions
+
+    m.__version__ = get_versions()["version"]
+
+    # m.entity_support = False
+
+    m.IMG_DIRECTORY = os.path.join(os.path.dirname(__file__), "img")
+
+    # Initialise default paths. Applications should override these environment variables.
+    # os.environ.setdefault("DATA_DIR", platformdirs.user_data_dir("AmuletTeam", "AmuletTeam"))
+    # os.environ.setdefault("CONFIG_DIR", platformdirs.user_config_dir("AmuletTeam", "AmuletTeam"))
+    os.environ.setdefault(
+        "CACHE_DIR", platformdirs.user_cache_dir("AmuletTeam", "AmuletTeam")
+    )
+    os.environ.setdefault(
+        "LOG_DIR", platformdirs.user_log_dir("AmuletTeam", "AmuletTeam")
+    )
+
+    # init a default logger
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")

amulet/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2024-09-17T11:48:57+0100",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "c74042d82cf944a7ef539dba6a51abb17b5c5d2a",
+ "version": "2.0a3"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

amulet/biome.cpp

@@ -0,0 +1,36 @@
+#include <map>
+#include <variant>
+#include <type_traits>
+#include <string>
+#include <functional>
+#include <stdexcept>
+
+#include <amulet/biome.hpp>
+#include <amulet_nbt/nbt_encoding/binary.hpp>
+#include <amulet_nbt/nbt_encoding/string.hpp>
+
+namespace Amulet {
+    void Biome::serialise(BinaryWriter& writer) const {
+        writer.writeNumeric<std::uint8_t>(1);
+        writer.writeSizeAndBytes(get_platform());
+        get_version()->serialise(writer);
+        writer.writeSizeAndBytes(namespace_);
+        writer.writeSizeAndBytes(base_name);
+    }
+    std::shared_ptr<Biome> Biome::deserialise(BinaryReader& reader){
+        auto version_number = reader.readNumeric<std::uint8_t>();
+        switch (version_number) {
+        case 1:
+        {
+            std::string platform = reader.readSizeAndBytes();
+            std::shared_ptr<VersionNumber> version = VersionNumber::deserialise(reader);
+            std::string namespace_ = reader.readSizeAndBytes();
+            std::string base_name = reader.readSizeAndBytes();
+            return std::make_shared<Biome>(platform, version, namespace_, base_name);
+        }
+        default:
+            throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+        }
+    }
+
+}

amulet/biome.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+
+#include <amulet/version.hpp>
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+
+namespace Amulet {
+    class Biome: public PlatformVersionContainer {
+        private:
+            std::string namespace_;
+            std::string base_name;
+        public:
+            const std::string& get_namespace() const { return namespace_; }
+            const std::string& get_base_name() const { return base_name; }
+
+            Biome(
+                const PlatformType& platform,
+                std::shared_ptr<VersionNumber> version,
+                const std::string& namespace_,
+                const std::string& base_name
+            ):
+                PlatformVersionContainer(platform, version),
+                namespace_(namespace_),
+                base_name(base_name) {}
+
+            void serialise(BinaryWriter&) const;
+            static std::shared_ptr<Biome> deserialise(BinaryReader&);
+
+            auto operator<=>(const Biome& other) const {
+                auto cmp = PlatformVersionContainer::operator<=>(other);
+                if (cmp != 0) { return cmp; }
+                cmp = namespace_ <=> other.namespace_;
+                if (cmp != 0) { return cmp; }
+                return base_name <=> other.base_name;
+            }
+            bool operator==(const Biome& other) const {
+                return (*this <=> other) == 0;
+            };
+    };
+}

amulet/biome.pyi

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.version
+
+__all__ = ["Biome"]
+
+class Biome(amulet.version.PlatformVersionContainer):
+    """
+    A class to manage the state of a biome.
+
+    It is an immutable object that contains the platform, version, namespace and base name.
+
+    Here's a few examples on how create a Biome object:
+
+    >>> # Create a plains biome for Java 1.20.2
+    >>> plains = Biome("java", VersionNumber(3578), "minecraft", "plains")
+    >>> # The version number for Java is the Java data version
+
+    >>> # Create a plains biome for Bedrock
+    >>> plains = Biome("bedrock", VersionNumber(1, 21, 0, 3), "minecraft", "plains")
+    >>> # The biome version number is unused in Bedrock but it is here for completeness.
+    """
+
+    @typing.overload
+    def __eq__(self, arg0: Biome) -> bool: ...
+    @typing.overload
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __ge__(self, arg0: Biome) -> bool: ...
+    def __getstate__(self) -> bytes: ...
+    def __gt__(self, arg0: Biome) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __init__(
+        self,
+        platform: str,
+        version: amulet.version.VersionNumber,
+        namespace: str,
+        base_name: str,
+    ) -> None: ...
+    def __le__(self, arg0: Biome) -> bool: ...
+    def __lt__(self, arg0: Biome) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __setstate__(self, arg0: bytes) -> None: ...
+    @property
+    def base_name(self) -> str:
+        """
+        The base name of the :class:`Biome` object.
+
+        >>> biome: Biome
+        >>> biome.base_name
+
+        :return: The base name of the biome
+        """
+
+    @property
+    def namespace(self) -> str:
+        """
+        The namespace of the :class:`Biome` object.
+
+        >>> biome: Biome
+        >>> water.namespace
+
+        :return: The namespace of the biome
+        """
+
+    @property
+    def namespaced_name(self) -> str:
+        """
+        The namespaced id of the :class:`Biome` object.
+
+        >>> biome: Biome
+        >>> biome.namespaced_name
+
+        :return: The "namespace:base_name" of the biome
+        """

amulet/block.cpp

@@ -0,0 +1,435 @@
+#include <map>
+#include <variant>
+#include <type_traits>
+#include <string>
+#include <functional>
+#include <stdexcept>
+
+#include <amulet/block.hpp>
+#include <amulet_nbt/nbt_encoding/binary.hpp>
+#include <amulet_nbt/nbt_encoding/string.hpp>
+
+namespace Amulet {
+    void Block::serialise(BinaryWriter& writer) const {
+        writer.writeNumeric<std::uint8_t>(1);
+        writer.writeSizeAndBytes(get_platform());
+        get_version()->serialise(writer);
+        writer.writeSizeAndBytes(namespace_);
+        writer.writeSizeAndBytes(base_name);
+        
+        writer.writeNumeric<std::uint64_t>(properties.size());
+        for (auto const& [key, val] : properties) {
+            writer.writeSizeAndBytes(key);
+            std::visit([&writer](auto&& tag) {
+                AmuletNBT::write_nbt(writer, "", tag);
+            }, val);
+        }
+    }
+    std::shared_ptr<Block> Block::deserialise(BinaryReader& reader){
+        auto version_number = reader.readNumeric<std::uint8_t>();
+        switch (version_number) {
+        case 1:
+        {
+            std::string platform = reader.readSizeAndBytes();
+            std::shared_ptr<VersionNumber> version = VersionNumber::deserialise(reader);
+            std::string namespace_ = reader.readSizeAndBytes();
+            std::string base_name = reader.readSizeAndBytes();
+            std::uint64_t property_count;
+            BlockProperites properties;
+            reader.readNumericInto<std::uint64_t>(property_count);
+            for (std::uint64_t i = 0; i < property_count; i++) {
+                std::string name = reader.readSizeAndBytes();
+                AmuletNBT::NamedTag named_tag = AmuletNBT::read_nbt(reader);
+                properties[name] = std::visit([](auto&& tag) -> PropertyValueType {
+                    using T = std::decay_t<decltype(tag)>;
+                    if constexpr (
+                        std::is_same_v<T, AmuletNBT::ByteTag> ||
+                        std::is_same_v<T, AmuletNBT::ShortTag> ||
+                        std::is_same_v<T, AmuletNBT::IntTag> ||
+                        std::is_same_v<T, AmuletNBT::LongTag> ||
+                        std::is_same_v<T, AmuletNBT::StringTag>
+                    ) {
+                        return tag;
+                    }
+                    else {
+                        throw std::invalid_argument("Property tag must be Byte, Short, Int, Long or String");
+                    }
+                }, named_tag.tag_node);
+            }
+            return std::make_shared<Block>(platform, version, namespace_, base_name, properties);
+        }
+        default:
+            throw std::invalid_argument("Unsupported Block version " + std::to_string(version_number));
+        }
+    }
+
+    template <typename T>
+    inline std::vector<std::string> get_ordered_keys(const T& map) {
+        std::vector<std::string> keys;
+        keys.reserve(map.size());
+        for (const auto& [key, _] : map) {
+            keys.push_back(key);
+        }
+        std::sort(keys.begin(), keys.end());
+        return keys;
+    }
+
+    std::string Block::java_blockstate() const {
+        std::string blockstate;
+        blockstate += get_namespace();
+        blockstate += ":";
+        blockstate += get_base_name();
+        const auto& properties = get_properties();
+        if (!properties.empty()) {
+            blockstate += "[";
+            auto keys = get_ordered_keys(properties);
+            bool is_first = true;
+            for (const std::string& key : keys) {
+                const auto& it = properties.find(key);
+                std::visit(
+                    [&is_first, &blockstate, &key](auto&& tag) {
+                        using T = std::decay_t<decltype(tag)>;
+                        if constexpr (std::is_same_v<T, AmuletNBT::StringTag>) {
+                            if (is_first) {
+                                is_first = false;
+                            }
+                            else {
+                                blockstate += ",";
+                            }
+                            blockstate += key;
+                            blockstate += "=";
+                            blockstate += tag;
+                        }
+                    },
+                    it->second
+                );
+            }
+            blockstate += "]";
+        }
+        return blockstate;
+    }
+    std::string Block::bedrock_blockstate() const {
+        std::string blockstate;
+        blockstate += get_namespace();
+        blockstate += ":";
+        blockstate += get_base_name();
+        const auto& properties = get_properties();
+        if (!properties.empty()) {
+            blockstate += "[";
+            auto keys = get_ordered_keys(properties);
+            bool is_first = true;
+            for (const std::string& key : keys) {
+                const auto& it = properties.find(key);
+                std::visit(
+                    [&is_first, &blockstate, &key](auto&& tag) {
+                        if (is_first) {
+                            is_first = false;
+                        }
+                        else {
+                            blockstate += ",";
+                        }
+                        blockstate += "\"";
+                        blockstate += key;
+                        blockstate += "\"=";
+                        using T = std::decay_t<decltype(tag)>;
+                        if constexpr (std::is_same_v<T, AmuletNBT::ByteTag>) {
+                            if (tag == 0) {
+                                blockstate += "false";
+                            } else if (tag == 1) {
+                                blockstate += "true";
+                            }
+                            else {
+                                blockstate += AmuletNBT::write_snbt(tag);
+                            }
+                        }
+                        else if constexpr (std::is_same_v<T, AmuletNBT::StringTag>) {
+                            blockstate += "\"";
+                            blockstate += tag;
+                            blockstate += "\"";
+                        }
+                        else {
+                            blockstate += AmuletNBT::write_snbt(tag);
+                        }
+                    },
+                    it->second
+                );
+            }
+            blockstate += "]";
+        }
+        return blockstate;
+    }
+
+    template <
+        void(*namespace_validator)(const size_t&, const std::string&),
+        void(*base_name_validator)(const size_t&, const std::string&),
+        std::string(*capture_key)(const std::string&, size_t&),
+        PropertyValueType(*capture_value)(const std::string&, size_t&)
+    >
+    std::shared_ptr<Block> parse_blockstate(
+        const PlatformType& platform,
+        std::shared_ptr<VersionNumber> version,
+        const std::string& blockstate
+    ) {
+        // This is more lenient than the game parser.
+        // It may parse formats that the game parsers wouldn't parse but it should support everything they do parse.
+        
+        // Find the start of the property section and the end of the resource identifier.
+        size_t property_start = blockstate.find("[");
+        if (property_start > blockstate.size()) {
+            property_start = blockstate.size();
+        }
+
+        size_t colon_pos = blockstate.find(":");
+        std::string namespace_;
+        std::string base_name;
+        if (colon_pos < property_start) {
+            // namespaced name
+            if (colon_pos == 0) { throw std::invalid_argument("namespace is empty"); }
+            namespace_ = std::string(blockstate.begin(), blockstate.begin() + colon_pos);
+            if (colon_pos + 1 == property_start) { throw std::invalid_argument("base name is empty"); }
+            base_name = std::string(blockstate.begin() + colon_pos + 1, blockstate.begin() + property_start);
+            namespace_validator(0, namespace_);
+            base_name_validator(colon_pos + 1, base_name);
+        }
+        else {
+            // only base name
+            namespace_ = "minecraft";
+            if (property_start == 0) { throw std::invalid_argument("base name is empty"); }
+            base_name = std::string(blockstate.begin(), blockstate.begin() + property_start);
+            base_name_validator(0, base_name);
+        }
+
+        if (property_start < blockstate.size()) {
+            // has properties
+            BlockProperites properties;
+            size_t property_pos = property_start + 1;
+            if (property_pos < blockstate.size() && blockstate[property_pos] == ']') {
+                // []
+                property_pos++;
+                if (property_pos < blockstate.size()) {
+                    throw std::invalid_argument("Extra data after ]");
+                }
+                return std::make_shared<Block>(platform, version, namespace_, base_name, properties);
+            }
+            for (;;) {
+                std::string key = capture_key(blockstate, property_pos);
+
+                if (property_pos >= blockstate.size() || blockstate[property_pos] != '=') {
+                    throw std::invalid_argument("Expected = at position " + std::to_string(property_pos));
+                }
+                property_pos++;
+
+                properties[key] = capture_value(blockstate, property_pos);
+
+                if (property_pos >= blockstate.size()) {
+                    throw std::invalid_argument("Expected , or ] at position " + std::to_string(property_pos));
+                }
+                switch (blockstate[property_pos]) {
+                    case ',':
+                        break;
+                    case ']':
+                        property_pos++;
+                        if (property_pos < blockstate.size()) {
+                            throw std::invalid_argument("Extra data after ]");
+                        }
+                        return std::make_shared<Block>(platform, version, namespace_, base_name, properties);
+                    default:
+                        throw std::invalid_argument("Expected , or ] at position " + std::to_string(property_pos));
+                }
+                property_pos++;
+            }
+        }
+        else {
+            // does not have properties
+            return std::make_shared<Block>(platform, version, namespace_, base_name);
+        }
+    }
+
+    auto is_alnum = [](const char& chr) {
+        return (
+            ('0' <= chr && chr <= '9') ||
+            ('a' <= (chr | 32) && (chr | 32) <= 'z')
+        );
+    };
+    
+    inline void validate_java_namespace(const size_t& offset, const std::string& namespace_) {
+        for (size_t i = 0; i < namespace_.size(); i++) {
+            const auto& chr = namespace_[i];
+            if (!(is_alnum(chr) || chr == '_' || chr == '-' || chr == '.')){
+                throw std::invalid_argument("Invalid namespace character at position " + std::to_string(offset + i));
+            }
+        }
+    }
+    inline void validate_java_base_name(const size_t& offset, const std::string& base_name) {
+        for (size_t i = 0; i < base_name.size(); i++) {
+            const auto& chr = base_name[i];
+            if (!(is_alnum(chr) || chr == '_' || chr == '-' || chr == '.' || chr == '/')) {
+                throw std::invalid_argument("Invalid base name character at position " + std::to_string(offset + i));
+            }
+        }
+    }
+    // key=str
+    inline std::string capture_java_blockstate_property_key(const std::string& blockstate, size_t& offset) {
+        size_t key_start = offset;
+        while (offset < blockstate.size()) {
+            const auto& chr = blockstate[offset];
+            if (!(is_alnum(chr) || chr == '_')) {
+                break;
+            }
+            offset++;
+        }
+        if (key_start == offset) {
+            throw std::invalid_argument("Expected a key or ] at position " + std::to_string(offset));
+        }
+        return std::string(blockstate.begin() + key_start, blockstate.begin() + offset);
+    }
+    inline PropertyValueType capture_java_blockstate_property_value(const std::string& blockstate, size_t& offset) {
+        size_t value_start = offset;
+        while (offset < blockstate.size()) {
+            const auto& chr = blockstate[offset];
+            if (!(is_alnum(chr) || chr == '_')) {
+                break;
+            }
+            offset++;
+        }
+        if (value_start == offset) {
+            throw std::invalid_argument("Expected a value at position " + std::to_string(offset));
+        }
+        return AmuletNBT::StringTag(blockstate.begin() + value_start, blockstate.begin() + offset);
+    }
+
+    // I think Bedrock resource identifiers are not limited to a-z0-9_-.
+    inline void validate_bedrock_namespace(const size_t& offset, const std::string& namespace_) {
+        for (size_t i = 0; i < namespace_.size(); i++) {
+            const auto& chr = namespace_[i];
+            if (!(is_alnum(chr) || chr == '_' || chr == '-' || chr == '.')) {
+                throw std::invalid_argument("Invalid namespace character at position " + std::to_string(offset + i));
+            }
+        }
+    }
+    inline void validate_bedrock_base_name(const size_t& offset, const std::string& base_name) {
+        for (size_t i = 0; i < base_name.size(); i++) {
+            const auto& chr = base_name[i];
+            if (!(is_alnum(chr) || chr == '_' || chr == '-' || chr == '.')) {
+                throw std::invalid_argument("Invalid base name character at position " + std::to_string(offset + i));
+            }
+        }
+    }
+    // "key"=false
+    // "key"=true
+    // "key"=nbt
+    inline std::string capture_bedrock_blockstate_property_key(const std::string& blockstate, size_t& offset) {
+        // Opening "
+        if (offset >= blockstate.size() || blockstate[offset] != '"') {
+            throw std::invalid_argument("Expected \" at position " + std::to_string(offset));
+        }
+        offset++;
+
+        // Key
+        size_t key_start = offset;
+        while (offset < blockstate.size()) {
+            const auto& chr = blockstate[offset];
+            if (!(is_alnum(chr) || chr == '_')) {
+                break;
+            }
+            offset++;
+        }
+        if (key_start == offset) {
+            throw std::invalid_argument("Expected a key or ] at position " + std::to_string(offset));
+        }
+        size_t key_end = offset;
+
+        // Closing "
+        if (offset >= blockstate.size() || blockstate[offset] != '"') {
+            throw std::invalid_argument("Expected \" at position " + std::to_string(offset));
+        }
+        offset++;
+
+        return std::string(blockstate.begin() + key_start, blockstate.begin() + key_end);
+    }
+    inline PropertyValueType capture_bedrock_blockstate_property_value(const std::string& blockstate, size_t& offset) {
+        size_t value_start = offset;
+        size_t value_end = std::min(
+            blockstate.find(",", value_start),
+            blockstate.find("]", value_start)
+        );
+        if (value_end >= blockstate.size()) {
+            throw std::invalid_argument("Expected , or ] after position " + std::to_string(offset));
+        }
+        offset = value_end;
+        AmuletNBT::TagNode node;
+        try {
+            node = AmuletNBT::read_snbt(std::string(blockstate.begin() + value_start, blockstate.begin() + value_end));
+        }
+        catch (const std::exception& e) {
+            throw std::invalid_argument("Failed parsing SNBT at position " + std::to_string(value_start) + ". " + e.what());
+        }
+        return std::visit(
+            [](auto&& tag) -> PropertyValueType {
+                using T = std::decay_t<decltype(tag)>;
+                if constexpr (
+                    std::is_same_v<T, AmuletNBT::ByteTag> ||
+                    std::is_same_v<T, AmuletNBT::ShortTag> ||
+                    std::is_same_v<T, AmuletNBT::IntTag> ||
+                    std::is_same_v<T, AmuletNBT::LongTag> ||
+                    std::is_same_v<T, AmuletNBT::StringTag>
+                ) {
+                    return tag;
+                }
+                else {
+                    throw std::invalid_argument("Values must be byte, short, int, long or string tags.");
+                }
+            },
+            node
+        );
+    }
+
+    std::shared_ptr<Block> Block::from_java_blockstate(const PlatformType& platform, std::shared_ptr<VersionNumber> version, const std::string& blockstate) {
+        return parse_blockstate<
+            validate_java_namespace,
+            validate_java_base_name,
+            capture_java_blockstate_property_key,
+            capture_java_blockstate_property_value
+        >(
+            platform, 
+            version, 
+            blockstate
+        );
+    }
+    std::shared_ptr<Block> Block::from_bedrock_blockstate(const PlatformType& platform, std::shared_ptr<VersionNumber> version, const std::string& blockstate) {
+        return parse_blockstate<
+            validate_bedrock_namespace,
+            validate_bedrock_base_name,
+            capture_bedrock_blockstate_property_key,
+            capture_bedrock_blockstate_property_value
+        >(
+            platform, 
+            version, 
+            blockstate
+        );
+    }
+
+    void BlockStack::serialise(BinaryWriter& writer) const {
+        writer.writeNumeric<std::uint8_t>(1);
+        writer.writeNumeric<std::uint64_t>(get_blocks().size());
+        for (const auto& block : get_blocks()) {
+            block->serialise(writer);
+        }
+    }
+    std::shared_ptr<BlockStack> BlockStack::deserialise(BinaryReader& reader) {
+        auto version_number = reader.readNumeric<std::uint8_t>();
+        switch (version_number) {
+        case 1:
+        {
+            std::vector<std::shared_ptr<Block>> blocks;
+            auto count = reader.readNumeric<std::uint64_t>();
+            for (auto i = 0; i < count; i++) {
+                blocks.push_back(Block::deserialise(reader));
+            }
+            return std::make_shared<BlockStack>(blocks);
+        }
+        default:
+            throw std::invalid_argument("Unsupported BlockStack version " + std::to_string(version_number));
+        }
+    }
+}