17 files changed, 1845 insertions, 244 deletions

@@ -2,6 +2,7 @@
 #include <google/protobuf/text_format.h>
 
 #include <cstdint>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <map>
@@ -9,6 +10,7 @@
 #include <string>
 
 #include "proto/human.pb.h"
+#include "util/ids_yaml_format.h"
 #include "util/naming.h"
 
 namespace com::fourisland::lingo2_archipelago {
@@ -34,11 +36,15 @@ class AssignIds {
 
   void Run() {
     std::filesystem::path datadir_path = mapdir_;
-    std::filesystem::path ids_path = datadir_path / "ids.txtpb";
+    std::filesystem::path ids_path = datadir_path / "ids.yaml";
 
     ReadIds(ids_path);
 
     ProcessMaps(datadir_path);
+    ProcessSpecialIds();
+    ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessGlobalMetadataFile(datadir_path / "metadata.txtpb");
 
     WriteIds(ids_path);
 
@@ -46,53 +52,34 @@ class AssignIds {
   }
 
   void ReadIds(std::filesystem::path path) {
-    id_mappings_ = ReadMessageFromFile<IdMappings>(path.string());
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    id_mappings_ = ReadIdsFromYaml(path.string());
 
     for (const auto& [_, map] : id_mappings_.maps()) {
-      for (const auto& [_, id] : map.doors()) {
-        if (id > next_id_) {
-          next_id_ = id;
-        }
-      }
+      UpdateNextId(map.doors());
 
       for (const auto& [_, room] : map.rooms()) {
-        for (const auto& [_, id] : room.panels()) {
-          if (id > next_id_) {
-            next_id_ = id;
-          }
-        }
-
-        for (const auto& [_, id] : room.masteries()) {
-          if (id > next_id_) {
-            next_id_ = id;
-          }
-        }
+        UpdateNextId(room.panels());
+        UpdateNextId(room.masteries());
+        UpdateNextId(room.keyholders());
+        UpdateNextId(room.ports());
       }
     }
 
-    for (const auto& [_, id] : id_mappings_.special()) {
-      if (id > next_id_) {
-        next_id_ = id;
-      }
-    }
-
-    for (const auto& [_, id] : id_mappings_.letters()) {
-      if (id > next_id_) {
-        next_id_ = id;
-      }
-    }
+    UpdateNextId(id_mappings_.special());
+    UpdateNextId(id_mappings_.letters());
+    UpdateNextId(id_mappings_.endings());
+    UpdateNextId(id_mappings_.progressives());
+    UpdateNextId(id_mappings_.door_groups());
 
     next_id_++;
   }
 
   void WriteIds(std::filesystem::path path) {
-    std::string output;
-    google::protobuf::TextFormat::PrintToString(id_mappings_, &output);
-
-    {
-      std::ofstream outputfile(path.string());
-      outputfile << output;
-    }
+    WriteIdsAsYaml(output_, path.string());
   }
 
   void ProcessMaps(std::filesystem::path path) {
@@ -104,7 +91,7 @@ class AssignIds {
   }
 
   void ProcessMap(std::filesystem::path path) {
-    std::string map_name = path.filename();
+    std::string map_name = path.filename().string();
 
     ProcessDoorsFile(path / "doors.txtpb", map_name);
     ProcessRooms(path / "rooms", map_name);
@@ -125,18 +112,23 @@ class AssignIds {
 
   void ProcessDoor(const HumanDoor& h_door,
                    const std::string& current_map_name) {
-    if (h_door.type() == DoorType::EVENT) {
+    if (h_door.type() == DoorType::EVENT && !h_door.latch() &&
+        !h_door.legacy_location()) {
       return;
     }
 
+    auto& maps = *output_.mutable_maps();
+    auto& doors = *maps[current_map_name].mutable_doors();
+
     if (!id_mappings_.maps().contains(current_map_name) ||
         !id_mappings_.maps()
              .at(current_map_name)
              .doors()
              .contains(h_door.name())) {
-      auto& maps = *id_mappings_.mutable_maps();
-      auto& doors = *maps[current_map_name].mutable_doors();
       doors[h_door.name()] = next_id_++;
+    } else {
+      doors[h_door.name()] =
+          id_mappings_.maps().at(current_map_name).doors().at(h_door.name());
     }
   }
 
@@ -151,6 +143,10 @@ class AssignIds {
   void ProcessRoom(const HumanRoom& h_room,
                    const std::string& current_map_name) {
     for (const HumanPanel& h_panel : h_room.panels()) {
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& panels = *rooms[h_room.name()].mutable_panels();
+
       if (!id_mappings_.maps().contains(current_map_name) ||
           !id_mappings_.maps()
                .at(current_map_name)
@@ -162,23 +158,33 @@ class AssignIds {
                .at(h_room.name())
                .panels()
                .contains(h_panel.name())) {
-        auto& maps = *id_mappings_.mutable_maps();
-        auto& rooms = *maps[current_map_name].mutable_rooms();
-        auto& panels = *rooms[h_room.name()].mutable_panels();
         panels[h_panel.name()] = next_id_++;
+      } else {
+        panels[h_panel.name()] = id_mappings_.maps()
+                                     .at(current_map_name)
+                                     .rooms()
+                                     .at(h_room.name())
+                                     .panels()
+                                     .at(h_panel.name());
       }
     }
 
     for (const HumanLetter& h_letter : h_room.letters()) {
       std::string lettername = GetLetterName(h_letter.key(), h_letter.level2());
 
+      auto& letters = *output_.mutable_letters();
       if (!id_mappings_.letters().contains(lettername)) {
-        auto& letters = *id_mappings_.mutable_letters();
         letters[lettername] = next_id_++;
+      } else {
+        letters[lettername] = id_mappings_.letters().at(lettername);
       }
     }
 
     for (const HumanMastery& h_mastery : h_room.masteries()) {
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& masteries = *rooms[h_room.name()].mutable_masteries();
+
       if (!id_mappings_.maps().contains(current_map_name) ||
           !id_mappings_.maps()
                .at(current_map_name)
@@ -190,20 +196,164 @@ class AssignIds {
                .at(h_room.name())
                .masteries()
                .contains(h_mastery.name())) {
-        auto& maps = *id_mappings_.mutable_maps();
-        auto& rooms = *maps[current_map_name].mutable_rooms();
-        auto& masteries = *rooms[h_room.name()].mutable_masteries();
         masteries[h_mastery.name()] = next_id_++;
+      } else {
+        masteries[h_mastery.name()] = id_mappings_.maps()
+                                          .at(current_map_name)
+                                          .rooms()
+                                          .at(h_room.name())
+                                          .masteries()
+                                          .at(h_mastery.name());
+      }
+    }
+
+    for (const HumanEnding& h_ending : h_room.endings()) {
+      auto& endings = *output_.mutable_endings();
+
+      if (!id_mappings_.endings().contains(h_ending.name())) {
+        endings[h_ending.name()] = next_id_++;
+      } else {
+        endings[h_ending.name()] = id_mappings_.endings().at(h_ending.name());
+      }
+    }
+
+    for (const HumanKeyholder& h_keyholder : h_room.keyholders()) {
+      if (!h_keyholder.has_key()) {
+        continue;
+      }
+
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& keyholders = *rooms[h_room.name()].mutable_keyholders();
+
+      if (!id_mappings_.maps().contains(current_map_name) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .contains(h_room.name()) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .at(h_room.name())
+               .keyholders()
+               .contains(h_keyholder.name())) {
+        keyholders[h_keyholder.name()] = next_id_++;
+      } else {
+        keyholders[h_keyholder.name()] = id_mappings_.maps()
+                                             .at(current_map_name)
+                                             .rooms()
+                                             .at(h_room.name())
+                                             .keyholders()
+                                             .at(h_keyholder.name());
+      }
+    }
+
+    for (const HumanPort& h_port : h_room.ports()) {
+      if (h_port.no_shuffle()) {
+        continue;
+      }
+
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& ports = *rooms[h_room.name()].mutable_ports();
+
+      if (!id_mappings_.maps().contains(current_map_name) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .contains(h_room.name()) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .at(h_room.name())
+               .ports()
+               .contains(h_port.name())) {
+        ports[h_port.name()] = next_id_++;
+      } else {
+        ports[h_port.name()] = id_mappings_.maps()
+                                   .at(current_map_name)
+                                   .rooms()
+                                   .at(h_room.name())
+                                   .ports()
+                                   .at(h_port.name());
+      }
+    }
+  }
+
+  void ProcessSpecialIds() {
+    auto& specials = *output_.mutable_special();
+
+    for (const auto& [special_name, ap_id] : id_mappings_.special()) {
+      specials[special_name] = ap_id;
+    }
+  }
+
+  void ProcessProgressivesFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_progs = ReadMessageFromFile<HumanProgressives>(path.string());
+    auto& progs = *output_.mutable_progressives();
+
+    for (const HumanProgressive& h_prog : h_progs.progressives()) {
+      if (!id_mappings_.progressives().contains(h_prog.name())) {
+        progs[h_prog.name()] = next_id_++;
+      } else {
+        progs[h_prog.name()] = id_mappings_.progressives().at(h_prog.name());
+      }
+    }
+  }
+
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+    auto& groups = *output_.mutable_door_groups();
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      if (!id_mappings_.door_groups().contains(h_group.name())) {
+        groups[h_group.name()] = next_id_++;
+      } else {
+        groups[h_group.name()] = id_mappings_.door_groups().at(h_group.name());
+      }
+    }
+  }
+
+  void ProcessGlobalMetadataFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
+    auto& specials = *output_.mutable_special();
+
+    for (const std::string& h_special : h_metadata.special_names()) {
+      if (!id_mappings_.special().contains(h_special)) {
+        specials[h_special] = next_id_++;
+      } else {
+        specials[h_special] = id_mappings_.special().at(h_special);
       }
     }
   }
 
  private:
+  void UpdateNextId(const google::protobuf::Map<std::string, uint64_t>& ids) {
+    for (const auto& [_, id] : ids) {
+      if (id > next_id_) {
+        next_id_ = id;
+      }
+    }
+  }
+
   std::string mapdir_;
 
-  uint64_t next_id_ = 0;
+  uint64_t next_id_ = 1;
 
   IdMappings id_mappings_;
+  IdMappings output_;
 };
 
 }  // namespace
@@ -79,7 +79,7 @@ uint64_t Container::FindOrAddPainting(
   auto it = room_container.find(painting_name);
   if (it == room_container.end()) {
     uint64_t new_id = all_objects_.paintings_size();
-    Painting* painting = all_objects_.add_paintings();
+    PaintingData* painting = all_objects_.add_paintings();
     painting->set_id(new_id);
     painting->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
     painting->set_name(painting_name);
@@ -205,6 +205,22 @@ uint64_t Container::FindLetterByName(std::string letter_name) {
   }
 }
 
+uint64_t Container::FindOrAddEnding(std::string ending_name) {
+  auto it = ending_id_by_name_.find(ending_name);
+  if (it == ending_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.endings_size();
+    Ending* ending = all_objects_.add_endings();
+    ending->set_id(new_id);
+    ending->set_name(ending_name);
+
+    ending_id_by_name_[ending_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 uint64_t Container::FindOrAddMastery(std::optional<std::string> map_name,
                                      std::optional<std::string> room_name,
                                      std::string mastery_name,
@@ -273,7 +289,7 @@ uint64_t Container::FindOrAddKeyholder(
   auto it = room_container.find(keyholder_name);
   if (it == room_container.end()) {
     uint64_t new_id = all_objects_.keyholders_size();
-    Keyholder* keyholder = all_objects_.add_keyholders();
+    KeyholderData* keyholder = all_objects_.add_keyholders();
     keyholder->set_id(new_id);
     keyholder->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
     keyholder->set_name(keyholder_name);
@@ -315,6 +331,40 @@ uint64_t Container::FindOrAddDoor(std::optional<std::string> map_name,
   }
 }
 
+uint64_t Container::FindOrAddProgressive(std::string prog_name) {
+  auto it = progressive_id_by_name_.find(prog_name);
+
+  if (it == progressive_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.progressives_size();
+    Progressive* progressive = all_objects_.add_progressives();
+    progressive->set_id(new_id);
+    progressive->set_name(prog_name);
+
+    progressive_id_by_name_[prog_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
+uint64_t Container::FindOrAddDoorGroup(std::string group_name) {
+  auto it = door_group_id_by_name_.find(group_name);
+
+  if (it == door_group_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.door_groups_size();
+    DoorGroup* door_group = all_objects_.add_door_groups();
+    door_group->set_id(new_id);
+    door_group->set_name(group_name);
+
+    door_group_id_by_name_[group_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 void Container::AddConnection(const Connection& connection) {
   *all_objects_.add_connections() = connection;
 }
@@ -40,6 +40,8 @@ class Container {
 
   uint64_t FindLetterByName(std::string letter_name);
 
+  uint64_t FindOrAddEnding(std::string ending_name);
+
   uint64_t FindOrAddMastery(std::optional<std::string> map_name,
                             std::optional<std::string> room_name,
                             std::string mastery_name,
@@ -58,6 +60,10 @@ class Container {
 
   void AddConnection(const Connection& connection);
 
+  uint64_t FindOrAddProgressive(std::string prog_name);
+
+  uint64_t FindOrAddDoorGroup(std::string group_name);
+
   AllObjects& all_objects() { return all_objects_; }
 
  private:
@@ -79,6 +85,9 @@ class Container {
       keyholder_id_by_map_room_keyholder_names_;
   std::map<std::string, std::map<std::string, uint64_t>>
       door_id_by_map_door_names_;
+  std::map<std::string, uint64_t> ending_id_by_name_;
+  std::map<std::string, uint64_t> progressive_id_by_name_;
+  std::map<std::string, uint64_t> door_group_id_by_name_;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -14,6 +14,7 @@
 #include "container.h"
 #include "proto/data.pb.h"
 #include "proto/human.pb.h"
+#include "util/ids_yaml_format.h"
 
 namespace com::fourisland::lingo2_archipelago {
 namespace {
@@ -42,7 +43,10 @@ class DataPacker {
 
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
-    ProcessIdsFile(datadir_path / "ids.txtpb");
+    ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessGlobalMetadataFile(datadir_path / "metadata.txtpb");
+    ProcessIdsFile(datadir_path / "ids.yaml");
 
     {
       std::ofstream outputfile(outputpath_);
@@ -65,13 +69,38 @@ class DataPacker {
   }
 
   void ProcessMap(std::filesystem::path path) {
-    std::string map_name = path.filename();
+    std::string map_name = path.filename().string();
 
+    ProcessMapMetadataFile(path / "metadata.txtpb", map_name);
     ProcessConnectionsFile(path / "connections.txtpb", map_name);
     ProcessDoorsFile(path / "doors.txtpb", map_name);
     ProcessRooms(path / "rooms", map_name);
   }
 
+  void ProcessMapMetadataFile(std::filesystem::path path,
+                              const std::string& map_name) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto metadata = ReadMessageFromFile<HumanMap>(path.string());
+
+    uint64_t map_id = container_.FindOrAddMap(map_name);
+    Map& map = *container_.all_objects().mutable_maps(map_id);
+
+    map.set_type(metadata.type());
+
+    if (metadata.has_display_name()) {
+      map.set_display_name(metadata.display_name());
+    }
+
+    if (metadata.has_worldport_entrance()) {
+      map.set_worldport_entrance(container_.FindOrAddPort(
+          map_name, metadata.worldport_entrance().room(),
+          metadata.worldport_entrance().name(), std::nullopt, std::nullopt));
+    }
+  }
+
   void ProcessRooms(std::filesystem::path path,
                     const std::string& current_map_name) {
     for (auto const& dir_entry : std::filesystem::directory_iterator(path)) {
@@ -86,7 +115,11 @@ class DataPacker {
         container_.FindOrAddRoom(current_map_name, h_room.name(), std::nullopt);
     Room& room = *container_.all_objects().mutable_rooms(room_id);
 
-    room.set_display_name(h_room.display_name());
+    // room.set_display_name(h_room.display_name());
+
+    if (h_room.has_panel_display_name()) {
+      room.set_panel_display_name(h_room.panel_display_name());
+    }
 
     for (const HumanPanel& h_panel : h_room.panels()) {
       room.add_panels(ProcessPanel(h_panel, current_map_name, room.name()));
@@ -114,6 +147,10 @@ class DataPacker {
       room.add_keyholders(
           ProcessKeyholder(h_keyholder, current_map_name, room.name()));
     }
+
+    for (const HumanEnding& h_ending : h_room.endings()) {
+      room.add_endings(ProcessEnding(h_ending, current_map_name, room.name()));
+    }
   }
 
   uint64_t ProcessPanel(const HumanPanel& h_panel,
@@ -153,6 +190,10 @@ class DataPacker {
           map_name, h_panel.required_room().name(), current_map_name));
     }
 
+    if (h_panel.has_display_name()) {
+      panel.set_display_name(h_panel.display_name());
+    }
+
     return panel_id;
   }
 
@@ -162,7 +203,7 @@ class DataPacker {
     uint64_t painting_id = container_.FindOrAddPainting(
         current_map_name, current_room_name, h_painting.name(), std::nullopt,
         std::nullopt);
-    Painting& painting =
+    PaintingData& painting =
         *container_.all_objects().mutable_paintings(painting_id);
 
     painting.set_path(h_painting.path());
@@ -206,7 +247,14 @@ class DataPacker {
     Port& port = *container_.all_objects().mutable_ports(port_id);
 
     port.set_path(h_port.path());
-    port.set_orientation(h_port.orientation());
+    port.set_display_name(h_port.display_name());
+
+    if (h_port.no_shuffle()) {
+      port.set_no_shuffle(h_port.no_shuffle());
+    } else {
+      *port.mutable_destination() = h_port.destination();
+      port.set_rotation(h_port.rotation());
+    }
 
     // Setting this explicitly because the Godot protobuf doesn't support
     // custom defaults.
@@ -257,14 +305,31 @@ class DataPacker {
     uint64_t keyholder_id = container_.FindOrAddKeyholder(
         current_map_name, current_room_name, h_keyholder.name(), std::nullopt,
         std::nullopt);
-    Keyholder& keyholder =
+    KeyholderData& keyholder =
         *container_.all_objects().mutable_keyholders(keyholder_id);
 
     keyholder.set_path(h_keyholder.path());
 
+    if (h_keyholder.has_key()) {
+      keyholder.set_key(h_keyholder.key());
+    }
+
     return keyholder_id;
   }
 
+  uint64_t ProcessEnding(const HumanEnding& h_ending,
+                         const std::string& current_map_name,
+                         const std::string& current_room_name) {
+    uint64_t ending_id = container_.FindOrAddEnding(h_ending.name());
+    Ending& ending = *container_.all_objects().mutable_endings(ending_id);
+
+    ending.set_room_id(container_.FindOrAddRoom(
+        current_map_name, current_room_name, std::nullopt));
+    ending.set_path(h_ending.path());
+
+    return ending_id;
+  }
+
   void ProcessDoorsFile(std::filesystem::path path,
                         const std::string& current_map_name) {
     if (!std::filesystem::exists(path)) {
@@ -296,8 +361,8 @@ class DataPacker {
         h_door.receivers().begin(), h_door.receivers().end(),
         google::protobuf::RepeatedFieldBackInserter(door.mutable_receivers()));
     std::copy(
-        h_door.switches().begin(), h_door.switches().end(),
-        google::protobuf::RepeatedFieldBackInserter(door.mutable_switches()));
+        h_door.senders().begin(), h_door.senders().end(),
+        google::protobuf::RepeatedFieldBackInserter(door.mutable_senders()));
 
     for (const PaintingIdentifier& pi : h_door.move_paintings()) {
       std::optional<std::string> map_name =
@@ -346,6 +411,10 @@ class DataPacker {
           container_.FindOrAddDoor(map_name, di.name(), current_map_name));
     }
 
+    if (h_door.has_white_ending()) {
+      door.set_white_ending(h_door.white_ending());
+    }
+
     if (h_door.has_control_center_color()) {
       door.set_control_center_color(h_door.control_center_color());
     }
@@ -355,6 +424,22 @@ class DataPacker {
     }
 
     door.set_type(h_door.type());
+
+    if (h_door.has_location_name()) {
+      door.set_location_name(h_door.location_name());
+    }
+
+    if (h_door.has_double_letters()) {
+      door.set_double_letters(h_door.double_letters());
+    }
+
+    if (h_door.has_latch()) {
+      door.set_latch(h_door.latch());
+    }
+
+    if (h_door.has_legacy_location()) {
+      door.set_legacy_location(h_door.legacy_location());
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -406,6 +491,26 @@ class DataPacker {
       r_connection.set_required_door(door_id);
     }
 
+    if (human_connection.has_roof_access()) {
+      f_connection.set_roof_access(human_connection.roof_access());
+      r_connection.set_roof_access(human_connection.roof_access());
+    }
+
+    if (human_connection.has_purple_ending()) {
+      f_connection.set_purple_ending(human_connection.purple_ending());
+      r_connection.set_purple_ending(human_connection.purple_ending());
+    }
+
+    if (human_connection.has_cyan_ending()) {
+      f_connection.set_cyan_ending(human_connection.cyan_ending());
+      r_connection.set_cyan_ending(human_connection.cyan_ending());
+    }
+
+    if (human_connection.has_vanilla_only()) {
+      f_connection.set_vanilla_only(human_connection.vanilla_only());
+      r_connection.set_vanilla_only(human_connection.vanilla_only());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -489,8 +594,65 @@ class DataPacker {
     }
   }
 
+  void ProcessProgressivesFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_progs = ReadMessageFromFile<HumanProgressives>(path.string());
+
+    for (const HumanProgressive& h_prog : h_progs.progressives()) {
+      ProcessProgressive(h_prog);
+    }
+  }
+
+  void ProcessProgressive(const HumanProgressive& h_prog) {
+    uint64_t prog_id = container_.FindOrAddProgressive(h_prog.name());
+    Progressive& prog = *container_.all_objects().mutable_progressives(prog_id);
+
+    for (const DoorIdentifier& di : h_prog.doors()) {
+      uint64_t door_id =
+          container_.FindOrAddDoor(di.map(), di.name(), std::nullopt);
+      prog.add_doors(door_id);
+    }
+  }
+
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      ProcessDoorGroup(h_group);
+    }
+  }
+
+  void ProcessDoorGroup(const HumanDoorGroup& h_group) {
+    uint64_t group_id = container_.FindOrAddDoorGroup(h_group.name());
+    DoorGroup& group = *container_.all_objects().mutable_door_groups(group_id);
+
+    group.set_type(h_group.type());
+
+    for (const DoorIdentifier& di : h_group.doors()) {
+      uint64_t door_id =
+          container_.FindOrAddDoor(di.map(), di.name(), std::nullopt);
+      group.add_doors(door_id);
+    }
+  }
+
+  void ProcessGlobalMetadataFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
+    *container_.all_objects().mutable_version() = h_metadata.version();
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
-    auto ids = ReadMessageFromFile<IdMappings>(path.string());
+    auto ids = ReadIdsFromYaml(path.string());
 
     for (const auto& [map_name, map] : ids.maps()) {
       for (const auto& [door_name, ap_id] : map.doors()) {
@@ -513,6 +675,20 @@ class DataPacker {
               .mutable_masteries(mastery_id)
               ->set_ap_id(ap_id);
         }
+
+        for (const auto& [keyholder_name, ap_id] : room.keyholders()) {
+          uint64_t keyholder_id = container_.FindOrAddKeyholder(
+              map_name, room_name, keyholder_name, std::nullopt, std::nullopt);
+          container_.all_objects()
+              .mutable_keyholders(keyholder_id)
+              ->set_ap_id(ap_id);
+        }
+
+        for (const auto& [port_name, ap_id] : room.ports()) {
+          uint64_t port_id = container_.FindOrAddPort(
+              map_name, room_name, port_name, std::nullopt, std::nullopt);
+          container_.all_objects().mutable_ports(port_id)->set_ap_id(ap_id);
+        }
       }
     }
 
@@ -525,6 +701,21 @@ class DataPacker {
       uint64_t letter_id = container_.FindLetterByName(letter_name);
       container_.all_objects().mutable_letters(letter_id)->set_ap_id(ap_id);
     }
+
+    for (const auto& [ending_name, ap_id] : ids.endings()) {
+      uint64_t ending_id = container_.FindOrAddEnding(ending_name);
+      container_.all_objects().mutable_endings(ending_id)->set_ap_id(ap_id);
+    }
+
+    for (const auto& [prog_name, ap_id] : ids.progressives()) {
+      uint64_t prog_id = container_.FindOrAddProgressive(prog_name);
+      container_.all_objects().mutable_progressives(prog_id)->set_ap_id(ap_id);
+    }
+
+    for (const auto& [group_name, ap_id] : ids.door_groups()) {
+      uint64_t group_id = container_.FindOrAddDoorGroup(group_name);
+      container_.all_objects().mutable_door_groups(group_id)->set_ap_id(ap_id);
+    }
   }
 
   std::string mapdir_;
@@ -1,10 +1,13 @@
 find_package(Protobuf REQUIRED)
+find_package(yaml-cpp REQUIRED)
 
 add_library(util
+  godot_scene.cpp
   identifiers.cpp
+  ids_yaml_format.cpp
   naming.cpp
 )
 set_property(TARGET util PROPERTY CXX_STANDARD 20)
 set_property(TARGET util PROPERTY CXX_STANDARD_REQUIRED ON)
 target_include_directories(util PUBLIC ${CMAKE_BINARY_DIR})
-target_link_libraries(util PUBLIC protos protobuf::libprotobuf)
+target_link_libraries(util PUBLIC protos protobuf::libprotobuf yaml-cpp::yaml-cpp)
@@ -0,0 +1,207 @@
+#include "godot_scene.h"
+
+#include <fstream>
+#include <sstream>
+#include <string_view>
+#include <variant>
+
+namespace com::fourisland::lingo2_archipelago {
+
+namespace {
+
+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(std::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
+
+std::string GodotNode::GetPath() const {
+  if (parent.empty() || parent == ".") {
+    return name;
+  } else {
+    return parent + "/" + name;
+  }
+}
+
+GodotScene ReadGodotSceneFromFile(const std::string& path) {
+  std::map<std::string, GodotExtResource> ext_resources;
+  std::vector<GodotNode> nodes;
+
+  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 != "") {
+          nodes.push_back(GodotNode{.name = heading.name,
+                                    .parent = heading.parent,
+                                    .instance_type = heading.instance_type});
+        }
+      } 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 GodotScene(std::move(ext_resources), std::move(nodes));
+}
+
+}  // namespace com::fourisland::lingo2_archipelago
@@ -0,0 +1,57 @@
+#ifndef TOOLS_UTIL_TSCN_H_
+#define TOOLS_UTIL_TSCN_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+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>;
+
+struct GodotNode {
+  std::string name;
+  std::string parent;
+  GodotInstanceType instance_type;
+
+  std::string GetPath() const;
+};
+
+class GodotScene {
+ public:
+  GodotScene(std::map<std::string, GodotExtResource> ext_resources,
+             std::vector<GodotNode> nodes)
+      : ext_resources_(std::move(ext_resources)), nodes_(std::move(nodes)) {}
+
+  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;
+    }
+  }
+  const std::vector<GodotNode>& GetNodes() const { return nodes_; }
+
+ private:
+  std::map<std::string, GodotExtResource> ext_resources_;
+  std::vector<GodotNode> nodes_;
+};
+
+GodotScene ReadGodotSceneFromFile(const std::string& path);
+
+}  // namespace com::fourisland::lingo2_archipelago
+
+#endif /* TOOLS_UTIL_TSCN_H_ */
@@ -0,0 +1,203 @@
+#include "ids_yaml_format.h"
+
+#include <yaml-cpp/yaml.h>
+
+#include <fstream>
+#include <functional>
+
+namespace com::fourisland::lingo2_archipelago {
+namespace {
+
+template <typename T>
+void OperateOnSortedMap(
+    const T& map, std::function<void(const std::string& name,
+                                     const typename T::mapped_type& value)>
+                      callback) {
+  std::vector<std::string> names;
+  for (const auto& it : map) {
+    names.push_back(it.first);
+  }
+
+  std::sort(names.begin(), names.end());
+
+  for (const std::string& name : names) {
+    callback(name, map.at(name));
+  }
+}
+
+}  // namespace
+
+IdMappings ReadIdsFromYaml(const std::string& filename) {
+  IdMappings result;
+
+  YAML::Node document = YAML::LoadFile(filename);
+
+  if (document["maps"]) {
+    for (const auto& map_it : document["maps"]) {
+      IdMappings::MapIds& map_ids =
+          (*result.mutable_maps())[map_it.first.as<std::string>()];
+
+      if (map_it.second["rooms"]) {
+        for (const auto& room_it : map_it.second["rooms"]) {
+          IdMappings::RoomIds& room_ids =
+              (*map_ids.mutable_rooms())[room_it.first.as<std::string>()];
+
+          if (room_it.second["panels"]) {
+            for (const auto& panel_it : room_it.second["panels"]) {
+              (*room_ids.mutable_panels())[panel_it.first.as<std::string>()] =
+                  panel_it.second.as<uint64_t>();
+            }
+          }
+
+          if (room_it.second["masteries"]) {
+            for (const auto& mastery_it : room_it.second["masteries"]) {
+              (*room_ids
+                    .mutable_masteries())[mastery_it.first.as<std::string>()] =
+                  mastery_it.second.as<uint64_t>();
+            }
+          }
+
+          if (room_it.second["keyholders"]) {
+            for (const auto& keyholder_it : room_it.second["keyholders"]) {
+              (*room_ids.mutable_keyholders())[keyholder_it.first
+                                                   .as<std::string>()] =
+                  keyholder_it.second.as<uint64_t>();
+            }
+          }
+
+          if (room_it.second["ports"]) {
+            for (const auto& port_it : room_it.second["ports"]) {
+              (*room_ids.mutable_ports())[port_it.first.as<std::string>()] =
+                  port_it.second.as<uint64_t>();
+            }
+          }
+        }
+      }
+
+      if (map_it.second["doors"]) {
+        for (const auto& door_it : map_it.second["doors"]) {
+          (*map_ids.mutable_doors())[door_it.first.as<std::string>()] =
+              door_it.second.as<uint64_t>();
+        }
+      }
+    }
+  }
+
+  if (document["letters"]) {
+    for (const auto& letter_it : document["letters"]) {
+      (*result.mutable_letters())[letter_it.first.as<std::string>()] =
+          letter_it.second.as<uint64_t>();
+    }
+  }
+
+  if (document["endings"]) {
+    for (const auto& ending_it : document["endings"]) {
+      (*result.mutable_endings())[ending_it.first.as<std::string>()] =
+          ending_it.second.as<uint64_t>();
+    }
+  }
+
+  if (document["special"]) {
+    for (const auto& special_it : document["special"]) {
+      (*result.mutable_special())[special_it.first.as<std::string>()] =
+          special_it.second.as<uint64_t>();
+    }
+  }
+
+  if (document["progressives"]) {
+    for (const auto& prog_it : document["progressives"]) {
+      (*result.mutable_progressives())[prog_it.first.as<std::string>()] =
+          prog_it.second.as<uint64_t>();
+    }
+  }
+
+  if (document["door_groups"]) {
+    for (const auto& group_it : document["door_groups"]) {
+      (*result.mutable_door_groups())[group_it.first.as<std::string>()] =
+          group_it.second.as<uint64_t>();
+    }
+  }
+
+  return result;
+}
+
+void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
+  YAML::Node result;
+
+  OperateOnSortedMap(ids.maps(), [&result](const std::string& map_name,
+                                           const IdMappings::MapIds& map_ids) {
+    YAML::Node map_node;
+
+    OperateOnSortedMap(
+        map_ids.rooms(), [&map_node](const std::string& room_name,
+                                     const IdMappings::RoomIds& room_ids) {
+          YAML::Node room_node;
+
+          OperateOnSortedMap(
+              room_ids.panels(),
+              [&room_node](const std::string& panel_name, uint64_t panel_id) {
+                room_node["panels"][panel_name] = panel_id;
+              });
+
+          OperateOnSortedMap(room_ids.masteries(),
+                             [&room_node](const std::string& mastery_name,
+                                          uint64_t mastery_id) {
+                               room_node["masteries"][mastery_name] =
+                                   mastery_id;
+                             });
+
+          OperateOnSortedMap(room_ids.keyholders(),
+                             [&room_node](const std::string& keyholder_name,
+                                          uint64_t keyholder_id) {
+                               room_node["keyholders"][keyholder_name] =
+                                   keyholder_id;
+                             });
+
+          OperateOnSortedMap(
+              room_ids.ports(),
+              [&room_node](const std::string& port_name, uint64_t port_id) {
+                room_node["ports"][port_name] = port_id;
+              });
+
+          map_node["rooms"][room_name] = std::move(room_node);
+        });
+
+    OperateOnSortedMap(
+        map_ids.doors(),
+        [&map_node](const std::string& door_name, uint64_t door_id) {
+          map_node["doors"][door_name] = door_id;
+        });
+
+    result["maps"][map_name] = std::move(map_node);
+  });
+
+  OperateOnSortedMap(ids.letters(), [&result](const std::string& letter_name,
+                                              uint64_t letter_id) {
+    result["letters"][letter_name] = letter_id;
+  });
+
+  OperateOnSortedMap(ids.endings(), [&result](const std::string& ending_name,
+                                              uint64_t ending_id) {
+    result["endings"][ending_name] = ending_id;
+  });
+
+  OperateOnSortedMap(ids.special(), [&result](const std::string& special_name,
+                                              uint64_t special_id) {
+    result["special"][special_name] = special_id;
+  });
+
+  OperateOnSortedMap(ids.progressives(),
+                     [&result](const std::string& prog_name, uint64_t prog_id) {
+                       result["progressives"][prog_name] = prog_id;
+                     });
+
+  OperateOnSortedMap(ids.door_groups(), [&result](const std::string& group_name,
+                                                  uint64_t group_id) {
+    result["door_groups"][group_name] = group_id;
+  });
+
+  std::ofstream output_stream(filename);
+  output_stream << result << std::endl;
+}
+
+}  // namespace com::fourisland::lingo2_archipelago
@@ -0,0 +1,16 @@
+#ifndef TOOLS_UTIL_IDS_YAML_FORMAT_H_
+#define TOOLS_UTIL_IDS_YAML_FORMAT_H_
+
+#include <string>
+
+#include "proto/human.pb.h"
+
+namespace com::fourisland::lingo2_archipelago {
+
+IdMappings ReadIdsFromYaml(const std::string& filename);
+
+void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename);
+
+}  // namespace com::fourisland::lingo2_archipelago
+
+#endif /* TOOLS_UTIL_IDS_YAML_FORMAT_H_ */
@@ -1,6 +1,8 @@
+find_package(fmt REQUIRED)
 find_package(Protobuf REQUIRED)
 
 add_executable(validator
+  godot_processor.cpp
   human_processor.cpp
   main.cpp
   validator.cpp
@@ -8,4 +10,4 @@ add_executable(validator
 set_property(TARGET validator PROPERTY CXX_STANDARD 20)
 set_property(TARGET validator PROPERTY CXX_STANDARD_REQUIRED ON)
 target_include_directories(validator PUBLIC ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/tools)
-target_link_libraries(validator PUBLIC protos util protobuf::libprotobuf)
+target_link_libraries(validator PUBLIC protos util fmt::fmt protobuf::libprotobuf)
@@ -0,0 +1,72 @@
+#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;
+
+    GodotScene scene = ReadGodotSceneFromFile(scene_path_str);
+    for (const GodotNode& node : scene.GetNodes()) {
+      ProcessMapNode(scene, node, map_info);
+    }
+  }
+
+  void ProcessMapNode(const GodotScene& scene, const GodotNode& node,
+                      MapInfo& map_info) {
+    if (std::holds_alternative<GodotExtResourceRef>(node.instance_type)) {
+      const GodotExtResourceRef& ext_resource_ref =
+          std::get<GodotExtResourceRef>(node.instance_type);
+      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;
+      }
+    }
+  }
+
+ 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_ */
@@ -1,5 +1,6 @@
 #include "human_processor.h"
 
+#include <fmt/core.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/text_format.h>
 
@@ -12,6 +13,7 @@
 #include <string>
 
 #include "structs.h"
+#include "util/ids_yaml_format.h"
 
 namespace com::fourisland::lingo2_archipelago {
 namespace {
@@ -40,7 +42,9 @@ class HumanProcessor {
 
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
-    ProcessIdsFile(datadir_path / "ids.txtpb");
+    ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessIdsFile(datadir_path / "ids.yaml");
   }
 
  private:
@@ -53,13 +57,43 @@ class HumanProcessor {
   }
 
   void ProcessMap(std::filesystem::path path) {
-    std::string map_name = path.filename();
+    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++;
+    }
+
+    for (const std::string& path : metadata.custom_nodes()) {
+      map_info.game_nodes[path].defined = true;
+    }
+
+    if (metadata.has_worldport_entrance()) {
+      auto port_identifier = GetCompletePortIdentifier(
+          metadata.worldport_entrance(), current_map_name, std::nullopt);
+      if (port_identifier) {
+        PortInfo& port_info = info_.ports[*port_identifier];
+        port_info.map_worldport_entrances.push_back(current_map_name);
+      } else {
+        map_info.malformed_worldport_entrance = metadata.worldport_entrance();
+      }
+    }
+  }
+
   void ProcessRooms(std::filesystem::path path,
                     const std::string& current_map_name) {
     for (auto const& dir_entry : std::filesystem::directory_iterator(path)) {
@@ -78,7 +112,7 @@ class HumanProcessor {
     room_info.definitions.push_back(h_room);
 
     for (const HumanPanel& h_panel : h_room.panels()) {
-      ProcessPanel(h_panel, current_map_name, h_room.name());
+      ProcessPanel(h_panel, current_map_name, h_room);
     }
 
     for (const HumanPainting& h_painting : h_room.paintings()) {
@@ -100,23 +134,31 @@ class HumanProcessor {
     for (const HumanKeyholder& h_keyholder : h_room.keyholders()) {
       ProcessKeyholder(h_keyholder, current_map_name, h_room.name());
     }
+
+    for (const HumanEnding& h_ending : h_room.endings()) {
+      ProcessEnding(h_ending, current_map_name, h_room.name());
+    }
   }
 
   void ProcessPanel(const HumanPanel& h_panel,
                     const std::string& current_map_name,
-                    const std::string& current_room_name) {
+                    const HumanRoom& h_room) {
     PanelIdentifier panel_identifier;
     panel_identifier.set_map(current_map_name);
-    panel_identifier.set_room(current_room_name);
+    panel_identifier.set_room(h_room.name());
     panel_identifier.set_name(h_panel.name());
 
     PanelInfo& panel_info = info_.panels[panel_identifier];
     panel_info.definitions.push_back(h_panel);
-    panel_info.proxies[h_panel.answer()].definitions.push_back(Proxy());
+
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_panel.path()].uses++;
 
     for (const Proxy& h_proxy : h_panel.proxies()) {
       ProxyInfo& proxy_info = panel_info.proxies[h_proxy.answer()];
       proxy_info.definitions.push_back(h_proxy);
+
+      map_info.game_nodes[h_proxy.path()].uses++;
     }
 
     if (h_panel.has_required_door()) {
@@ -132,6 +174,24 @@ class HumanProcessor {
       RoomInfo& required_room_info = info_.rooms[required_room_identifier];
       required_room_info.panels_referenced_by.push_back(panel_identifier);
     }
+
+    std::string map_area_name = current_map_name;
+    if (h_room.has_panel_display_name()) {
+      map_area_name =
+          fmt::format("{} ({})", current_map_name, h_room.panel_display_name());
+    }
+
+    panel_info.map_area_name = map_area_name;
+
+    std::string panelsanity_name;
+    if (h_panel.has_display_name()) {
+      panelsanity_name =
+          fmt::format("{} - {}", map_area_name, h_panel.display_name());
+    } else {
+      panelsanity_name = fmt::format("{} - {}", map_area_name, h_panel.name());
+    }
+    info_.panel_names[panelsanity_name].panels_used_by.push_back(
+        panel_identifier);
   }
 
   void ProcessPainting(const HumanPainting& h_painting,
@@ -145,6 +205,9 @@ class HumanProcessor {
     PaintingInfo& painting_info = info_.paintings[painting_identifier];
     painting_info.definitions.push_back(h_painting);
 
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_painting.path()].uses++;
+
     if (h_painting.has_required_door()) {
       DoorIdentifier required_door_identifier = *GetCompleteDoorIdentifier(
           h_painting.required_door(), current_map_name);
@@ -163,6 +226,9 @@ class HumanProcessor {
     PortInfo& port_info = info_.ports[port_identifier];
     port_info.definitions.push_back(h_port);
 
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_port.path()].uses++;
+
     if (h_port.has_required_door()) {
       DoorIdentifier required_door_identifier =
           *GetCompleteDoorIdentifier(h_port.required_door(), current_map_name);
@@ -182,12 +248,16 @@ class HumanProcessor {
     room_identifier.set_map(current_map_name);
     room_identifier.set_name(current_room_name);
     letter_info.defined_in.push_back(room_identifier);
+
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_letter.path()].uses++;
   }
 
   void ProcessMastery(const HumanMastery& h_mastery,
                       const std::string& current_map_name,
                       const std::string& current_room_name) {
-    // Nothing really to validate about masteries yet.
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_mastery.path()].uses++;
   }
 
   void ProcessKeyholder(const HumanKeyholder& h_keyholder,
@@ -200,6 +270,23 @@ class HumanProcessor {
 
     KeyholderInfo& keyholder_info = info_.keyholders[keyholder_identifier];
     keyholder_info.definitions.push_back(h_keyholder);
+
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_keyholder.path()].uses++;
+  }
+
+  void ProcessEnding(const HumanEnding& h_ending,
+                     const std::string& current_map_name,
+                     const std::string& current_room_name) {
+    EndingInfo& ending_info = info_.endings[h_ending.name()];
+
+    RoomIdentifier room_identifier;
+    room_identifier.set_map(current_map_name);
+    room_identifier.set_name(current_room_name);
+    ending_info.defined_in.push_back(room_identifier);
+
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_ending.path()].uses++;
   }
 
   void ProcessDoorsFile(std::filesystem::path path,
@@ -317,7 +404,9 @@ class HumanProcessor {
       }
     } else if (human_connection.has_from()) {
       ProcessSingleConnection(human_connection, human_connection.from(),
-                              current_map_name);
+                              current_map_name,
+                              /*is_target=*/!human_connection.oneway() &&
+                                  !human_connection.bypass_target_door());
     }
 
     if (human_connection.has_to_room()) {
@@ -333,8 +422,9 @@ class HumanProcessor {
         std::cout << "A global connection used to_room." << std::endl;
       }
     } else if (human_connection.has_to()) {
-      ProcessSingleConnection(human_connection, human_connection.to(),
-                              current_map_name);
+      ProcessSingleConnection(
+          human_connection, human_connection.to(), current_map_name,
+          /*is_target=*/!human_connection.bypass_target_door());
     }
 
     if (human_connection.has_door()) {
@@ -355,7 +445,7 @@ class HumanProcessor {
   void ProcessSingleConnection(
       const HumanConnection& human_connection,
       const HumanConnection::Endpoint& endpoint,
-      const std::optional<std::string>& current_map_name) {
+      const std::optional<std::string>& current_map_name, bool is_target) {
     if (endpoint.has_room()) {
       auto room_identifier =
           GetCompleteRoomIdentifier(endpoint.room(), current_map_name);
@@ -374,6 +464,11 @@ class HumanProcessor {
       if (painting_identifier) {
         PaintingInfo& painting_info = info_.paintings[*painting_identifier];
         painting_info.connections_referenced_by.push_back(human_connection);
+
+        if (is_target) {
+          painting_info.target_connections_referenced_by.push_back(
+              human_connection);
+        }
       } else {
         // Not sure where else to store this right now.
         std::cout
@@ -386,6 +481,11 @@ class HumanProcessor {
       if (port_identifier) {
         PortInfo& port_info = info_.ports[*port_identifier];
         port_info.connections_referenced_by.push_back(human_connection);
+
+        if (is_target) {
+          port_info.target_connections_referenced_by.push_back(
+              human_connection);
+        }
       } else {
         // Not sure where else to store this right now.
         std::cout
@@ -403,12 +503,147 @@ class HumanProcessor {
           panel_info.proxies[endpoint.panel().answer()]
               .connections_referenced_by.push_back(human_connection);
         }
+
+        if (is_target) {
+          panel_info.target_connections_referenced_by.push_back(
+              human_connection);
+        }
+      }
+    }
+  }
+
+  void ProcessProgressivesFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_progs = ReadMessageFromFile<HumanProgressives>(path.string());
+
+    for (const HumanProgressive& h_prog : h_progs.progressives()) {
+      ProcessProgressive(h_prog);
+    }
+  }
+
+  void ProcessProgressive(const HumanProgressive& h_prog) {
+    ProgressiveInfo& prog_info = info_.progressives[h_prog.name()];
+    prog_info.definitions.push_back(h_prog);
+
+    for (const DoorIdentifier& di : h_prog.doors()) {
+      if (!di.has_map()) {
+        prog_info.malformed_doors.push_back(di);
+        continue;
+      }
+
+      DoorInfo& door_info = info_.doors[di];
+      door_info.progressives_referenced_by.push_back(h_prog.name());
+    }
+  }
+
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      ProcessDoorGroup(h_group);
+    }
+  }
+
+  void ProcessDoorGroup(const HumanDoorGroup& h_group) {
+    DoorGroupInfo& group_info = info_.door_groups[h_group.name()];
+    group_info.definitions.push_back(h_group);
+
+    for (const DoorIdentifier& di : h_group.doors()) {
+      if (!di.has_map()) {
+        group_info.malformed_doors.push_back(di);
+        continue;
       }
+
+      DoorInfo& door_info = info_.doors[di];
+      door_info.door_groups_referenced_by.push_back(h_group.name());
     }
   }
 
   void ProcessIdsFile(std::filesystem::path path) {
-    // Ignore this for now.
+    auto ids = ReadIdsFromYaml(path.string());
+
+    DoorIdentifier di;
+    PanelIdentifier pai;
+    PortIdentifier poi;
+    KeyholderIdentifier ki;
+
+    for (const auto& [map_name, map] : ids.maps()) {
+      di.set_map(map_name);
+      pai.set_map(map_name);
+      poi.set_map(map_name);
+      ki.set_map(map_name);
+
+      for (const auto& [door_name, ap_id] : map.doors()) {
+        di.set_name(door_name);
+
+        DoorInfo& door_info = info_.doors[di];
+        door_info.has_id = true;
+      }
+
+      for (const auto& [room_name, room] : map.rooms()) {
+        pai.set_room(room_name);
+        poi.set_room(room_name);
+        ki.set_room(room_name);
+
+        for (const auto& [panel_name, ap_id] : room.panels()) {
+          pai.set_name(panel_name);
+
+          PanelInfo& panel_info = info_.panels[pai];
+          panel_info.has_id = true;
+        }
+
+        for (const auto& [mastery_name, ap_id] : room.masteries()) {
+          // TODO: Mastery
+        }
+
+        for (const auto& [keyholder_name, ap_id] : room.keyholders()) {
+          ki.set_name(keyholder_name);
+
+          KeyholderInfo& keyholder_info = info_.keyholders[ki];
+          keyholder_info.has_id = true;
+        }
+
+        for (const auto& [port_name, ap_id] : room.ports()) {
+          poi.set_name(port_name);
+
+          PortInfo& port_info = info_.ports[poi];
+          port_info.has_id = true;
+        }
+      }
+    }
+
+    for (const auto& [tag, id] : ids.special()) {
+      // TODO: Specials
+    }
+
+    for (const auto& [letter_name, ap_id] : ids.letters()) {
+      LetterIdentifier li =
+          std::make_tuple(letter_name[0], letter_name[1] == '2');
+      LetterInfo& letter_info = info_.letters[li];
+      letter_info.has_id = true;
+    }
+
+    for (const auto& [ending_name, ap_id] : ids.endings()) {
+      EndingInfo& ending_info = info_.endings[ending_name];
+      ending_info.has_id = true;
+    }
+
+    for (const auto& [prog_name, ap_id] : ids.progressives()) {
+      ProgressiveInfo& prog_info = info_.progressives[prog_name];
+      prog_info.has_id = true;
+    }
+
+    for (const auto& [group_name, ap_id] : ids.door_groups()) {
+      DoorGroupInfo& group_info = info_.door_groups[group_name];
+      group_info.has_id = true;
+    }
   }
 
   std::string mapdir_;
@@ -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;
 }
@@ -20,6 +20,17 @@ struct MalformedIdentifiers {
   }
 };
 
+struct GameNodeInfo {
+  bool defined = false;
+  int uses = 0;
+};
+
+struct MapInfo {
+  std::map<std::string, GameNodeInfo> game_nodes;
+
+  std::optional<PortIdentifier> malformed_worldport_entrance;
+};
+
 struct RoomInfo {
   std::vector<HumanRoom> definitions;
 
@@ -30,26 +41,33 @@ struct RoomInfo {
 
 struct DoorInfo {
   std::vector<HumanDoor> definitions;
+  bool has_id = false;
 
   std::vector<HumanConnection> connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
   std::vector<PanelIdentifier> panels_referenced_by;
   std::vector<PaintingIdentifier> paintings_referenced_by;
   std::vector<PortIdentifier> ports_referenced_by;
+  std::vector<std::string> progressives_referenced_by;
+  std::vector<std::string> door_groups_referenced_by;
 
   MalformedIdentifiers malformed_identifiers;
 };
 
 struct PortInfo {
   std::vector<HumanPort> definitions;
+  bool has_id = false;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
+  std::vector<std::string> map_worldport_entrances;
 };
 
 struct PaintingInfo {
   std::vector<HumanPainting> definitions;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
 };
 
@@ -62,8 +80,12 @@ struct ProxyInfo {
 
 struct PanelInfo {
   std::vector<HumanPanel> definitions;
+  bool has_id = false;
+
+  std::string map_area_name;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
 
   std::map<std::string, ProxyInfo> proxies;
@@ -71,6 +93,7 @@ struct PanelInfo {
 
 struct KeyholderInfo {
   std::vector<HumanKeyholder> definitions;
+  bool has_id = false;
 
   std::vector<DoorIdentifier> doors_referenced_by;
 };
@@ -79,9 +102,34 @@ using LetterIdentifier = std::tuple<char, bool>;
 
 struct LetterInfo {
   std::vector<RoomIdentifier> defined_in;
+  bool has_id = false;
+};
+
+struct EndingInfo {
+  std::vector<RoomIdentifier> defined_in;
+  bool has_id = false;
+};
+
+struct PanelNameInfo {
+  std::vector<PanelIdentifier> panels_used_by;
+};
+
+struct ProgressiveInfo {
+  std::vector<HumanProgressive> definitions;
+  bool has_id = false;
+
+  std::vector<DoorIdentifier> malformed_doors;
+};
+
+struct DoorGroupInfo {
+  std::vector<HumanDoorGroup> definitions;
+  bool has_id = false;
+
+  std::vector<DoorIdentifier> malformed_doors;
 };
 
 struct CollectedInfo {
+  std::map<std::string, MapInfo> maps;
   std::map<RoomIdentifier, RoomInfo, RoomIdentifierLess> rooms;
   std::map<DoorIdentifier, DoorInfo, DoorIdentifierLess> doors;
   std::map<PortIdentifier, PortInfo, PortIdentifierLess> ports;
@@ -90,6 +138,10 @@ struct CollectedInfo {
   std::map<KeyholderIdentifier, KeyholderInfo, KeyholderIdentifierLess>
       keyholders;
   std::map<LetterIdentifier, LetterInfo> letters;
+  std::map<std::string, EndingInfo> endings;
+  std::map<std::string, PanelNameInfo> panel_names;
+  std::map<std::string, ProgressiveInfo> progressives;
+  std::map<std::string, DoorGroupInfo> door_groups;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -9,242 +9,579 @@
 namespace com::fourisland::lingo2_archipelago {
 namespace {
 
-void ValidateRoom(const RoomIdentifier& room_identifier,
-                  const RoomInfo& room_info) {
-  if (room_info.definitions.empty()) {
-    std::cout << "Room " << room_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
-
-    for (const DoorIdentifier& door_identifier :
-         room_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+class Validator {
+ public:
+  explicit Validator(const CollectedInfo& info) : info_(info) {}
+
+  void Validate() const {
+    for (const auto& [map_name, map_info] : info_.maps) {
+      ValidateMap(map_name, map_info);
+    }
+    for (const auto& [room_identifier, room_info] : info_.rooms) {
+      ValidateRoom(room_identifier, room_info);
+    }
+    for (const auto& [door_identifier, door_info] : info_.doors) {
+      ValidateDoor(door_identifier, door_info);
+    }
+    for (const auto& [port_identifier, port_info] : info_.ports) {
+      ValidatePort(port_identifier, port_info);
+    }
+    for (const auto& [painting_identifier, painting_info] : info_.paintings) {
+      ValidatePainting(painting_identifier, painting_info);
+    }
+    for (const auto& [panel_identifier, panel_info] : info_.panels) {
+      ValidatePanel(panel_identifier, panel_info);
+    }
+    for (const auto& [keyholder_identifier, keyholder_info] :
+         info_.keyholders) {
+      ValidateKeyholder(keyholder_identifier, keyholder_info);
+    }
+    for (const auto& [letter_identifier, letter_info] : info_.letters) {
+      ValidateLetter(letter_identifier, letter_info);
+    }
+    for (const auto& [ending_name, ending_info] : info_.endings) {
+      ValidateEnding(ending_name, ending_info);
+    }
+    for (const auto& [panel_name, panel_info] : info_.panel_names) {
+      ValidatePanelName(panel_name, panel_info);
+    }
+    for (const auto& [prog_name, prog_info] : info_.progressives) {
+      ValidateProgressive(prog_name, prog_info);
     }
+    for (const auto& [group_name, group_info] : info_.door_groups) {
+      ValidateDoorGroup(group_name, group_info);
+    }
+  }
 
-    for (const PanelIdentifier& panel_identifier :
-         room_info.panels_referenced_by) {
-      std::cout << "    PANEL " << panel_identifier.ShortDebugString()
-                << std::endl;
+ private:
+  void ValidateMap(const std::string& map_name, const MapInfo& map_info) const {
+    for (const auto& [node_path, node_info] : map_info.game_nodes) {
+      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;
+      }
     }
 
-    for (const HumanConnection& connection :
-         room_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    if (map_info.malformed_worldport_entrance) {
+      std::cout << "The worldport entrance for map " << map_name
+                << " is malformed." << std::endl;
     }
-  } else if (room_info.definitions.size() > 1) {
-    std::cout << "Room " << room_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidateDoor(const DoorIdentifier& door_identifier,
-                  const DoorInfo& door_info) {
-  if (door_info.definitions.empty()) {
-    std::cout << "Door " << door_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+  void ValidateRoom(const RoomIdentifier& room_identifier,
+                    const RoomInfo& room_info) const {
+    if (room_info.definitions.empty()) {
+      std::cout << "Room " << room_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const DoorIdentifier& other_door_identifier :
-         door_info.doors_referenced_by) {
-      std::cout << "    DOOR " << other_door_identifier.ShortDebugString()
-                << std::endl;
+      for (const DoorIdentifier& door_identifier :
+           room_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PanelIdentifier& panel_identifier :
+           room_info.panels_referenced_by) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const HumanConnection& connection :
+           room_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+    } else if (room_info.definitions.size() > 1) {
+      std::cout << "Room " << room_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
+  }
 
-    for (const PanelIdentifier& panel_identifier :
-         door_info.panels_referenced_by) {
-      std::cout << "    PANEL " << panel_identifier.ShortDebugString()
-                << std::endl;
+  bool DoesDoorNeedLocationName(const HumanDoor& h_door,
+                                const std::string& map_name) const {
+    if (h_door.type() != DoorType::STANDARD) {
+      return false;
     }
 
-    for (const PaintingIdentifier& painting_identifier :
-         door_info.paintings_referenced_by) {
-      std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
-                << std::endl;
+    if (h_door.keyholders_size() > 0 || h_door.white_ending() ||
+        h_door.complete_at() > 0) {
+      return true;
     }
 
-    for (const PortIdentifier& port_identifier :
-         door_info.ports_referenced_by) {
-      std::cout << "    PORT " << port_identifier.ShortDebugString()
-                << std::endl;
+    if (h_door.panels_size() > 4) {
+      return true;
     }
 
-    for (const HumanConnection& connection :
-         door_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    std::set<std::string> map_areas;
+    for (const PanelIdentifier& pi : h_door.panels()) {
+      auto full_pi =
+          GetCompletePanelIdentifierWithoutAnswer(pi, map_name, std::nullopt);
+      if (full_pi) {
+        auto panel_info_it = info_.panels.find(*full_pi);
+        if (panel_info_it != info_.panels.end()) {
+          const PanelInfo& panel_info = panel_info_it->second;
+
+          map_areas.insert(panel_info.map_area_name);
+        }
+      }
+    }
+
+    if (map_areas.size() > 1) {
+      return true;
     }
-  } else if (door_info.definitions.size() > 1) {
-    std::cout << "Door " << door_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
+
+    return false;
   }
 
-  if (door_info.malformed_identifiers.HasAny()) {
-    std::cout << "Door " << door_identifier.ShortDebugString()
-              << " has malformed identifiers:" << std::endl;
+  void ValidateDoor(const DoorIdentifier& door_identifier,
+                    const DoorInfo& door_info) const {
+    if (door_info.definitions.empty()) {
+      std::cout << "Door " << door_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const PaintingIdentifier& painting_identifier :
-         door_info.malformed_identifiers.paintings) {
-      std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
-                << std::endl;
-    }
+      for (const DoorIdentifier& other_door_identifier :
+           door_info.doors_referenced_by) {
+        std::cout << "    DOOR " << other_door_identifier.ShortDebugString()
+                  << std::endl;
+      }
 
-    for (const PanelIdentifier& panel_identifier :
-         door_info.malformed_identifiers.panels) {
-      std::cout << "    PANEL " << panel_identifier.ShortDebugString()
-                << std::endl;
+      for (const PanelIdentifier& panel_identifier :
+           door_info.panels_referenced_by) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PaintingIdentifier& painting_identifier :
+           door_info.paintings_referenced_by) {
+        std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PortIdentifier& port_identifier :
+           door_info.ports_referenced_by) {
+        std::cout << "    PORT " << port_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const HumanConnection& connection :
+           door_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const std::string& prog_name :
+           door_info.progressives_referenced_by) {
+        std::cout << "    PROGRESSIVE " << prog_name << std::endl;
+      }
+
+      for (const std::string& group_name :
+           door_info.door_groups_referenced_by) {
+        std::cout << "    DOOR GROUP " << group_name << std::endl;
+      }
+
+      if (door_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (door_info.definitions.size() > 1) {
+      std::cout << "Door " << door_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
 
-    for (const KeyholderIdentifier& keyholder_identifier :
-         door_info.malformed_identifiers.keyholders) {
-      std::cout << "    KEYHOLDER " << keyholder_identifier.ShortDebugString()
-                << std::endl;
+    if (door_info.malformed_identifiers.HasAny()) {
+      std::cout << "Door " << door_identifier.ShortDebugString()
+                << " has malformed identifiers:" << std::endl;
+
+      for (const PaintingIdentifier& painting_identifier :
+           door_info.malformed_identifiers.paintings) {
+        std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PanelIdentifier& panel_identifier :
+           door_info.malformed_identifiers.panels) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const KeyholderIdentifier& keyholder_identifier :
+           door_info.malformed_identifiers.keyholders) {
+        std::cout << "    KEYHOLDER " << keyholder_identifier.ShortDebugString()
+                  << std::endl;
+      }
     }
-  }
-}
 
-void ValidatePort(const PortIdentifier& port_identifier,
-                  const PortInfo& port_info) {
-  if (port_info.definitions.empty()) {
-    std::cout << "Port " << port_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+    for (const HumanDoor& h_door : door_info.definitions) {
+      if (DoesDoorNeedLocationName(h_door, door_identifier.map()) &&
+          !h_door.has_location_name()) {
+        std::cout << "Door " << door_identifier.ShortDebugString()
+                  << " needs an explicit location name." << std::endl;
+      }
 
-    for (const HumanConnection& connection :
-         port_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+      if (h_door.type() == DoorType::STANDARD ||
+          h_door.type() == DoorType::LOCATION_ONLY ||
+          h_door.type() == DoorType::GRAVESTONE || h_door.legacy_location()) {
+        if (h_door.double_letters()) {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " is a location that depends on double_letters."
+                    << std::endl;
+        }
+
+        if (!h_door.has_location_room()) {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " is missing a location_room." << std::endl;
+        }
+      }
+
+      bool needs_id = (h_door.type() != DoorType::EVENT || h_door.latch() ||
+                       h_door.legacy_location());
+      if (door_info.has_id != needs_id) {
+        if (needs_id) {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        } else {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
+      }
     }
-  } else if (port_info.definitions.size() > 1) {
-    std::cout << "Port " << port_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidatePainting(const PaintingIdentifier& painting_identifier,
-                      const PaintingInfo& painting_info) {
-  if (painting_info.definitions.empty()) {
-    std::cout << "Painting " << painting_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+  void ValidatePort(const PortIdentifier& port_identifier,
+                    const PortInfo& port_info) const {
+    if (port_info.definitions.empty()) {
+      std::cout << "Port " << port_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const DoorIdentifier& door_identifier :
-         painting_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+      for (const HumanConnection& connection :
+           port_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const std::string& map_name : port_info.map_worldport_entrances) {
+        std::cout << "    MAP (worldport_entrance) " << map_name << std::endl;
+      }
+
+      if (port_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (port_info.definitions.size() > 1) {
+      std::cout << "Port " << port_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
 
-    for (const HumanConnection& connection :
-         painting_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    if (!port_info.target_connections_referenced_by.empty()) {
+      for (const HumanPort& port : port_info.definitions) {
+        if (port.has_required_door()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " has a required door but is the target of a connection:"
+                    << std::endl;
+
+          for (const HumanConnection& connection :
+               port_info.target_connections_referenced_by) {
+            std::cout << "    CONNECTION " << connection.ShortDebugString()
+                      << std::endl;
+          }
+        }
+      }
+    }
+
+    for (const HumanPort& port : port_info.definitions) {
+      if (!port.no_shuffle()) {
+        if (!port.has_destination()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is shuffleable and missing a destination."
+                    << std::endl;
+        }
+        if (!port.has_rotation()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is shuffleable and missing a rotation." << std::endl;
+        }
+        if (!port_info.has_id) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        }
+      } else {
+        if (port_info.has_id) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
+      }
     }
-  } else if (painting_info.definitions.size() > 1) {
-    std::cout << "Painting " << painting_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidatePanel(const PanelIdentifier& panel_identifier,
-                   const PanelInfo& panel_info) {
-  if (panel_info.definitions.empty()) {
-    std::cout << "Panel " << panel_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+  void ValidatePainting(const PaintingIdentifier& painting_identifier,
+                        const PaintingInfo& painting_info) const {
+    if (painting_info.definitions.empty()) {
+      std::cout << "Painting " << painting_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const DoorIdentifier& door_identifier :
-         panel_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+      for (const DoorIdentifier& door_identifier :
+           painting_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const HumanConnection& connection :
+           painting_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+    } else if (painting_info.definitions.size() > 1) {
+      std::cout << "Painting " << painting_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
 
-    for (const HumanConnection& connection :
-         panel_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    if (!painting_info.target_connections_referenced_by.empty()) {
+      for (const HumanPainting& painting : painting_info.definitions) {
+        if (painting.has_required_door()) {
+          std::cout << "Painting " << painting_identifier.ShortDebugString()
+                    << " has a required door but is the target of a connection:"
+                    << std::endl;
+
+          for (const HumanConnection& connection :
+               painting_info.target_connections_referenced_by) {
+            std::cout << "    CONNECTION " << connection.ShortDebugString()
+                      << std::endl;
+          }
+        }
+      }
     }
-  } else if (panel_info.definitions.size() > 1) {
-    std::cout << "Panel " << panel_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
 
-  for (const auto& [answer, proxy_info] : panel_info.proxies) {
-    if (proxy_info.definitions.empty()) {
+  void ValidatePanel(const PanelIdentifier& panel_identifier,
+                     const PanelInfo& panel_info) const {
+    if (panel_identifier.name().empty()) {
       std::cout << "Panel " << panel_identifier.ShortDebugString()
-                << " with answer \"" << answer
-                << "\" has no definition, but was referenced:" << std::endl;
+                << " has no name." << std::endl;
+    }
+
+    if (panel_info.definitions.empty()) {
+      std::cout << "Panel " << panel_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
       for (const DoorIdentifier& door_identifier :
-           proxy_info.doors_referenced_by) {
+           panel_info.doors_referenced_by) {
         std::cout << "    DOOR " << door_identifier.ShortDebugString()
                   << std::endl;
       }
 
       for (const HumanConnection& connection :
-           proxy_info.connections_referenced_by) {
+           panel_info.connections_referenced_by) {
         std::cout << "    CONNECTION " << connection.ShortDebugString()
                   << std::endl;
       }
-    } else if (proxy_info.definitions.size() > 1) {
+
+      if (panel_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (panel_info.definitions.size() > 1) {
       std::cout << "Panel " << panel_identifier.ShortDebugString()
-                << " with answer \"" << answer
-                << "\" was defined multiple times." << std::endl;
+                << " was defined multiple times." << std::endl;
+    }
+
+    for (const auto& [answer, proxy_info] : panel_info.proxies) {
+      if (proxy_info.definitions.empty()) {
+        std::cout << "Panel " << panel_identifier.ShortDebugString()
+                  << " with answer \"" << answer
+                  << "\" has no definition, but was referenced:" << std::endl;
+
+        for (const DoorIdentifier& door_identifier :
+             proxy_info.doors_referenced_by) {
+          std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                    << std::endl;
+        }
+
+        for (const HumanConnection& connection :
+             proxy_info.connections_referenced_by) {
+          std::cout << "    CONNECTION " << connection.ShortDebugString()
+                    << std::endl;
+        }
+      } else if (proxy_info.definitions.size() > 1) {
+        std::cout << "Panel " << panel_identifier.ShortDebugString()
+                  << " with answer \"" << answer
+                  << "\" was defined multiple times." << std::endl;
+      }
     }
-  }
-}
 
-void ValidateKeyholder(const KeyholderIdentifier& keyholder_identifier,
-                       const KeyholderInfo& keyholder_info) {
-  if (keyholder_info.definitions.empty()) {
-    std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+    if (!panel_info.has_id) {
+      std::cout << "Panel " << panel_identifier.ShortDebugString()
+                << " is missing an AP ID." << std::endl;
+    }
 
-    for (const DoorIdentifier& door_identifier :
-         keyholder_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+    if (!panel_info.target_connections_referenced_by.empty()) {
+      for (const HumanPanel& panel : panel_info.definitions) {
+        if (panel.has_required_door()) {
+          std::cout << "Panel " << panel_identifier.ShortDebugString()
+                    << " has a required door but is the target of a connection:"
+                    << std::endl;
+
+          for (const HumanConnection& connection :
+               panel_info.target_connections_referenced_by) {
+            std::cout << "    CONNECTION " << connection.ShortDebugString()
+                      << std::endl;
+          }
+        }
+      }
     }
-  } else if (keyholder_info.definitions.size() > 1) {
-    std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidateLetter(const LetterIdentifier& letter_identifier,
-                    const LetterInfo& letter_info) {
-  std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
-                            (std::get<1>(letter_identifier) ? "2" : "1");
+  void ValidateKeyholder(const KeyholderIdentifier& keyholder_identifier,
+                         const KeyholderInfo& keyholder_info) const {
+    if (keyholder_info.definitions.empty()) {
+      std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-  if (letter_info.defined_in.size() > 1) {
-    std::cout << "Letter " << letter_name
-              << " was defined in multiple places:" << std::endl;
+      for (const DoorIdentifier& door_identifier :
+           keyholder_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
 
-    for (const RoomIdentifier& room_identifier : letter_info.defined_in) {
-      std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      if (keyholder_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (keyholder_info.definitions.size() > 1) {
+      std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
+    }
+
+    for (const HumanKeyholder& h_keyholder : keyholder_info.definitions) {
+      bool needs_id = (h_keyholder.has_key());
+
+      if (needs_id != keyholder_info.has_id) {
+        if (needs_id) {
+          std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        } else {
+          std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
+      }
     }
   }
-}
 
-}  // namespace
+  void ValidateLetter(const LetterIdentifier& letter_identifier,
+                      const LetterInfo& letter_info) const {
+    std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
+                              (std::get<1>(letter_identifier) ? "2" : "1");
 
-void ValidateCollectedInfo(const CollectedInfo& info) {
-  for (const auto& [room_identifier, room_info] : info.rooms) {
-    ValidateRoom(room_identifier, room_info);
-  }
-  for (const auto& [door_identifier, door_info] : info.doors) {
-    ValidateDoor(door_identifier, door_info);
-  }
-  for (const auto& [port_identifier, port_info] : info.ports) {
-    ValidatePort(port_identifier, port_info);
+    if (letter_info.defined_in.empty()) {
+      std::cout << "Letter " << letter_name
+                << " has no definition, but was referenced:" << std::endl;
+
+      if (letter_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (letter_info.defined_in.size() > 1) {
+      std::cout << "Letter " << letter_name
+                << " was defined in multiple places:" << std::endl;
+
+      for (const RoomIdentifier& room_identifier : letter_info.defined_in) {
+        std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      }
+    }
+
+    if (!letter_info.has_id) {
+      std::cout << "Letter " << letter_name << " is missing an AP ID."
+                << std::endl;
+    }
   }
-  for (const auto& [painting_identifier, painting_info] : info.paintings) {
-    ValidatePainting(painting_identifier, painting_info);
+
+  void ValidateEnding(const std::string& ending_name,
+                      const EndingInfo& ending_info) const {
+    if (ending_info.defined_in.empty()) {
+      std::cout << "Ending " << ending_name
+                << " has no definition, but was referenced:" << std::endl;
+
+      if (ending_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (ending_info.defined_in.size() > 1) {
+      std::cout << "Ending " << ending_name
+                << " was defined in multiple places:" << std::endl;
+
+      for (const RoomIdentifier& room_identifier : ending_info.defined_in) {
+        std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      }
+    }
+
+    if (!ending_info.has_id) {
+      std::cout << "Ending " << ending_name << " is missing an AP ID."
+                << std::endl;
+    }
   }
-  for (const auto& [panel_identifier, panel_info] : info.panels) {
-    ValidatePanel(panel_identifier, panel_info);
+
+  void ValidatePanelName(const std::string& panel_name,
+                         const PanelNameInfo& panel_info) const {
+    if (panel_info.panels_used_by.size() > 1) {
+      std::cout << "The location name \"" << panel_name
+                << "\" is used by multiple panels:" << std::endl;
+
+      for (const PanelIdentifier& panel_identifier :
+           panel_info.panels_used_by) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+    }
   }
-  for (const auto& [keyholder_identifier, keyholder_info] : info.keyholders) {
-    ValidateKeyholder(keyholder_identifier, keyholder_info);
+
+  void ValidateProgressive(const std::string& prog_name,
+                           const ProgressiveInfo& prog_info) const {
+    if (prog_info.definitions.empty()) {
+      std::cout << "Progressive \"" << prog_name
+                << "\" has no definition, but was referenced:" << std::endl;
+
+      if (prog_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (prog_info.definitions.size() > 1) {
+      std::cout << "Progressive \"" << prog_name
+                << "\" has multiple definitions." << std::endl;
+    }
+
+    if (!prog_info.has_id) {
+      std::cout << "Progressive \"" << prog_name << "\" is missing an AP ID."
+                << std::endl;
+    }
   }
-  for (const auto& [letter_identifier, letter_info] : info.letters) {
-    ValidateLetter(letter_identifier, letter_info);
+
+  void ValidateDoorGroup(const std::string& group_name,
+                         const DoorGroupInfo& group_info) const {
+    if (group_info.definitions.empty()) {
+      std::cout << "Door group \"" << group_name
+                << "\" has no definition, but was referenced:" << std::endl;
+
+      if (group_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (group_info.definitions.size() > 1) {
+      std::cout << "Door group \"" << group_name
+                << "\" has multiple definitions." << std::endl;
+    }
+
+    if (!group_info.has_id) {
+      std::cout << "Door group \"" << group_name << "\" is missing an AP ID."
+                << std::endl;
+    }
   }
+
+  const CollectedInfo& info_;
+};
+
+}  // namespace
+
+void ValidateCollectedInfo(const CollectedInfo& info) {
+  Validator validator(info);
+  validator.Validate();
 }
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -1,4 +1,4 @@
-#ifndef TOOLS_VALIDATOR_VALIDATOR_H_
+#ifndef TOOLS_VALIDATOR_VALIDATOR_H
 #define TOOLS_VALIDATOR_VALIDATOR_H
 
 namespace com::fourisland::lingo2_archipelago {