5 files changed, 467 insertions, 21 deletions

@@ -13,6 +13,7 @@
 #include <string>
 
 #include "structs.h"
+#include "util/ids_yaml_format.h"
 
 namespace com::fourisland::lingo2_archipelago {
 namespace {
@@ -41,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:
@@ -71,9 +74,35 @@ class HumanProcessor {
     MapInfo& map_info = info_.maps[current_map_name];
 
     auto metadata = ReadMessageFromFile<HumanMap>(path.string());
+    map_info.definitions.push_back(metadata);
+
     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();
+      }
+    }
+
+    if (metadata.has_rte_room()) {
+      RoomIdentifier room_identifier;
+      room_identifier.set_map(current_map_name);
+      room_identifier.set_name(metadata.rte_room());
+
+      RoomInfo& room_info = info_.rooms[room_identifier];
+      room_info.map_rtes_referenced_by.push_back(current_map_name);
+    }
   }
 
   void ProcessRooms(std::filesystem::path path,
@@ -355,11 +384,6 @@ class HumanProcessor {
       DoorInfo& other_door_info = info_.doors[complete_door_identifier];
       other_door_info.doors_referenced_by.push_back(door_identifier);
     }
-
-    for (const std::string& ei : h_door.endings()) {
-      EndingInfo& ending_info = info_.endings[ei];
-      ending_info.doors_referenced_by.push_back(door_identifier);
-    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -391,7 +415,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()) {
@@ -407,8 +433,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()) {
@@ -429,7 +456,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);
@@ -448,6 +475,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
@@ -460,6 +492,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
@@ -477,12 +514,152 @@ 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;
+        }
+      }
+
+      if (map.has_rte()) {
+        MapInfo& map_info = info_.maps[map_name];
+        map_info.has_rte_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_;
@@ -21,7 +21,9 @@ void Run(const std::string& mapdir, const std::string& repodir) {
 int main(int argc, char** argv) {
   if (argc != 3) {
     std::cout << "Incorrect argument count." << std::endl;
-    std::cout << "Usage: validator [path to map directory] [path to Lingo 2 repository]" << std::endl;
+    std::cout << "Usage: validator [path to map directory] [path to Lingo 2 "
+                 "repository]"
+              << std::endl;
     return 1;
   }
 
@@ -27,6 +27,11 @@ struct GameNodeInfo {
 
 struct MapInfo {
   std::map<std::string, GameNodeInfo> game_nodes;
+
+  std::vector<HumanMap> definitions;
+  bool has_rte_id = false;
+
+  std::optional<PortIdentifier> malformed_worldport_entrance;
 };
 
 struct RoomInfo {
@@ -35,30 +40,38 @@ struct RoomInfo {
   std::vector<DoorIdentifier> doors_referenced_by;
   std::vector<PanelIdentifier> panels_referenced_by;
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<std::string> map_rtes_referenced_by;
 };
 
 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;
 };
 
@@ -71,10 +84,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;
@@ -82,6 +97,7 @@ struct PanelInfo {
 
 struct KeyholderInfo {
   std::vector<HumanKeyholder> definitions;
+  bool has_id = false;
 
   std::vector<DoorIdentifier> doors_referenced_by;
 };
@@ -90,18 +106,32 @@ using LetterIdentifier = std::tuple<char, bool>;
 
 struct LetterInfo {
   std::vector<RoomIdentifier> defined_in;
+  bool has_id = false;
 };
 
 struct EndingInfo {
   std::vector<RoomIdentifier> defined_in;
-
-  std::vector<DoorIdentifier> doors_referenced_by;
+  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;
@@ -114,6 +144,8 @@ struct CollectedInfo {
   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
@@ -1,5 +1,6 @@
 #include "validator.h"
 
+#include <algorithm>
 #include <iostream>
 
 #include "proto/human.pb.h"
@@ -45,6 +46,12 @@ class Validator {
     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);
+    }
   }
 
  private:
@@ -63,6 +70,27 @@ class Validator {
                   << " is not defined in the game file." << std::endl;
       }
     }
+
+    if (map_info.malformed_worldport_entrance) {
+      std::cout << "The worldport entrance for map " << map_name
+                << " is malformed." << std::endl;
+    }
+
+    if (map_info.has_rte_id) {
+      if (!std::any_of(
+              map_info.definitions.begin(), map_info.definitions.end(),
+              [](const HumanMap& h_map) { return h_map.has_rte_room(); })) {
+        std::cout << "Map " << map_name << " has an RTE ID but no RTE room."
+                  << std::endl;
+      }
+    } else {
+      if (std::any_of(
+              map_info.definitions.begin(), map_info.definitions.end(),
+              [](const HumanMap& h_map) { return h_map.has_rte_room(); })) {
+        std::cout << "Map " << map_name << " has an RTE room but no RTE ID."
+                  << std::endl;
+      }
+    }
   }
 
   void ValidateRoom(const RoomIdentifier& room_identifier,
@@ -88,6 +116,10 @@ class Validator {
         std::cout << "    CONNECTION " << connection.ShortDebugString()
                   << std::endl;
       }
+
+      for (const std::string& map_name : room_info.map_rtes_referenced_by) {
+        std::cout << "    MAP RTE " << map_name << std::endl;
+      }
     } else if (room_info.definitions.size() > 1) {
       std::cout << "Room " << room_identifier.ShortDebugString()
                 << " was defined multiple times." << std::endl;
@@ -100,7 +132,8 @@ class Validator {
       return false;
     }
 
-    if (h_door.keyholders_size() > 0 || h_door.endings_size() > 0) {
+    if (h_door.keyholders_size() > 0 || h_door.white_ending() ||
+        h_door.complete_at() > 0) {
       return true;
     }
 
@@ -164,6 +197,20 @@ class Validator {
         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;
@@ -198,6 +245,33 @@ class Validator {
         std::cout << "Door " << door_identifier.ShortDebugString()
                   << " needs an explicit location name." << 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;
+        }
+      }
     }
   }
 
@@ -212,10 +286,57 @@ class Validator {
         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;
     }
+
+    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;
+        }
+      }
+    }
   }
 
   void ValidatePainting(const PaintingIdentifier& painting_identifier,
@@ -239,6 +360,22 @@ class Validator {
       std::cout << "Painting " << painting_identifier.ShortDebugString()
                 << " was defined multiple times." << 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;
+          }
+        }
+      }
+    }
   }
 
   void ValidatePanel(const PanelIdentifier& panel_identifier,
@@ -263,6 +400,10 @@ class Validator {
         std::cout << "    CONNECTION " << connection.ShortDebugString()
                   << std::endl;
       }
+
+      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()
                 << " was defined multiple times." << std::endl;
@@ -291,6 +432,27 @@ class Validator {
                   << "\" was defined multiple times." << std::endl;
       }
     }
