6 files changed, 80 insertions, 5 deletions

@@ -65,6 +65,7 @@ class AssignIds {
         UpdateNextId(room.panels());
         UpdateNextId(room.masteries());
         UpdateNextId(room.keyholders());
+        UpdateNextId(room.ports());
       }
     }
 
@@ -245,6 +246,37 @@ class AssignIds {
                                              .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() {
@@ -679,6 +679,12 @@ class DataPacker {
               .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);
+        }
       }
     }
 
@@ -64,6 +64,13 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
                   keyholder_it.second.as<uint64_t>();
             }
           }
+
+          if (room_it.second["ports"]) {
+            for (const auto& port_it : room_it.second["ports"]) {
+              (*room_ids.mutable_ports())[port_it.first.as<std::string>()] =
+                  port_it.second.as<uint64_t>();
+            }
+          }
         }
       }
 
@@ -146,6 +153,12 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
                                    keyholder_id;
                              });
 
+          OperateOnSortedMap(
+              room_ids.ports(),
+              [&room_node](const std::string& port_name, uint64_t port_id) {
+                room_node["ports"][port_name] = port_id;
+              });
+
           map_node["rooms"][room_name] = std::move(room_node);
         });
 
@@ -570,12 +570,14 @@ class HumanProcessor {
     auto ids = ReadIdsFromYaml(path.string());
 
     DoorIdentifier di;
-    PanelIdentifier pi;
+    PanelIdentifier pai;
+    PortIdentifier poi;
     KeyholderIdentifier ki;
 
     for (const auto& [map_name, map] : ids.maps()) {
       di.set_map(map_name);
-      pi.set_map(map_name);
+      pai.set_map(map_name);
+      poi.set_map(map_name);
       ki.set_map(map_name);
 
       for (const auto& [door_name, ap_id] : map.doors()) {
@@ -586,13 +588,14 @@ class HumanProcessor {
       }
 
       for (const auto& [room_name, room] : map.rooms()) {
-        pi.set_room(room_name);
+        pai.set_room(room_name);
+        poi.set_room(room_name);
         ki.set_room(room_name);
 
         for (const auto& [panel_name, ap_id] : room.panels()) {
-          pi.set_name(panel_name);
+          pai.set_name(panel_name);
 
-          PanelInfo& panel_info = info_.panels[pi];
+          PanelInfo& panel_info = info_.panels[pai];
           panel_info.has_id = true;
         }
 
@@ -606,6 +609,13 @@ class HumanProcessor {
           KeyholderInfo& keyholder_info = info_.keyholders[ki];
           keyholder_info.has_id = true;
         }
+
+        for (const auto& [port_name, ap_id] : room.ports()) {
+          poi.set_name(port_name);
+
+          PortInfo& port_info = info_.ports[poi];
+          port_info.has_id = true;
+        }
       }
     }
 
@@ -56,6 +56,7 @@ struct DoorInfo {
 
 struct PortInfo {
   std::vector<HumanPort> definitions;
+  bool has_id = false;
 
   std::vector<HumanConnection> connections_referenced_by;
   std::vector<HumanConnection> target_connections_referenced_by;
@@ -269,6 +269,10 @@ class Validator {
       for (const std::string& map_name : port_info.map_worldport_entrances) {
         std::cout << "    MAP (worldport_entrance) " << map_name << std::endl;
       }
+
+      if (port_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
     } else if (port_info.definitions.size() > 1) {
       std::cout << "Port " << port_identifier.ShortDebugString()
                 << " was defined multiple times." << std::endl;
@@ -301,6 +305,15 @@ class Validator {
           std::cout << "Port " << port_identifier.ShortDebugString()
                     << " is shuffleable and missing a rotation." << std::endl;
         }
+        if (!port_info.has_id) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        }
+      } else {
+        if (port_info.has_id) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
       }
     }
   }