1 files changed, 210 insertions, 43 deletions

@@ -2,6 +2,7 @@
 #include <google/protobuf/text_format.h>
 
 #include <cstdint>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <map>
@@ -40,6 +41,10 @@ class AssignIds {
     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);
 
@@ -54,50 +59,31 @@ class AssignIds {
     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;
+      if (map.has_rte()) {
+        UpdateNextId(map.rte());
       }
     }
 
-    for (const auto& [_, id] : id_mappings_.letters()) {
-      if (id > next_id_) {
-        next_id_ = id;
-      }
-    }
-
-    for (const auto& [_, id] : id_mappings_.endings()) {
-      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) {
-    WriteIdsAsYaml(id_mappings_, path.string());
+    WriteIdsAsYaml(output_, path.string());
   }
 
   void ProcessMaps(std::filesystem::path path) {
@@ -111,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)) {
@@ -130,18 +137,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());
     }
   }
 
@@ -156,6 +168,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)
@@ -167,23 +183,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)
@@ -195,27 +221,168 @@ 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())) {
-        auto& endings = *id_mappings_.mutable_endings();
         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) {
+      UpdateNextId(id);
+    }
+  }
+
+  void UpdateNextId(uint64_t id) {
+    if (id > next_id_) {
+      next_id_ = id;
+    }
+  }
+
   std::string mapdir_;
 
   uint64_t next_id_ = 1;
 
   IdMappings id_mappings_;
+  IdMappings output_;
 };
 
 }  // namespace