1 files changed, 143 insertions, 70 deletions

@@ -12,32 +12,6 @@
 
 namespace {
 
-LingoColor GetColorForString(const std::string &str) {
-  if (str == "black") {
-    return LingoColor::kBlack;
-  } else if (str == "red") {
-    return LingoColor::kRed;
-  } else if (str == "blue") {
-    return LingoColor::kBlue;
-  } else if (str == "yellow") {
-    return LingoColor::kYellow;
-  } else if (str == "orange") {
-    return LingoColor::kOrange;
-  } else if (str == "green") {
-    return LingoColor::kGreen;
-  } else if (str == "gray") {
-    return LingoColor::kGray;
-  } else if (str == "brown") {
-    return LingoColor::kBrown;
-  } else if (str == "purple") {
-    return LingoColor::kPurple;
-  } else {
-    TrackerLog(fmt::format("Invalid color: {}", str));
-
-    return LingoColor::kNone;
-  }
-}
-
 struct GameData {
   std::vector<Room> rooms_;
   std::vector<Door> doors_;
@@ -55,10 +29,10 @@ struct GameData {
   std::map<std::string, int> painting_by_id_;
 
   std::vector<int> door_definition_order_;
-  std::vector<int> room_definition_order_;
 
   std::map<std::string, int> room_by_painting_;
   std::map<int, int> room_by_sunwarp_;
+  std::map<int, int> panel_by_solve_index_;
 
   std::vector<int> achievement_panels_;
 
@@ -69,6 +43,8 @@ struct GameData {
   std::map<std::string, int> subway_item_by_painting_;
   std::map<SubwaySunwarp, int> subway_item_by_sunwarp_;
 
+  std::map<int, std::string> item_by_ap_id_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -84,7 +60,7 @@ struct GameData {
           ids_config["special_items"][color_name]) {
         std::string input_name = color_name;
         input_name[0] = std::tolower(input_name[0]);
-        ap_id_by_color_[GetColorForString(input_name)] =
+        ap_id_by_color_[GetLingoColorForString(input_name)] =
             ids_config["special_items"][color_name].as<int>();
       } else {
         TrackerLog(fmt::format("Missing AP item ID for color {}", color_name));
@@ -101,11 +77,20 @@ struct GameData {
     init_color_id("Brown");
     init_color_id("Gray");
 
+    if (ids_config["special_items"]) {
+      for (const auto& special_item_it : ids_config["special_items"])
+      {
+        item_by_ap_id_[special_item_it.second.as<int>()] =
+            special_item_it.first.as<std::string>();
+      }
+    }
+
     rooms_.reserve(lingo_config.size() * 2);
 
+    std::vector<int> panel_location_ids;
+
     for (const auto &room_it : lingo_config) {
       int room_id = AddOrGetRoom(room_it.first.as<std::string>());
-      room_definition_order_.push_back(room_id);
 
       for (const auto &entrance_it : room_it.second["entrances"]) {
         int from_room_id = AddOrGetRoom(entrance_it.first.as<std::string>());
@@ -181,12 +166,12 @@ struct GameData {
 
           if (panel_it.second["colors"]) {
             if (panel_it.second["colors"].IsScalar()) {
-              panels_[panel_id].colors.push_back(GetColorForString(
+              panels_[panel_id].colors.push_back(GetLingoColorForString(
                   panel_it.second["colors"].as<std::string>()));
             } else {
               for (const auto &color_node : panel_it.second["colors"]) {
                 panels_[panel_id].colors.push_back(
-                    GetColorForString(color_node.as<std::string>()));
+                    GetLingoColorForString(color_node.as<std::string>()));
               }
             }
           }
@@ -292,10 +277,11 @@ struct GameData {
               ids_config["panels"][rooms_[room_id].name] &&
               ids_config["panels"][rooms_[room_id].name]
                         [panels_[panel_id].name]) {
-            panels_[panel_id].ap_location_id =
-                ids_config["panels"][rooms_[room_id].name]
-                          [panels_[panel_id].name]
-                              .as<int>();
+            int location_id = ids_config["panels"][rooms_[room_id].name]
+                                        [panels_[panel_id].name]
+                                            .as<int>();
+            panels_[panel_id].ap_location_id = location_id;
+            panel_location_ids.push_back(location_id);
           } else {
             TrackerLog(fmt::format("Missing AP location ID for panel {} - {}",
                                    rooms_[room_id].name,
@@ -361,6 +347,9 @@ struct GameData {
                   ids_config["doors"][rooms_[room_id].name]
                             [doors_[door_id].name]["item"]
                                 .as<int>();
+
+              item_by_ap_id_[doors_[door_id].ap_item_id] =
+                  doors_[door_id].item_name;
             } else {
               TrackerLog(fmt::format("Missing AP item ID for door {} - {}",
                                      rooms_[room_id].name,
@@ -377,6 +366,9 @@ struct GameData {
               doors_[door_id].group_ap_item_id =
                   ids_config["door_groups"][doors_[door_id].group_name]
                       .as<int>();
+
+              item_by_ap_id_[doors_[door_id].group_ap_item_id] =
+                  doors_[door_id].group_name;
             } else {
               TrackerLog(fmt::format("Missing AP item ID for door group {}",
                                      doors_[door_id].group_name));
@@ -440,21 +432,50 @@ struct GameData {
           int panel_door_id =
               AddOrGetPanelDoor(rooms_[room_id].name, panel_door_name);
 
+          std::map<std::string, std::vector<std::string>> panel_per_room;
+          int num_panels = 0;
           for (const auto &panel_node : panel_door_it.second["panels"]) {
+            num_panels++;
+
             int panel_id = -1;
 
             if (panel_node.IsScalar()) {
               panel_id = AddOrGetPanel(rooms_[room_id].name,
                                        panel_node.as<std::string>());
+              
+              panel_per_room[rooms_[room_id].name].push_back(
+                  panel_node.as<std::string>());
             } else {
               panel_id = AddOrGetPanel(panel_node["room"].as<std::string>(),
                                        panel_node["panel"].as<std::string>());
+
+              panel_per_room[panel_node["room"].as<std::string>()].push_back(
+                  panel_node["panel"].as<std::string>());
             }
 
             Panel &panel = panels_[panel_id];
             panel.panel_door = panel_door_id;
           }
 
+          if (panel_door_it.second["item_name"]) {
+            panel_doors_[panel_door_id].item_name =
+                panel_door_it.second["item_name"].as<std::string>();
+          } else {
+            std::vector<std::string> room_strs;
+            for (const auto &[room_str, panels_str] : panel_per_room) {
+              room_strs.push_back(fmt::format(
+                  "{} - {}", room_str, hatkirby::implode(panels_str, ", ")));
+            }
+
+            if (num_panels == 1) {
+              panel_doors_[panel_door_id].item_name =
+                  fmt::format("{} (Panel)", room_strs[0]);
+            } else {
+              panel_doors_[panel_door_id].item_name = fmt::format(
+                  "{} (Panels)", hatkirby::implode(room_strs, " and "));
+            }
+          }
+
           if (ids_config["panel_doors"] &&
               ids_config["panel_doors"][rooms_[room_id].name] &&
               ids_config["panel_doors"][rooms_[room_id].name]
@@ -462,6 +483,9 @@ struct GameData {
             panel_doors_[panel_door_id].ap_item_id =
                 ids_config["panel_doors"][rooms_[room_id].name][panel_door_name]
                     .as<int>();
+
+            item_by_ap_id_[panel_doors_[panel_door_id].ap_item_id] =
+                panel_doors_[panel_door_id].item_name;
           } else {
             TrackerLog(fmt::format("Missing AP item ID for panel door {} - {}",
                                    rooms_[room_id].name, panel_door_name));
@@ -475,6 +499,9 @@ struct GameData {
                 ids_config["panel_groups"][panel_group]) {
               panel_doors_[panel_door_id].group_ap_item_id =
                   ids_config["panel_groups"][panel_group].as<int>();
+
+              item_by_ap_id_[panel_doors_[panel_door_id].group_ap_item_id] =
+                  panel_group;
             } else {
               TrackerLog(fmt::format(
                   "Missing AP item ID for panel door group {}", panel_group));
@@ -490,6 +517,13 @@ struct GameData {
           PaintingExit &painting_exit = paintings_[painting_id];
           painting_exit.room = room_id;
 
+          if (painting["display_name"]) {
+            painting_exit.display_name =
+                painting["display_name"].as<std::string>();
+          } else {
+            painting_exit.display_name = painting_exit.internal_id;
+          }
+
           if ((!painting["exit_only"] || !painting["exit_only"].as<bool>()) &&
               (!painting["disable"] || !painting["disable"].as<bool>())) {
             painting_exit.entrance = true;
@@ -531,6 +565,8 @@ struct GameData {
               ids_config["progression"][progressive_item_name]) {
             progressive_item_id =
                 ids_config["progression"][progressive_item_name].as<int>();
+
+            item_by_ap_id_[progressive_item_id] = progressive_item_name;
           } else {
             TrackerLog(fmt::format("Missing AP item ID for progressive item {}",
                                    progressive_item_name));
@@ -582,6 +618,21 @@ struct GameData {
       }
     }
 
+    // Determine the panel solve indices from the sorted location IDs.
+    std::sort(panel_location_ids.begin(), panel_location_ids.end());
+
+    std::map<int, int> solve_index_by_location_id;
+    for (int i = 0; i < panel_location_ids.size(); i++) {
+      solve_index_by_location_id[panel_location_ids[i]] = i;
+    }
+
+    for (Panel &panel : panels_) {
+      if (panel.ap_location_id != -1) {
+        panel.solve_index = solve_index_by_location_id[panel.ap_location_id];
+        panel_by_solve_index_[panel.solve_index] = panel.id;
+      }
+    }
+
     map_areas_.reserve(areas_config.size());
 
     std::map<std::string, int> fold_areas;
@@ -602,7 +653,7 @@ struct GameData {
     // Only locations for the panels are kept here.
     std::map<std::string, std::tuple<int, int>> locations_by_name;
 
-    for (const Panel &panel : panels_) {
+    for (Panel &panel : panels_) {
       int room_id = panel.room;
       std::string room_name = rooms_[room_id].name;
 
@@ -618,6 +669,8 @@ struct GameData {
           area_name = location_name.substr(0, divider_pos);
           section_name = location_name.substr(divider_pos + 3);
         }
+      } else {
+        panel.location_name = location_name;
       }
 
       if (fold_areas.count(area_name)) {
@@ -716,7 +769,8 @@ struct GameData {
         MapArea &map_area = map_areas_[area_id];
 
         for (int painting_id : room.paintings) {
-          const PaintingExit &painting_obj = paintings_.at(painting_id);
+          PaintingExit &painting_obj = paintings_.at(painting_id);
+          painting_obj.map_area = area_id;
           if (painting_obj.entrance) {
             map_area.paintings.push_back(painting_id);
           }
@@ -724,31 +778,6 @@ struct GameData {
       }
     }
 
-    // As a workaround for a generator bug in 0.5.1, we are going to remove the
-    // panel door requirement on panels that are defined earlier in the file than
-    // the panel door is. This results in logic that matches the generator, even
-    // if it is not true to how the game should work. This will be reverted once
-    // the logic bug is fixed and released.
-    // See: https://github.com/ArchipelagoMW/Archipelago/pull/4342
-    for (Panel& panel : panels_) {
-      if (panel.panel_door == -1) {
-        continue;
-      }
-      const PanelDoor &panel_door = panel_doors_[panel.panel_door];
-      for (int room_id : room_definition_order_) {
-        if (room_id == panel_door.room) {
-          // The panel door was defined first (or at the same time as the panel),
-          // so we're good.
-          break;
-        } else if (room_id == panel.room) {
-          // The panel was defined first, so we have to pretend the panel door is
-          // not required for this panel.
-          panel.panel_door = -1;
-          break;
-        }
-      }
-    }
-
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
       TrackerLog(fmt::format("Area data not found for: {}", area));
@@ -768,13 +797,10 @@ struct GameData {
                                         subway_it["door"].as<std::string>());
       }
 
-      if (subway_it["paintings"]) {
-        for (const auto &painting_it : subway_it["paintings"]) {
-          std::string painting_id = painting_it.as<std::string>();
-
-          subway_item.paintings.push_back(painting_id);
-          subway_item_by_painting_[painting_id] = subway_item.id;
-        }
+      if (subway_it["painting"]) {
+        std::string painting_id = subway_it["painting"].as<std::string>();
+        subway_item.painting = painting_id;
+        subway_item_by_painting_[painting_id] = subway_item.id;
       }
 
       if (subway_it["tags"]) {
@@ -821,6 +847,10 @@ struct GameData {
         subway_item.special = subway_it["special"].as<std::string>();
       }
 
+      if (subway_it["tilted"]) {
+        subway_item.tilted = subway_it["tilted"].as<bool>();
+      }
+
       subway_items_.push_back(subway_item);
     }
 
@@ -880,7 +910,7 @@ struct GameData {
     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({.room = AddOrGetRoom(room)});
+      panel_doors_.push_back({});
     }
 
     return panel_doors_by_id_[full_name];
@@ -953,6 +983,14 @@ const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
 
+int GD_GetPanelBySolveIndex(int solve_index) {
+  return GetState().panel_by_solve_index_.at(solve_index);
+}
+
+const std::vector<PaintingExit> &GD_GetPaintings() {
+  return GetState().paintings_;
+}
+
 const PaintingExit &GD_GetPaintingExit(int painting_id) {
   return GetState().paintings_.at(painting_id);
 }
@@ -995,3 +1033,38 @@ std::optional<int> GD_GetSubwayItemForPainting(const std::string &painting_id) {
 int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
   return GetState().subway_item_by_sunwarp_.at(sunwarp);
 }
+
+std::string GD_GetItemName(int id) {
+  auto it = GetState().item_by_ap_id_.find(id);
+  if (it != GetState().item_by_ap_id_.end()) {
+    return it->second;
+  } else {
+    return "Unknown";
+  }
+}
+
+LingoColor GetLingoColorForString(const std::string &str) {
+  if (str == "black") {
+    return LingoColor::kBlack;
+  } else if (str == "red") {
+    return LingoColor::kRed;
+  } else if (str == "blue") {
+    return LingoColor::kBlue;
+  } else if (str == "yellow") {
+    return LingoColor::kYellow;
+  } else if (str == "orange") {
+    return LingoColor::kOrange;
+  } else if (str == "green") {
+    return LingoColor::kGreen;
+  } else if (str == "gray") {
+    return LingoColor::kGray;
+  } else if (str == "brown") {
+    return LingoColor::kBrown;
+  } else if (str == "purple") {
+    return LingoColor::kPurple;
+  } else {
+    TrackerLog(fmt::format("Invalid color: {}", str));
+
+    return LingoColor::kNone;
+  }
+}