1 files changed, 79 insertions, 4 deletions

@@ -88,9 +88,28 @@ class DataPacker {
     uint64_t map_id = container_.FindOrAddMap(map_name);
     Map& map = *container_.all_objects().mutable_maps(map_id);
 
+    map.set_type(metadata.type());
+    map.set_daedalus_only_mode(metadata.daedalus_only_mode());
+
     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));
+    }
+
+    if (metadata.has_rte_room()) {
+      map.set_rte_room(container_.FindOrAddRoom(map_name, metadata.rte_room(),
+                                                std::nullopt));
+    }
+
+    if (metadata.has_rte_trigger_pos()) {
+      *map.mutable_rte_trigger_pos() = metadata.rte_trigger_pos();
+      *map.mutable_rte_trigger_scale() = metadata.rte_trigger_scale();
+    }
   }
 
   void ProcessRooms(std::filesystem::path path,
@@ -113,6 +132,10 @@ class DataPacker {
       room.set_panel_display_name(h_room.panel_display_name());
     }
 
+    if (h_room.has_daedalus_only_allow()) {
+      room.set_daedalus_only_allow(h_room.daedalus_only_allow());
+    }
+
     for (const HumanPanel& h_panel : h_room.panels()) {
       room.add_panels(ProcessPanel(h_panel, current_map_name, room.name()));
     }
@@ -186,6 +209,10 @@ class DataPacker {
       panel.set_display_name(h_panel.display_name());
     }
 
+    if (h_panel.has_exclude_from_panelsanity()) {
+      panel.set_exclude_from_panelsanity(h_panel.exclude_from_panelsanity());
+    }
+
     return panel_id;
   }
 
@@ -239,7 +266,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.
@@ -396,8 +430,8 @@ 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_white_ending()) {
+      door.set_white_ending(h_door.white_ending());
     }
 
     if (h_door.has_control_center_color()) {
@@ -417,6 +451,22 @@ class DataPacker {
     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());
+    }
+
+    if (h_door.has_daedalus_only_allow()) {
+      door.set_daedalus_only_allow(h_door.daedalus_only_allow());
+    }
+
+    if (h_door.has_daedalus_only_always_item()) {
+      door.set_daedalus_only_always_item(h_door.daedalus_only_always_item());
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -483,6 +533,16 @@ class DataPacker {
       r_connection.set_cyan_ending(human_connection.cyan_ending());
     }
 
+    if (human_connection.has_mint_ending()) {
+      f_connection.set_mint_ending(human_connection.mint_ending());
+      r_connection.set_mint_ending(human_connection.mint_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);
@@ -612,6 +672,10 @@ class DataPacker {
           container_.FindOrAddDoor(di.map(), di.name(), std::nullopt);
       group.add_doors(door_id);
     }
+
+    if (h_group.has_daedalus_only_always_item()) {
+      group.set_daedalus_only_always_item(h_group.daedalus_only_always_item());
+    }
   }
 
   void ProcessGlobalMetadataFile(std::filesystem::path path) {
@@ -620,7 +684,7 @@ class DataPacker {
     }
 
     auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
-    container_.all_objects().set_version(h_metadata.version());
+    *container_.all_objects().mutable_version() = h_metadata.version();
   }
 
   void ProcessIdsFile(std::filesystem::path path) {
@@ -655,6 +719,17 @@ 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);
+        }
+      }
+
+      if (map.has_rte()) {
+        uint64_t map_id = container_.FindOrAddMap(map_name);
+        container_.all_objects().mutable_maps(map_id)->set_rte_ap_id(map.rte());
       }
     }