feat(vf): add ResourceId and DataPackMeta

core/include/vf/DataPack.h

@@ -0,0 +1,156 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "Crafting.h"
+#include "Item.h"
+#include "Json.h"
+#include "Loot.h"
+
+namespace vf {
+
+// A namespaced identifier, "voxelforge:iron_ingot". Both halves are lowercase
+// by construction: the space accepts [a-z0-9_.-] and the path additionally
+// accepts '/', so one namespace can hold folders of resources.
+struct ResourceId {
+    std::string space;
+    std::string path;
+
+    ResourceId() = default;
+    ResourceId(std::string space, std::string path);
+
+    // Accepts "space:path" or a bare "path", which takes defaultSpace.
+    static bool parse(const std::string& text, const std::string& defaultSpace, ResourceId& out);
+    static bool validSpace(const std::string& text);
+    static bool validPath(const std::string& text);
+
+    bool valid() const { return validSpace(space) && validPath(path); }
+    bool empty() const { return space.empty() && path.empty(); }
+    std::string text() const { return space + ":" + path; }
+
+    bool operator==(const ResourceId& other) const {
+        return space == other.space && path == other.path;
+    }
+    bool operator!=(const ResourceId& other) const { return !(*this == other); }
+    bool operator<(const ResourceId& other) const {
+        return space == other.space ? path < other.path : space < other.space;
+    }
+};
+
+// Maps a resource id onto the palettes the engine already has. The path is
+// matched case insensitively with '_' and '-' removed, so "iron_ingot" finds
+// ItemId::IronIngot through the shared name table in Command.cpp.
+bool resolveItemId(const ResourceId& id, ItemId& out);
+bool resolveBlockId(const ResourceId& id, Block& out);
+
+struct DataPackMeta {
+    std::string name;
+    std::string description;
+    int formatVersion = 1;
+    // Higher priority is applied later, so it overwrites what came before.
+    int priority = 0;
+    std::string defaultSpace = "voxelforge";
+
+    static bool fromJson(const JsonValue& root, DataPackMeta& out, std::string& problem);
+};
+
+// One thing that went wrong while loading, always naming the file it came from.
+// A pack keeps loading past its own errors: one broken recipe costs that recipe
+// and nothing else.
+struct DataPackError {
+    std::string pack;
+    std::string file;
+    std::string reason;
+    int line = 0;
+    int column = 0;
+
+    std::string text() const;
+};
+
+// A pack as a directory tree held in memory: a map from a slash separated path
+// to the file's bytes. Nothing here ever touches a real filesystem.
+//
+// Layout, all below data/<space>/:
+//   recipes/<name>.json      shaped, shapeless or smelting
+//   lootTables/<name>.json   pools of entries, conditions and functions
+//   tags/blocks/<name>.json  block tag, entries may reference other tags
+//   tags/items/<name>.json   item tag
+//   advancements/<name>.json read by Advancement.h
+// plus an optional pack.json at the root carrying the metadata.
+class DataPack {
+public:
+    DataPack() = default;
+    explicit DataPack(DataPackMeta meta) : packMeta(std::move(meta)) {}
+
+    const DataPackMeta& meta() const { return packMeta; }
+    DataPackMeta& meta() { return packMeta; }
+
+    void addFile(const std::string& path, std::string contents);
+    bool removeFile(const std::string& path);
+    bool hasFile(const std::string& path) const;
+    const std::string* fileContents(const std::string& path) const;
+
+    // Sorted, so loading order never depends on hashing.
+    std::vector<std::string> filesUnder(const std::string& prefix) const;
+    std::vector<std::string> allFiles() const;
+    std::size_t fileCount() const { return files.size(); }
+
+private:
+    DataPackMeta packMeta;
+    std::map<std::string, std::string> files;
+};
+
+// A recipe read from data, in the shape the existing CraftingRegistry takes.
+// The conversions below hand back the very structs Crafting.h declares, so a
+// loaded recipe is matched by the same craftMatch as a built in one.
+struct RecipeData {
+    enum class Kind : uint8_t { Shaped, Shapeless, Smelting };
+
+    ResourceId id;
+    Kind kind = Kind::Shaped;
+
+    int width = 0;
+    int height = 0;
+    std::array<ItemId, craftGridCells> pattern{};
+    bool allowMirror = true;
+
+    std::vector<ItemId> ingredients;
+
+    ItemId smeltInput = ItemId::None;
+    float smeltSeconds = 10.0f;
+    float experience = 0.0f;
+
+    ItemId resultItem = ItemId::None;
+    int resultCount = 1;
+
+    ShapedRecipe toShaped() const;
+    ShapelessRecipe toShapeless() const;
+    SmeltingRecipe toSmelting() const;
+};
+
+// A tag: a named set of resource ids that may itself name other tags. The same
+// type carries block tags and item tags; which palette an entry resolves
+// against is decided by the registry it was loaded into.
+struct BlockTag {
+    struct Entry {
+        ResourceId id;
+        // Written as "#space:path" in data: pull in every member of that tag.
+        bool reference = false;
+
+        bool operator==(const Entry& other) const {
+            return id == other.id && reference == other.reference;
+        }
+    };
+
+    ResourceId id;
+    // false appends to whatever an earlier pack defined, true wipes it first.
+    bool replace = false;
+    std::vector<Entry> entries;
+
+    bool contains(const ResourceId& member) const;
+};
+