1 files changed, 107 insertions, 15 deletions

@@ -42,6 +42,7 @@ struct GameData {
   std::vector<Room> rooms_;
   std::vector<Door> doors_;
   std::vector<Panel> panels_;
+  std::vector<PanelDoor> panel_doors_;
   std::vector<MapArea> map_areas_;
   std::vector<SubwayItem> subway_items_;
   std::vector<PaintingExit> paintings_;
@@ -49,6 +50,7 @@ struct GameData {
   std::map<std::string, int> room_by_id_;
   std::map<std::string, int> door_by_id_;
   std::map<std::string, int> panel_by_id_;
+  std::map<std::string, int> panel_doors_by_id_;
   std::map<std::string, int> area_by_id_;
   std::map<std::string, int> painting_by_id_;
 
@@ -109,6 +111,7 @@ struct GameData {
         auto process_single_entrance =
             [this, room_id, from_room_id](const YAML::Node &option) {
               Exit exit_obj;
+              exit_obj.source_room = from_room_id; 
               exit_obj.destination_room = room_id;
 
               if (option["door"]) {
@@ -143,7 +146,7 @@ struct GameData {
         switch (entrance_it.second.Type()) {
           case YAML::NodeType::Scalar: {
             // This is just "true".
-            rooms_[from_room_id].exits.push_back({.destination_room = room_id});
+            rooms_[from_room_id].exits.push_back({.source_room = from_room_id, .destination_room = room_id});
             break;
           }
           case YAML::NodeType::Map: {
@@ -424,6 +427,55 @@ struct GameData {
         }
       }
 
+      if (room_it.second["panel_doors"]) {
+        for (const auto &panel_door_it : room_it.second["panel_doors"]) {
+          std::string panel_door_name = panel_door_it.first.as<std::string>();
+          int panel_door_id =
+              AddOrGetPanelDoor(rooms_[room_id].name, panel_door_name);
+
+          for (const auto &panel_node : panel_door_it.second["panels"]) {
+            int panel_id = -1;
+
+            if (panel_node.IsScalar()) {
+              panel_id = AddOrGetPanel(rooms_[room_id].name,
+                                       panel_node.as<std::string>());
+            } else {
+              panel_id = AddOrGetPanel(panel_node["room"].as<std::string>(),
+                                       panel_node["panel"].as<std::string>());
+            }
+
+            Panel &panel = panels_[panel_id];
+            panel.panel_door = panel_door_id;
+          }
+
+          if (ids_config["panel_doors"] &&
+              ids_config["panel_doors"][rooms_[room_id].name] &&
+              ids_config["panel_doors"][rooms_[room_id].name]
+                        [panel_door_name]) {
+            panel_doors_[panel_door_id].ap_item_id =
+                ids_config["panel_doors"][rooms_[room_id].name][panel_door_name]
+                    .as<int>();
+          } else {
+            wxLogError("Missing AP item ID for panel door %s - %s",
+                       rooms_[room_id].name, panel_door_name);
+          }
+
+          if (panel_door_it.second["panel_group"]) {
+            std::string panel_group =
+                panel_door_it.second["panel_group"].as<std::string>();
+
+            if (ids_config["panel_groups"] &&
+                ids_config["panel_groups"][panel_group]) {
+              panel_doors_[panel_door_id].group_ap_item_id =
+                  ids_config["panel_groups"][panel_group].as<int>();
+            } else {
+              wxLogError("Missing AP item ID for panel door group %s",
+                         panel_group);
+            }
+          }
+        }
+      }
+
       if (room_it.second["paintings"]) {
         for (const auto &painting : room_it.second["paintings"]) {
           std::string internal_id = painting["id"].as<std::string>();
@@ -477,23 +529,47 @@ struct GameData {
                                    progressive_item_name));
           }
 
-          int index = 1;
-          for (const auto &stage : progression_it.second) {
-            int door_id = -1;
+          if (progression_it.second["doors"]) {
+            int index = 1;
+            for (const auto &stage : progression_it.second["doors"]) {
+              int door_id = -1;
 
-            if (stage.IsScalar()) {
-              door_id =
-                  AddOrGetDoor(rooms_[room_id].name, stage.as<std::string>());
-            } else {
-              door_id = AddOrGetDoor(stage["room"].as<std::string>(),
-                                     stage["door"].as<std::string>());
+              if (stage.IsScalar()) {
+                door_id =
+                    AddOrGetDoor(rooms_[room_id].name, stage.as<std::string>());
+              } else {
+                door_id = AddOrGetDoor(stage["room"].as<std::string>(),
+                                       stage["door"].as<std::string>());
+              }
+
+              doors_[door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
             }
+          }
 
-            doors_[door_id].progressives.push_back(
-                {.item_name = progressive_item_name,
-                 .ap_item_id = progressive_item_id,
-                 .quantity = index});
-            index++;
+          if (progression_it.second["panel_doors"]) {
+            int index = 1;
+            for (const auto &stage : progression_it.second["panel_doors"]) {
+              int panel_door_id = -1;
+
+              if (stage.IsScalar()) {
+                panel_door_id = AddOrGetPanelDoor(rooms_[room_id].name,
+                                                  stage.as<std::string>());
+              } else {
+                panel_door_id =
+                    AddOrGetPanelDoor(stage["room"].as<std::string>(),
+                                      stage["panel_door"].as<std::string>());
+              }
+
+              panel_doors_[panel_door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
+            }
           }
         }
       }
@@ -752,6 +828,18 @@ struct GameData {
     return panel_by_id_[full_name];
   }
 
+  int AddOrGetPanelDoor(std::string room, std::string panel) {
+    std::string full_name = room + " - " + panel;
+
+    if (!panel_doors_by_id_.count(full_name)) {
+      int panel_door_id = panel_doors_.size();
+      panel_doors_by_id_[full_name] = panel_door_id;
+      panel_doors_.push_back({});
+    }
+
+    return panel_doors_by_id_[full_name];
+  }
+
   int AddOrGetArea(std::string area) {
     if (!area_by_id_.count(area)) {
       if (loaded_area_data_) {
@@ -802,6 +890,10 @@ const std::vector<Door> &GD_GetDoors() { return GetState().doors_; }
 
 const Door &GD_GetDoor(int door_id) { return GetState().doors_.at(door_id); }
 
+const PanelDoor &GD_GetPanelDoor(int panel_door_id) {
+  return GetState().panel_doors_.at(panel_door_id);
+}
+
 int GD_GetDoorByName(const std::string &name) {
   return GetState().door_by_id_.at(name);
 }