1 files changed, 164 insertions, 47 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,33 @@ 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());
       }
     }
 
-    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 +90,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);
@@ -129,14 +115,18 @@ class AssignIds {
       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 +141,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 +156,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 +194,133 @@ 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());
+      }
+    }
+  }
+
+  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