+
+    if (!panel_info.has_id) {
+      std::cout << "Panel " << panel_identifier.ShortDebugString()
+                << " is missing an AP ID." << 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;
+          }
+        }
+      }
+    }
   }
 
   void ValidateKeyholder(const KeyholderIdentifier& keyholder_identifier,
@@ -304,10 +466,28 @@ class Validator {
         std::cout << "    DOOR " << door_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;
+        }
+      }
+    }
   }
 
   void ValidateLetter(const LetterIdentifier& letter_identifier,
@@ -315,7 +495,14 @@ class Validator {
     std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
                               (std::get<1>(letter_identifier) ? "2" : "1");
 
-    if (letter_info.defined_in.size() > 1) {
+    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;
 
@@ -323,6 +510,11 @@ class Validator {
         std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
       }
     }
+
+    if (!letter_info.has_id) {
+      std::cout << "Letter " << letter_name << " is missing an AP ID."
+                << std::endl;
+    }
   }
 
   void ValidateEnding(const std::string& ending_name,
@@ -331,10 +523,8 @@ class Validator {
       std::cout << "Ending " << ending_name
                 << " has no definition, but was referenced:" << std::endl;
 
-      for (const DoorIdentifier& door_identifier :
-           ending_info.doors_referenced_by) {
-        std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                  << 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
@@ -344,6 +534,11 @@ class Validator {
         std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
       }
     }
+
+    if (!ending_info.has_id) {
+      std::cout << "Ending " << ending_name << " is missing an AP ID."
+                << std::endl;
+    }
   }
 
   void ValidatePanelName(const std::string& panel_name,
@@ -360,6 +555,46 @@ class Validator {
     }
   }
 
+  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;
+    }
+  }
+
+  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_;
 };
 
@@ -1,4 +1,4 @@
-#ifndef TOOLS_VALIDATOR_VALIDATOR_H_
+#ifndef TOOLS_VALIDATOR_VALIDATOR_H
 #define TOOLS_VALIDATOR_VALIDATOR_H
 
 namespace com::fourisland::lingo2_archipelago {