1 files changed, 199 insertions, 1 deletions

@@ -1,6 +1,7 @@
 #include <google/protobuf/message.h>
 #include <google/protobuf/text_format.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <filesystem>
 #include <fstream>
@@ -19,6 +20,8 @@ namespace {
 
 template <typename T>
 T ReadMessageFromFile(const std::string& path) {
+  std::cout << "Processing " << path << std::endl;
+
   std::ifstream file(path);
   std::stringstream buffer;
   buffer << file.rdbuf();
@@ -38,6 +41,7 @@ class DataPacker {
     std::filesystem::path datadir_path = mapdir_;
 
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
+    ProcessMaps(datadir_path);
 
     {
       std::ofstream outputfile(outputpath_);
@@ -51,6 +55,200 @@ class DataPacker {
   }
 
  private:
+  void ProcessMaps(std::filesystem::path path) {
+    std::filesystem::path maps_dir = path / "maps";
+    for (auto const& dir_entry :
+         std::filesystem::directory_iterator(maps_dir)) {
+      ProcessMap(dir_entry.path());
+    }
+  }
+
+  void ProcessMap(std::filesystem::path path) {
+    std::string map_name = path.filename();
+
+    ProcessConnectionsFile(path / "connections.txtpb", map_name);
+    ProcessDoorsFile(path / "doors.txtpb", map_name);
+    ProcessRooms(path / "rooms", map_name);
+  }
+
+  void ProcessRooms(std::filesystem::path path,
+                    const std::string& current_map_name) {
+    for (auto const& dir_entry : std::filesystem::directory_iterator(path)) {
+      auto room = ReadMessageFromFile<HumanRoom>(dir_entry.path().string());
+      ProcessRoom(room, current_map_name);
+    }
+  }
+
+  void ProcessRoom(const HumanRoom& h_room,
+                   const std::string& current_map_name) {
+    uint64_t room_id =
+        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());
+
+    for (const HumanPanel& h_panel : h_room.panels()) {
+      room.add_panels(ProcessPanel(h_panel, current_map_name, room.name()));
+    }
+
+    for (const HumanPainting& h_painting : h_room.paintings()) {
+      room.add_paintings(
+          ProcessPainting(h_painting, current_map_name, room.name()));
+    }
+
+    for (const HumanPort& h_port : h_room.ports()) {
+      room.add_ports(ProcessPort(h_port, current_map_name, room.name()));
+    }
+
+    std::copy(
+        h_room.letters().begin(), h_room.letters().end(),
+        google::protobuf::RepeatedFieldBackInserter(room.mutable_letters()));
+  }
+
+  uint64_t ProcessPanel(const HumanPanel& h_panel,
+                        const std::string& current_map_name,
+                        const std::string& current_room_name) {
+    uint64_t panel_id =
+        container_.FindOrAddPanel(current_map_name, current_room_name,
+                                  h_panel.name(), std::nullopt, std::nullopt);
+    Panel& panel = *container_.all_objects().mutable_panels(panel_id);
+
+    panel.set_path(h_panel.path());
+    panel.set_clue(h_panel.clue());
+    panel.set_answer(h_panel.answer());
+
+    std::copy(
+        h_panel.symbols().begin(), h_panel.symbols().end(),
+        google::protobuf::RepeatedFieldBackInserter(panel.mutable_symbols()));
+    std::copy(
+        h_panel.proxies().begin(), h_panel.proxies().end(),
+        google::protobuf::RepeatedFieldBackInserter(panel.mutable_proxies()));
+
+    if (h_panel.has_required_door()) {
+      std::optional<std::string> map_name =
+          h_panel.required_door().has_map()
+              ? std::optional<std::string>(h_panel.required_door().map())
+              : std::nullopt;
+      panel.set_required_door(container_.FindOrAddDoor(
+          map_name, h_panel.required_door().name(), current_map_name));
+    }
+
+    return panel_id;
+  }
+
+  uint64_t ProcessPainting(const HumanPainting& h_painting,
+                           const std::string& current_map_name,
+                           const std::string& current_room_name) {
+    uint64_t painting_id = container_.FindOrAddPainting(
+        current_map_name, current_room_name, h_painting.name(), std::nullopt,
+        std::nullopt);
+    Painting& painting =
+        *container_.all_objects().mutable_paintings(painting_id);
+
+    painting.set_path(h_painting.path());
+    painting.set_display_name(h_painting.display_name());
+    painting.set_orientation(h_painting.orientation());
+
+    if (h_painting.has_flipped()) {
+      painting.set_flipped(h_painting.flipped());
+    }
+
+    if (h_painting.has_move()) {
+      painting.set_move(h_painting.move());
+    }
+
+    if (h_painting.has_enter_only()) {
+      painting.set_enter_only(h_painting.enter_only());
+    }
+
+    if (h_painting.has_required_door()) {
+      std::optional<std::string> map_name =
+          h_painting.required_door().has_map()
+              ? std::optional<std::string>(h_painting.required_door().map())
+              : std::nullopt;
+      painting.set_required_door(container_.FindOrAddDoor(
+          map_name, h_painting.required_door().name(), current_map_name));
+    }
+
+    return painting_id;
+  }
+
+  uint64_t ProcessPort(const HumanPort& h_port,
+                       const std::string& current_map_name,
+                       const std::string& current_room_name) {
+    uint64_t port_id =
+        container_.FindOrAddPort(current_map_name, current_room_name,
+                                 h_port.name(), std::nullopt, std::nullopt);
+    Port& port = *container_.all_objects().mutable_ports(port_id);
+
+    port.set_path(h_port.path());
+    port.set_orientation(h_port.orientation());
+
+    if (h_port.has_required_door()) {
+      std::optional<std::string> map_name =
+          h_port.required_door().has_map()
+              ? std::optional<std::string>(h_port.required_door().map())
+              : std::nullopt;
+      port.set_required_door(container_.FindOrAddDoor(
+          map_name, h_port.required_door().name(), current_map_name));
+    }
+
+    return port_id;
+  }
+
+  void ProcessDoorsFile(std::filesystem::path path,
+                        const std::string& current_map_name) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto doors = ReadMessageFromFile<HumanDoors>(path.string());
+
+    for (const HumanDoor& door : doors.doors()) {
+      ProcessDoor(door, current_map_name);
+    }
+  }
+
+  void ProcessDoor(const HumanDoor& h_door,
+                   const std::string& current_map_name) {
+    uint64_t door_id =
+        container_.FindOrAddDoor(current_map_name, h_door.name(), std::nullopt);
+    Door& door = *container_.all_objects().mutable_doors(door_id);
+
+    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 =
+          pi.has_map() ? std::optional<std::string>(pi.map()) : std::nullopt;
+      door.add_move_paintings(container_.FindOrAddPainting(
+          map_name, pi.room(), pi.name(), current_map_name, std::nullopt));
+    }
+
+    for (const PanelIdentifier& pi : h_door.panels()) {
+      ProxyIdentifier* proxy = door.add_panels();
+
+      std::optional<std::string> map_name =
+          pi.has_map() ? std::optional<std::string>(pi.map()) : std::nullopt;
+      proxy->set_panel(container_.FindOrAddPanel(
+          map_name, pi.room(), pi.name(), current_map_name, std::nullopt));
+
+      if (pi.has_answer()) {
+        proxy->set_answer(pi.answer());
+      }
+    }
+
+    if (h_door.has_control_center_color()) {
+      door.set_control_center_color(h_door.control_center_color());
+    }
+
+    door.set_type(h_door.type());
+  }
+
   void ProcessConnectionsFile(std::filesystem::path path,
                               std::optional<std::string> current_map_name) {
     if (!std::filesystem::exists(path)) {
@@ -80,7 +278,7 @@ class DataPacker {
     r_connection.set_to_room(f_connection.from_room());
 
     if (human_connection.has_to_room()) {
-      r_connection.set_to_room(container_.FindOrAddRoom(
+      r_connection.set_from_room(container_.FindOrAddRoom(
           std::nullopt, human_connection.to_room(), current_map_name));
     } else if (human_connection.has_to()) {
       ProcessSingleConnection(human_connection.to(), current_map_name,