3 files changed, 261 insertions, 11 deletions

@@ -79,7 +79,7 @@ uint64_t Container::FindOrAddPainting(
   auto it = room_container.find(painting_name);
   if (it == room_container.end()) {
     uint64_t new_id = all_objects_.paintings_size();
-    Painting* painting = all_objects_.add_paintings();
+    PaintingData* painting = all_objects_.add_paintings();
     painting->set_id(new_id);
     painting->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
     painting->set_name(painting_name);
@@ -205,6 +205,22 @@ uint64_t Container::FindLetterByName(std::string letter_name) {
   }
 }
 
+uint64_t Container::FindOrAddEnding(std::string ending_name) {
+  auto it = ending_id_by_name_.find(ending_name);
+  if (it == ending_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.endings_size();
+    Ending* ending = all_objects_.add_endings();
+    ending->set_id(new_id);
+    ending->set_name(ending_name);
+
+    ending_id_by_name_[ending_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 uint64_t Container::FindOrAddMastery(std::optional<std::string> map_name,
                                      std::optional<std::string> room_name,
                                      std::string mastery_name,
@@ -273,7 +289,7 @@ uint64_t Container::FindOrAddKeyholder(
   auto it = room_container.find(keyholder_name);
   if (it == room_container.end()) {
     uint64_t new_id = all_objects_.keyholders_size();
-    Keyholder* keyholder = all_objects_.add_keyholders();
+    KeyholderData* keyholder = all_objects_.add_keyholders();
     keyholder->set_id(new_id);
     keyholder->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
     keyholder->set_name(keyholder_name);
@@ -315,6 +331,40 @@ uint64_t Container::FindOrAddDoor(std::optional<std::string> map_name,
   }
 }
 
+uint64_t Container::FindOrAddProgressive(std::string prog_name) {
+  auto it = progressive_id_by_name_.find(prog_name);
+
+  if (it == progressive_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.progressives_size();
+    Progressive* progressive = all_objects_.add_progressives();
+    progressive->set_id(new_id);
+    progressive->set_name(prog_name);
+
+    progressive_id_by_name_[prog_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
+uint64_t Container::FindOrAddDoorGroup(std::string group_name) {
+  auto it = door_group_id_by_name_.find(group_name);
+
+  if (it == door_group_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.door_groups_size();
+    DoorGroup* door_group = all_objects_.add_door_groups();
+    door_group->set_id(new_id);
+    door_group->set_name(group_name);
+
+    door_group_id_by_name_[group_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 void Container::AddConnection(const Connection& connection) {
   *all_objects_.add_connections() = connection;
 }
@@ -40,6 +40,8 @@ class Container {
 
   uint64_t FindLetterByName(std::string letter_name);
 
+  uint64_t FindOrAddEnding(std::string ending_name);
+
   uint64_t FindOrAddMastery(std::optional<std::string> map_name,
                             std::optional<std::string> room_name,
                             std::string mastery_name,
@@ -58,6 +60,10 @@ class Container {
 
   void AddConnection(const Connection& connection);
 
+  uint64_t FindOrAddProgressive(std::string prog_name);
+
+  uint64_t FindOrAddDoorGroup(std::string group_name);
+
   AllObjects& all_objects() { return all_objects_; }
 
  private:
@@ -79,6 +85,9 @@ class Container {
       keyholder_id_by_map_room_keyholder_names_;
   std::map<std::string, std::map<std::string, uint64_t>>
       door_id_by_map_door_names_;
+  std::map<std::string, uint64_t> ending_id_by_name_;
+  std::map<std::string, uint64_t> progressive_id_by_name_;
+  std::map<std::string, uint64_t> door_group_id_by_name_;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -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,38 @@ 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);
+
+    map.set_type(metadata.type());
+
+    if (metadata.has_display_name()) {
+      map.set_display_name(metadata.display_name());
+    }
+
+    if (metadata.has_worldport_entrance()) {
+      map.set_worldport_entrance(container_.FindOrAddPort(
+          map_name, metadata.worldport_entrance().room(),
+          metadata.worldport_entrance().name(), std::nullopt, std::nullopt));
+    }
+  }
+
   void ProcessRooms(std::filesystem::path path,
                     const std::string& current_map_name) {
     for (auto const& dir_entry : std::filesystem::directory_iterator(path)) {
@@ -86,7 +115,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 +147,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 +190,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 +203,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());
@@ -206,7 +247,14 @@ class DataPacker {
     Port& port = *container_.all_objects().mutable_ports(port_id);
 
     port.set_path(h_port.path());
-    port.set_orientation(h_port.orientation());
+    port.set_display_name(h_port.display_name());
+
+    if (h_port.no_shuffle()) {
+      port.set_no_shuffle(h_port.no_shuffle());
+    } else {
+      *port.mutable_destination() = h_port.destination();
+      port.set_rotation(h_port.rotation());
+    }
 
     // Setting this explicitly because the Godot protobuf doesn't support
     // custom defaults.
@@ -257,14 +305,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)) {
@@ -296,8 +361,8 @@ class DataPacker {
         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()));
+        h_door.senders().begin(), h_door.senders().end(),
+        google::protobuf::RepeatedFieldBackInserter(door.mutable_senders()));
 
     for (const PaintingIdentifier& pi : h_door.move_paintings()) {
       std::optional<std::string> map_name =
@@ -346,6 +411,10 @@ class DataPacker {
           container_.FindOrAddDoor(map_name, di.name(), current_map_name));
     }
 
+    if (h_door.has_white_ending()) {
+      door.set_white_ending(h_door.white_ending());
+    }
+
     if (h_door.has_control_center_color()) {
       door.set_control_center_color(h_door.control_center_color());
     }
@@ -355,6 +424,22 @@ 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());
+    }
+
+    if (h_door.has_latch()) {
+      door.set_latch(h_door.latch());
+    }
+
+    if (h_door.has_legacy_location()) {
+      door.set_legacy_location(h_door.legacy_location());
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -406,6 +491,26 @@ 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());
+    }
+
+    if (human_connection.has_purple_ending()) {
+      f_connection.set_purple_ending(human_connection.purple_ending());
+      r_connection.set_purple_ending(human_connection.purple_ending());
+    }
+
+    if (human_connection.has_cyan_ending()) {
+      f_connection.set_cyan_ending(human_connection.cyan_ending());
+      r_connection.set_cyan_ending(human_connection.cyan_ending());
+    }
+
+    if (human_connection.has_vanilla_only()) {
+      f_connection.set_vanilla_only(human_connection.vanilla_only());
+      r_connection.set_vanilla_only(human_connection.vanilla_only());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -489,8 +594,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().mutable_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 +675,20 @@ 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);
+        }
+
+        for (const auto& [port_name, ap_id] : room.ports()) {
+          uint64_t port_id = container_.FindOrAddPort(
+              map_name, room_name, port_name, std::nullopt, std::nullopt);
+          container_.all_objects().mutable_ports(port_id)->set_ap_id(ap_id);
+        }
       }
     }
 
@@ -525,6 +701,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_;