7 files changed, 94 insertions, 4 deletions

@@ -67,6 +67,10 @@ class AssignIds {
         UpdateNextId(room.keyholders());
         UpdateNextId(room.ports());
       }
+
+      if (map.has_rte()) {
+        UpdateNextId(map.rte());
+      }
     }
 
     UpdateNextId(id_mappings_.special());
@@ -93,10 +97,31 @@ class AssignIds {
   void ProcessMap(std::filesystem::path path) {
     std::string map_name = path.filename().string();
 
+    ProcessMapMetadata(path / "metadata.txtpb", map_name);
     ProcessDoorsFile(path / "doors.txtpb", map_name);
     ProcessRooms(path / "rooms", map_name);
   }
 
+  void ProcessMapMetadata(std::filesystem::path path,
+                          const std::string& current_map_name) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto metadata = ReadMessageFromFile<HumanMap>(path.string());
+    auto& maps = *output_.mutable_maps();
+
+    if (metadata.has_rte_room()) {
+      if (!id_mappings_.maps().contains(current_map_name) ||
+          !id_mappings_.maps().at(current_map_name).has_rte()) {
+        maps[current_map_name].set_rte(next_id_++);
+      } else {
+        maps[current_map_name].set_rte(
+            id_mappings_.maps().at(current_map_name).rte());
+      }
+    }
+  }
+
   void ProcessDoorsFile(std::filesystem::path path,
                         const std::string& current_map_name) {
     if (!std::filesystem::exists(path)) {
@@ -342,9 +367,13 @@ class AssignIds {
  private:
   void UpdateNextId(const google::protobuf::Map<std::string, uint64_t>& ids) {
     for (const auto& [_, id] : ids) {
-      if (id > next_id_) {
-        next_id_ = id;
-      }
+      UpdateNextId(id);
+    }
+  }
+
+  void UpdateNextId(uint64_t id) {
+    if (id > next_id_) {
+      next_id_ = id;
     }
   }
 
@@ -100,6 +100,11 @@ class DataPacker {
           map_name, metadata.worldport_entrance().room(),
           metadata.worldport_entrance().name(), std::nullopt, std::nullopt));
     }
+
+    if (metadata.has_rte_room()) {
+      map.set_rte_room(container_.FindOrAddRoom(map_name, metadata.rte_room(),
+                                                std::nullopt));
+    }
   }
 
   void ProcessRooms(std::filesystem::path path,
@@ -711,6 +716,11 @@ class DataPacker {
           container_.all_objects().mutable_ports(port_id)->set_ap_id(ap_id);
         }
       }
+
+      if (map.has_rte()) {
+        uint64_t map_id = container_.FindOrAddMap(map_name);
+        container_.all_objects().mutable_maps(map_id)->set_rte_ap_id(map.rte());
+      }
     }
 
     auto& specials = *container_.all_objects().mutable_special_ids();
@@ -80,6 +80,10 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
               door_it.second.as<uint64_t>();
         }
       }
+
+      if (map_it.second["rte"]) {
+        map_ids.set_rte(map_it.second["rte"].as<uint64_t>());
+      }
     }
   }
 
@@ -168,6 +172,10 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
           map_node["doors"][door_name] = door_id;
         });
 
+    if (map_ids.has_rte()) {
+      map_node["rte"] = map_ids.rte();
+    }
+
     result["maps"][map_name] = std::move(map_node);
   });
 
@@ -74,6 +74,8 @@ 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++;
     }
@@ -92,6 +94,15 @@ class HumanProcessor {
         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,
@@ -617,6 +628,11 @@ class HumanProcessor {
           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()) {
@@ -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;
   }
 
@@ -28,6 +28,9 @@ 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;
 };
 
@@ -37,6 +40,7 @@ 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 {
@@ -1,5 +1,6 @@
 #include "validator.h"
 
+#include <algorithm>
 #include <iostream>
 
 #include "proto/human.pb.h"
@@ -74,6 +75,22 @@ class Validator {
       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,
@@ -99,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;