feat: add loadAdvancements to Advancement

core/src/Advancement.cpp

@@ -491,3 +491,72 @@ bool parseAdvancementJson(const JsonValue& root, const std::string& defaultSpace
         parsed.criteria.push_back(criterion);
     }
 
+    if (const JsonValue* requirements = root.find("requirements")) {
+        if (!requirements->isArray()) {
+            problem = "\"requirements\" must be an array of groups";
+            return false;
+        }
+        for (const JsonValue& group : requirements->elements()) {
+            if (!group.isArray() || group.elements().empty()) {
+                problem = "every requirement group must be a non empty array";
+                return false;
+            }
+            std::vector<std::string> names;
+            for (const JsonValue& name : group.elements()) {
+                if (!name.isString()) {
+                    problem = "requirement groups hold criterion names";
+                    return false;
+                }
+                names.push_back(name.stringValue());
+            }
+            parsed.requirements.push_back(names);
+        }
+        std::vector<std::string> dangling = parsed.danglingRequirements();
+        if (!dangling.empty()) {
+            problem = "requirement names no criterion declares: " + dangling.front();
+            return false;
+        }
+    }
+
+    if (const JsonValue* rewards = root.find("rewards")) {
+        if (!rewards->isObject()) {
+            problem = "\"rewards\" must be an object";
+            return false;
+        }
+        parsed.reward.experience = static_cast<int>(rewards->intOr("experience", 0));
+        if (parsed.reward.experience < 0) {
+            problem = "\"experience\" cannot be negative";
+            return false;
+        }
+        if (!readResourceList(*rewards, "recipes", defaultSpace, parsed.reward.recipes, problem))
+            return false;
+        if (!readResourceList(*rewards, "loot", defaultSpace, parsed.reward.lootTables, problem))
+            return false;
+    }
+
+    out = parsed;
+    return true;
+}
+
+AdvancementTree loadAdvancements(const DataPackLoader& loader, std::vector<DataPackError>& errors) {
+    AdvancementTree tree;
+    const std::map<ResourceId, JsonValue>* documents = loader.documentsIn("advancements");
+    if (documents == nullptr) return tree;
+    for (const auto& document : *documents) {
+        Advancement advancement;
+        std::string problem;
+        if (!parseAdvancementJson(document.second, document.first.space, advancement, problem)) {
+            DataPackError failure;
+            failure.file = "data/" + document.first.space + "/advancements/" + document.first.path +
+                           ".json";
+            failure.reason = problem;
+            errors.push_back(failure);
+            continue;
+        }
+        advancement.id = document.first;
+        tree.add(advancement);
+    }
+    return tree;
+}
+
+} // namespace vf