1 files changed, 153 insertions, 9 deletions

@@ -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,30 @@ 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);
+
+    if (metadata.has_display_name()) {
+      map.set_display_name(metadata.display_name());
+    }
+  }
+
   void ProcessRooms(std::filesystem::path path,
                     const std::string& current_map_name) {
     for (auto const& dir_entry : std::filesystem::directory_iterator(path)) {
@@ -86,7 +107,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 +139,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 +182,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 +195,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());
@@ -257,14 +290,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)) {
@@ -295,9 +345,6 @@ class DataPacker {
     std::copy(
         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()));
 
     for (const PaintingIdentifier& pi : h_door.move_paintings()) {
       std::optional<std::string> map_name =
@@ -346,6 +393,10 @@ class DataPacker {
           container_.FindOrAddDoor(map_name, di.name(), current_map_name));
     }
 
+    for (const std::string& ending_name : h_door.endings()) {
+      door.add_endings(container_.FindOrAddEnding(ending_name));
+    }
+
     if (h_door.has_control_center_color()) {
       door.set_control_center_color(h_door.control_center_color());
     }
@@ -355,6 +406,14 @@ 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());
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -406,6 +465,11 @@ 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());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -489,8 +553,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().set_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 +634,14 @@ 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);
+        }
       }
     }
 
@@ -525,6 +654,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_;