33 files changed, 627 insertions, 30 deletions

@@ -915,7 +915,7 @@ connections {
   from {
     port {
       map: "the_between"
-      room: "Main Area"
+      room: "Plaza Entrance"
       name: "PLAZA"
     }
   }
@@ -5,6 +5,47 @@ connections {
 }
 connections {
   from_room: "Main Area"
-  to_room: "B2 Room"
+  to_room: "B2 Front Room"
   door { name: "B2 Door" }
 }
+connections {
+  from {
+    painting {
+      room: "B2 Front Room"
+      name: "EYES4"
+    }
+  }
+  to {
+    painting {
+      room: "B2 Back Room"
+      name: "EYES3"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "B2 Front Room"
+      name: "EYES"
+    }
+  }
+  to {
+    painting {
+      room: "B2 Back Room"
+      name: "EYES2"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "B2 Back Room"
+  to_room: "B2 Front Room"
+  # via collecting B2
+  oneway: true
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Plaza Entrance"
+  door { name: "Plaza Entrance" }
+}
@@ -0,0 +1,17 @@
+name: "B2 Back Room"
+display_name: "B2 Room"
+letters {
+  key: "b"
+  level2: true
+  path: "Components/Collectables/collectable"
+}
+paintings {
+  name: "EYES2"
+  path: "Components/Paintings/eyes2"
+  orientation: "east"
+}
+paintings {
+  name: "EYES3"
+  path: "Components/Paintings/eyes3"
+  orientation: "west"
+}
@@ -0,0 +1,12 @@
+name: "B2 Front Room"
+display_name: "B2 Room"
+paintings {
+  name: "EYES"
+  path: "Components/Paintings/eyes"
+  orientation: "east"
+}
+paintings {
+  name: "EYES4"
+  path: "Components/Paintings/eyes4"
+  orientation: "west"
+}
@@ -1,8 +0,0 @@
-name: "B2 Room"
-display_name: "B2 Room"
-letters {
-  key: "b"
-  level2: true
-  path: "Components/Collectables/collectable"
-}
-# Uhh idk if the paintings and door in here should be randomized.
@@ -201,9 +201,3 @@ ports {
   path: "Components/Warps/worldport"
   orientation: "east"
 }
-ports {
-  name: "PLAZA"
-  path: "Components/Warps/worldport4"
-  orientation: "north"
-  required_door { name: "Plaza Entrance" }
-}
@@ -0,0 +1,7 @@
+name: "Plaza Entrance"
+display_name: "Main Area"
+ports {
+  name: "PLAZA"
+  path: "Components/Warps/worldport4"
+  orientation: "north"
+}
@@ -0,0 +1,2 @@
+# This has something to do with the FISH/FISHES proxy.
+excluded_nodes: "Components/panel_fake"
@@ -0,0 +1,10 @@
+# This is a debug warp to The Ancient and as far as I can tell there is no way
+# to access it.
+excluded_nodes: "Components/Warps/worldport-test"
+# Proxy stuff related to the Ctrl Tutorial.
+excluded_nodes: "Panels/Back Left/backleft_2_proxied_1"
+excluded_nodes: "Panels/Back Left/backleft_2_proxied_2"
+excluded_nodes: "Panels/Back Left/backleft_3_proxied_1"
+excluded_nodes: "Panels/Back Left/backleft_3_proxied_2"
+excluded_nodes: "Panels/Back Left/backleft_4_proxied_1"
+excluded_nodes: "Panels/Back Left/backleft_4_proxied_2"
@@ -0,0 +1,2 @@
+# This appears to be completely inaccessible.
+excluded_nodes: "Components/Warps/worldport"
@@ -0,0 +1,8 @@
+# These are the eyes in the foyer, and aren't normal paintings.
+excluded_nodes: "Components/Paintings/Starting/eye"
+excluded_nodes: "Components/Paintings/Starting/eye2"
+excluded_nodes: "Components/Paintings/Starting/eye3"
+excluded_nodes: "Components/Paintings/Starting/eye4"
+# This is the E that got removed but not deleted. It's above the ceiling and
+# cannot be accessed.
+excluded_nodes: "Components/Paintings/Starting/e"
@@ -0,0 +1,5 @@
+# These really shouldn't be shuffled because it would make Black Ending trivial.
+excluded_nodes: "Components/Paintings/grave"
+excluded_nodes: "Components/Paintings/grave2"
+# I'll be real, I have no idea what this is.
+excluded_nodes: "Panels/panel_4"
@@ -0,0 +1,7 @@
+# This can't be shuffled because it is tilted.
+excluded_nodes: "Components/Paintings/u"
+# This can't be shuffled because it is on the ground.
+excluded_nodes: "Components/blare"
+# This is the fake HI panel that used to be in the Control Center entrance. It
+# is neither visible nor accessible.
+excluded_nodes: "Panels/General/entry_4"
@@ -134,7 +134,7 @@ ports {
 }
 ports {
   name: "TOWER"
-  path: "Components/Warps/worldport10"
+  path: "Meshes/Blocks/Warps/worldport10"
   orientation: "south"
   required_door { name: "Tower Entrance" }
   # The reverse warp bypasses the door, so there needs to be two oneway connections.
@@ -9,7 +9,7 @@ panels {
 }
 ports {
   name: "DAEDALUS"
-  path: "Components/Warps/worldport8"
+  path: "Meshes/Blocks/Warps/worldport8"
   orientation: "south"
   required_door { name: "Daedalus Entrance" }
   # The reverse warp bypasses the door, so there needs to be two oneway connections.
@@ -121,27 +121,27 @@ panels {
 }
 ports {
   name: "ENTRY"
-  path: "Components/Warps/worldport"
+  path: "Meshes/Blocks/Warps/worldport"
   orientation: "south"
 }
 ports {
   name: "KEEN"
-  path: "Components/Warps/worldport6"
+  path: "Meshes/Blocks/Warps/worldport6"
   orientation: "north"
 }
 ports {
   name: "ORB"
-  path: "Components/Warps/worldport3"
+  path: "Meshes/Blocks/Warps/worldport3"
   orientation: "north"
 }
 ports {
   name: "LINEAR"
-  path: "Components/Warps/worldport15"
+  path: "Meshes/Blocks/Warps/worldport15"
   orientation: "south"
 }
 ports {
   name: "DIGITAL"
-  path: "Components/Warps/worldport4"
+  path: "Meshes/Blocks/Warps/worldport4"
   orientation: "down"
   required_door { name: "Digital Entrance" }
 }
@@ -2,6 +2,6 @@ name: "Purple Room"
 display_name: "Main Area"
 ports {
   name: "DAEDALUS"
-  path: "Components/Warps/worldport18"
+  path: "Meshes/Blocks/Warps/worldport18"
   orientation: "north"
 }
@@ -2,6 +2,6 @@ name: "Salmon Room"
 display_name: "Main Area"
 ports {
   name: "BETWEEN"
-  path: "Components/Warps/worldport11"
+  path: "Meshes/Blocks/Warps/worldport11"
   orientation: "east"
 }
@@ -0,0 +1,32 @@
+# I'm not currently planning on shuffling anything in here.
+excluded_nodes: "Components/Paintings/C"
+excluded_nodes: "Components/Paintings/E"
+excluded_nodes: "Components/Paintings/F/F_0"
+excluded_nodes: "Components/Paintings/F/F_1"
+excluded_nodes: "Components/Paintings/U"
+excluded_nodes: "Components/Paintings/U_1"
+excluded_nodes: "Components/Paintings/X"
+excluded_nodes: "Components/Paintings/z2_1"
+excluded_nodes: "Components/Paintings/z2_2"
+excluded_nodes: "Components/Warps/worldport3_deco"
+excluded_nodes: "Components/Warps/worldport3_deco2"
+excluded_nodes: "Components/Warps/worldport3_deco3"
+excluded_nodes: "Components/Warps/worldport3_deco4"
+excluded_nodes: "Components/Warps/worldport3_deco5"
+excluded_nodes: "Panels/G/court"
+excluded_nodes: "Panels/J/red"
+excluded_nodes: "Panels/K/no"
+excluded_nodes: "Panels/L/trick"
+excluded_nodes: "Panels/Misc/hi"
+excluded_nodes: "Panels/Misc/hint"
+excluded_nodes: "Panels/O/oh"
+excluded_nodes: "Panels/P/hint"
+excluded_nodes: "Panels/Q/gray"
+excluded_nodes: "Panels/V/grin"
+excluded_nodes: "Panels/Z/art"
+excluded_nodes: "Panels/k2/place"
+excluded_nodes: "Panels/m2/green"
+excluded_nodes: "Panels/o2/orange2"
+excluded_nodes: "Panels/p2/foxes"
+excluded_nodes: "Panels/u2/open"
+excluded_nodes: "Panels/v2/snipe"
@@ -0,0 +1,5 @@
+# These are apparently little eyes on the Green Eye panel pedestals? I don't
+# think they're ever visible in gameplay.
+excluded_nodes: "Meshes/eye"
+excluded_nodes: "Meshes/eye2"
+excluded_nodes: "Meshes/eye3"
@@ -0,0 +1,4 @@
+# These are inaccessible, and were probably just copy pasted from the other
+# rooms.
+excluded_nodes: "Components/Warps/worldport2"
+excluded_nodes: "Components/Warps/worldport3"
@@ -10,7 +10,6 @@ paintings {
   # TODO: This is too high up to enter. It's also a hint painting.
   exit_only: true
 }
-# I believe worldport2 and worldport3 are completely inaccessible.
 # TODO: Should these two be independent for shuffling purposes, or always tied
 # to the Main Area's port?
 ports {
@@ -163,6 +163,11 @@ message HumanRoom {
   repeated HumanMastery masteries = 8;
 }
 
+message HumanMap {
+  optional string display_name = 1;
+  repeated string excluded_nodes = 2;
+}
+
 message IdMappings {
   message RoomIds {
     map<string, uint64> panels = 1;
@@ -1,6 +1,7 @@
 find_package(Protobuf REQUIRED)
 
 add_library(util
+  godot_scene.cpp
   identifiers.cpp
   naming.cpp
 )
@@ -0,0 +1,269 @@
+#include "godot_scene.h"
+
+#include <absl/strings/str_split.h>
+
+#include <fstream>
+#include <sstream>
+#include <variant>
+
+namespace com::fourisland::lingo2_archipelago {
+
+namespace {
+
+class GodotSceneImpl : public GodotScene {
+ public:
+  GodotSceneImpl(std::map<std::string, GodotExtResource> ext_resources,
+                 std::unique_ptr<GodotNode> root,
+                 std::vector<std::unique_ptr<GodotNode>> descendents)
+      : ext_resources_(std::move(ext_resources)),
+        root_(std::move(root)),
+        descendents_(std::move(descendents)) {}
+
+  virtual const GodotExtResource* GetExtResource(const std::string& id) const {
+    auto it = ext_resources_.find(id);
+    if (it != ext_resources_.end()) {
+      return &it->second;
+    } else {
+      return nullptr;
+    }
+  }
+
+  virtual const GodotNode& GetRoot() const { return *root_; }
+
+ private:
+  std::map<std::string, GodotExtResource> ext_resources_;
+  std::unique_ptr<GodotNode> root_;
+  std::vector<std::unique_ptr<GodotNode>> descendents_;
+};
+
+struct Heading {
+  std::string type;
+
+  std::string id;
+  std::string path;
+  std::string resource_type;
+
+  std::string name;
+  std::string parent;
+  GodotInstanceType instance_type;
+};
+
+Heading ParseTscnHeading(absl::string_view line) {
+  std::string original_line(line);
+  Heading heading;
+
+  if (line[0] != '[') {
+    std::ostringstream errormsg;
+    errormsg << "Heading must start with [." << std::endl
+             << "Bad heading: " << original_line;
+    throw std::invalid_argument(errormsg.str());
+  }
+
+  line.remove_prefix(1);
+  int divider = line.find_first_of(" ]");
+  if (divider == std::string_view::npos) {
+    std::ostringstream errormsg;
+    errormsg << "Malformatted heading: " << line << std::endl
+             << "Original line: " << original_line;
+    throw std::invalid_argument(errormsg.str());
+  }
+
+  heading.type = std::string(line.substr(0, divider));
+  line.remove_prefix(divider + 1);
+
+  while (!line.empty()) {
+    divider = line.find_first_of("=");
+    if (divider == std::string_view::npos) {
+      std::ostringstream errormsg;
+      errormsg << "Malformatted heading: " << line << std::endl
+               << "Original line: " << original_line;
+      throw std::invalid_argument(errormsg.str());
+    }
+
+    std::string key(line.substr(0, divider));
+    line.remove_prefix(divider + 1);
+
+    if (line[0] == '"') {
+      line.remove_prefix(1);
+      divider = line.find_first_of("\"");
+
+      if (divider == std::string_view::npos) {
+        std::ostringstream errormsg;
+        errormsg << "Malformatted heading: " << line << std::endl
+                 << "Original line: " << original_line;
+        throw std::invalid_argument(errormsg.str());
+      }
+
+      std::string strval(line.substr(0, divider));
+      line.remove_prefix(divider + 2);
+
+      if (key == "name") {
+        heading.name = strval;
+      } else if (key == "parent") {
+        heading.parent = strval;
+      } else if (key == "path") {
+        heading.path = strval;
+      } else if (key == "type") {
+        heading.resource_type = strval;
+      } else if (key == "id") {
+        heading.id = strval;
+      }
+    } else if (line[0] == 'S' || line[0] == 'E') {
+      GodotInstanceType rrval;
+      char internal = line[0];
+
+      line.remove_prefix(13);  // SubResource("
+      divider = line.find_first_of("\"");
+
+      if (divider == std::string_view::npos) {
+        std::ostringstream errormsg;
+        errormsg << "Malformatted heading: " << line << std::endl
+                 << "Original line: " << original_line;
+        throw std::invalid_argument(errormsg.str());
+      }
+
+      std::string refid = std::string(line.substr(0, divider));
+      line.remove_prefix(divider + 3);
+
+      GodotInstanceType instance_type;
+      if (internal == 'E') {
+        instance_type = GodotExtResourceRef{.id = refid};
+      } else {
+        // SubResource is not supported right now.
+      }
+
+      if (key == "instance") {
+        heading.instance_type = instance_type;
+      } else {
+        // Other keys aren't supported right now.
+      }
+    } else {
+      divider = line.find_first_of(" ]");
+
+      if (divider == std::string_view::npos) {
+        std::ostringstream errormsg;
+        errormsg << "Malformatted heading: " << line << std::endl
+                 << "Original line: " << original_line;
+        throw std::invalid_argument(errormsg.str());
+      }
+
+      int numval = std::atoi(line.substr(0, divider).data());
+      line.remove_prefix(divider + 1);
+
+      // keyvals_[key] = numval;
+    }
+  }
+
+  return heading;
+}
+
+}  // namespace
+
+void GodotNode::AddChild(GodotNode& child) {
+  children_[child.GetName()] = &child;
+  child.parent_ = this;
+}
+
+std::string GodotNode::GetPath() const {
+  if (parent_ == nullptr || parent_->GetName() == "") {
+    return name_;
+  } else {
+    return parent_->GetPath() + "/" + name_;
+  }
+}
+
+const GodotNode* GodotNode::GetNode(absl::string_view path) const {
+  std::vector<std::string> names = absl::StrSplit(path, "/");
+
+  auto it = children_.find(names[0]);
+  if (it == children_.end()) {
+    return nullptr;
+  } else {
+    if (names.size() == 1) {
+      return it->second;
+    } else {
+      path.remove_prefix(names[0].size() + 1);
+
+      return it->second->GetNode(path);
+    }
+  }
+}
+
+GodotNode* GodotNode::GetNode(absl::string_view path) {
+  return const_cast<GodotNode*>(
+      const_cast<const GodotNode*>(this)->GetNode(path));
+}
+
+std::unique_ptr<GodotScene> ReadGodotSceneFromFile(const std::string& path) {
+  std::map<std::string, GodotExtResource> ext_resources;
+  auto root = std::make_unique<GodotNode>("", GodotInstanceType{});
+  std::vector<std::unique_ptr<GodotNode>> descendents;
+
+  std::ifstream input(path);
+
+  std::string line;
+  bool section_started = false;
+  Heading cur_heading;
+  std::ostringstream cur_value;
+  bool value_started = false;
+  auto handle_end_of_section = [&]() {
+    section_started = false;
+    value_started = false;
+
+    if (cur_heading.type == "sub_resource") {
+      // sub_resources_[std::get<int>(cur_heading.GetKeyval("id"))] =
+      // {cur_heading, cur_value.str(), ""};
+    } else {
+      // other_.emplace_back(cur_heading, cur_value.str());
+    }
+
+    cur_value = {};
+  };
+  while (std::getline(input, line)) {
+    if (section_started && (line.empty() || line[0] == '[')) {
+      handle_end_of_section();
+    }
+    if (!line.empty() && line[0] == '[') {
+      Heading heading = ParseTscnHeading(line);
+      if (heading.type == "gd_scene") {
+        // file_descriptor_ = heading;
+      } else if (heading.type == "ext_resource") {
+        GodotExtResource ext_resource;
+        ext_resource.path = heading.path;
+        ext_resource.type = heading.resource_type;
+
+        ext_resources[heading.id] = ext_resource;
+      } else if (heading.type == "node") {
+        if (heading.parent != "") {
+          descendents.push_back(
+              std::make_unique<GodotNode>(heading.name, heading.instance_type));
+          GodotNode* child = descendents.back().get();
+
+          if (heading.parent == ".") {
+            root->AddChild(*child);
+          } else {
+            root->GetNode(heading.parent)->AddChild(*child);
+          }
+        }
+      } else {
+        cur_heading = heading;
+        section_started = true;
+      }
+    } else if (!line.empty()) {
+      if (value_started) {
+        cur_value << std::endl;
+      } else {
+        value_started = true;
+      }
+      cur_value << line;
+    }
+  }
+  if (section_started) {
+    handle_end_of_section();
+  }
+
+  return std::make_unique<GodotSceneImpl>(
+      std::move(ext_resources), std::move(root), std::move(descendents));
+}
+
+}  // namespace com::fourisland::lingo2_archipelago
@@ -0,0 +1,67 @@
+#ifndef TOOLS_UTIL_TSCN_H_
+#define TOOLS_UTIL_TSCN_H_
+
+#include <absl/strings/string_view.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <variant>
+
+namespace com::fourisland::lingo2_archipelago {
+
+struct GodotExtResource {
+  std::string type;
+  std::string path;
+};
+
+struct GodotExtResourceRef {
+  std::string id;
+};
+
+using GodotInstanceType = std::variant<std::monostate, GodotExtResourceRef>;
+
+class GodotNode {
+ public:
+  GodotNode(std::string name, GodotInstanceType instance_type)
+      : name_(std::move(name)), instance_type_(std::move(instance_type)) {}
+
+  const std::string& GetName() const { return name_; }
+
+  const GodotInstanceType& GetInstanceType() const { return instance_type_; }
+
+  const GodotNode* GetParent() const { return parent_; }
+  GodotNode* GetParent() { return parent_; }
+
+  std::string GetPath() const;
+
+  void AddChild(GodotNode& child);
+
+  const GodotNode* GetNode(absl::string_view path) const;
+  GodotNode* GetNode(absl::string_view path);
+
+  const std::map<std::string, GodotNode*> GetChildren() const {
+    return children_;
+  }
+
+ private:
+  std::string name_;
+  GodotInstanceType instance_type_;
+
+  GodotNode* parent_ = nullptr;
+  std::map<std::string, GodotNode*> children_;
+};
+
+class GodotScene {
+ public:
+  virtual const GodotExtResource* GetExtResource(
+      const std::string& id) const = 0;
+  virtual const GodotNode& GetRoot() const = 0;
+};
+
+std::unique_ptr<GodotScene> ReadGodotSceneFromFile(const std::string& path);
+
+}  // namespace com::fourisland::lingo2_archipelago
+
+#endif /* TOOLS_UTIL_TSCN_H_ */
@@ -1,6 +1,7 @@
 find_package(Protobuf REQUIRED)
 
 add_executable(validator
+  godot_processor.cpp
   human_processor.cpp
   main.cpp
   validator.cpp
@@ -0,0 +1,76 @@
+#include "godot_processor.h"
+
+#include <filesystem>
+#include <iostream>
+#include <memory>
+#include <set>
+
+#include "structs.h"
+#include "util/godot_scene.h"
+
+namespace com::fourisland::lingo2_archipelago {
+
+namespace {
+
+static const std::set<std::string> kImportantNodeTypes = {
+    "res://objects/nodes/panel.tscn", "res://objects/nodes/worldport.tscn",
+    "res://objects/nodes/keyHolder.tscn",
+    "res://objects/nodes/collectable.tscn"};
+
+class GodotProcessor {
+ public:
+  GodotProcessor(const std::string& repodir, CollectedInfo& info)
+      : repodir_(repodir), info_(info) {}
+
+  void Run() {
+    for (auto& [map_name, map_info] : info_.maps) {
+      ProcessMap(map_name, map_info);
+    }
+  }
+
+  void ProcessMap(const std::string& map_name, MapInfo& map_info) {
+    std::filesystem::path scene_path = std::filesystem::path(repodir_) /
+                                       "objects" / "scenes" /
+                                       (map_name + ".tscn");
+    std::string scene_path_str = scene_path.string();
+    std::cout << "Processing " << scene_path_str << std::endl;
+
+    std::unique_ptr<GodotScene> scene =
+        ReadGodotSceneFromFile(scene_path_str);
+
+    ProcessMapNode(*scene, scene->GetRoot(), map_info);
+  }
+
+  void ProcessMapNode(const GodotScene& scene, const GodotNode& node,
+                      MapInfo& map_info) {
+    if (std::holds_alternative<GodotExtResourceRef>(node.GetInstanceType())) {
+      const GodotExtResourceRef& ext_resource_ref =
+          std::get<GodotExtResourceRef>(node.GetInstanceType());
+      const GodotExtResource* ext_resource =
+          scene.GetExtResource(ext_resource_ref.id);
+
+      if (ext_resource != nullptr &&
+          (kImportantNodeTypes.count(ext_resource->path) ||
+           ext_resource->path.starts_with("res://objects/meshes/paintings/"))) {
+        map_info.game_nodes[node.GetPath()].defined = true;
+      }
+    }
+
+    for (const auto& [child_name, child_node] : node.GetChildren()) {
+      ProcessMapNode(scene, *child_node, map_info);
+    }
+  }
+
+ private:
+  std::string repodir_;
+  CollectedInfo& info_;
+};
+
+}  // namespace
+
+void ProcessGodotData(const std::string& repodir, CollectedInfo& info) {
+  GodotProcessor godot_processor(repodir, info);
+  godot_processor.Run();
+}
+
+}  // namespace com::fourisland::lingo2_archipelago
@@ -0,0 +1,14 @@
+#ifndef TOOLS_VALIDATOR_GODOT_PROCESSOR_H_
+#define TOOLS_VALIDATOR_GODOT_PROCESSOR_H_
+
+#include <string>
+
+namespace com::fourisland::lingo2_archipelago {
+
+struct CollectedInfo;
+
+void ProcessGodotData(const std::string& repodir, CollectedInfo& info);
+
+}  // namespace com::fourisland::lingo2_archipelago
+
+#endif /* TOOLS_VALIDATOR_GODOT_PROCESSOR_H_ */
@@ -55,11 +55,26 @@ class HumanProcessor {
   void ProcessMap(std::filesystem::path path) {
     std::string map_name = path.filename().string();
 
+    ProcessMetadataFile(path / "metadata.txtpb", map_name);
     ProcessConnectionsFile(path / "connections.txtpb", map_name);
     ProcessDoorsFile(path / "doors.txtpb", map_name);
     ProcessRooms(path / "rooms", map_name);
   }
 
+  void ProcessMetadataFile(std::filesystem::path path,
+    const std::string& current_map_name) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    MapInfo& map_info = info_.maps[current_map_name];
+
+    auto metadata = ReadMessageFromFile<HumanMap>(path.string());
+    for (const std::string& path : metadata.excluded_nodes()) {
+      map_info.game_nodes[path].uses++;
+    }
+  }
+
   void ProcessRooms(std::filesystem::path path,
                     const std::string& current_map_name) {
     for (auto const& dir_entry : std::filesystem::directory_iterator(path)) {
@@ -1,3 +1,4 @@
+#include "godot_processor.h"
 #include "human_processor.h"
 #include "structs.h"
 #include "validator.h"
@@ -5,10 +6,11 @@
 namespace com::fourisland::lingo2_archipelago {
 namespace {
 
-void Run(const std::string& mapdir) {
+void Run(const std::string& mapdir, const std::string& repodir) {
   CollectedInfo info;
 
   ProcessHumanData(mapdir, info);
+  ProcessGodotData(repodir, info);
 
   ValidateCollectedInfo(info);
 }
@@ -17,15 +19,16 @@ void Run(const std::string& mapdir) {
 }  // namespace com::fourisland::lingo2_archipelago
 
 int main(int argc, char** argv) {
-  if (argc != 2) {
+  if (argc != 3) {
     std::cout << "Incorrect argument count." << std::endl;
-    std::cout << "Usage: validator [path to map directory]" << std::endl;
+    std::cout << "Usage: validator [path to map directory] [path to Lingo 2 repository]" << std::endl;
     return 1;
   }
 
   std::string mapdir = argv[1];
+  std::string repodir = argv[2];
 
-  com::fourisland::lingo2_archipelago::Run(mapdir);
+  com::fourisland::lingo2_archipelago::Run(mapdir, repodir);
 
   return 0;
 }
@@ -21,6 +21,7 @@ struct MalformedIdentifiers {
 };
 
 struct GameNodeInfo {
+  bool defined = false;
   int uses = 0;
 };
 
@@ -14,6 +14,14 @@ void ValidateMap(const std::string& map_name, const MapInfo& map_info) {
     if (node_info.uses > 1) {
       std::cout << "Map " << map_name << " node " << node_path
                 << " is used in multiple places." << std::endl;
+    } else if (node_info.uses == 0) {
+      std::cout << "Map " << map_name << " node " << node_path
+                << " is not used." << std::endl;
+    }
+
+    if (!node_info.defined) {
+      std::cout << "Map " << map_name << " node " << node_path
+                << " is not defined in the game file." << std::endl;
     }
   }
 }