Merge branch 'main' into panels

1 files changed, 202 insertions, 55 deletions

@@ -1,5 +1,11 @@
 #include "game_data.h"
 
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
 #include <hkutil/string.h>
 #include <yaml-cpp/yaml.h>
 
@@ -7,7 +13,6 @@
 #include <sstream>
 
 #include "global.h"
-#include "logger.h"
 
 namespace {
 
@@ -31,9 +36,7 @@ LingoColor GetColorForString(const std::string &str) {
   } else if (str == "purple") {
     return LingoColor::kPurple;
   } else {
-    std::ostringstream errmsg;
-    errmsg << "Invalid color: " << str;
-    TrackerLog(errmsg.str());
+    wxLogError("Invalid color: %s", str);
 
     return LingoColor::kNone;
   }
@@ -45,12 +48,15 @@ struct GameData {
   std::vector<Panel> panels_;
   std::vector<PanelDoor> panel_doors_;
   std::vector<MapArea> map_areas_;
+  std::vector<SubwayItem> subway_items_;
+  std::vector<PaintingExit> paintings_;
 
   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_;
 
   std::vector<int> door_definition_order_;
 
@@ -63,6 +69,9 @@ struct GameData {
 
   std::vector<int> sunwarp_doors_;
 
+  std::map<std::string, int> subway_item_by_painting_;
+  std::map<SubwaySunwarp, int> subway_item_by_sunwarp_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -81,9 +90,7 @@ struct GameData {
         ap_id_by_color_[GetColorForString(input_name)] =
             ids_config["special_items"][color_name].as<int>();
       } else {
-        std::ostringstream errmsg;
-        errmsg << "Missing AP item ID for color " << color_name;
-        TrackerLog(errmsg.str());
+        wxLogError("Missing AP item ID for color %s", color_name);
       }
     };
 
@@ -158,8 +165,9 @@ struct GameData {
           }
           default: {
             // This shouldn't happen.
-            std::cout << "Error reading game data: " << entrance_it
-                      << std::endl;
+            std::ostringstream formatted;
+            formatted << entrance_it;
+            wxLogError("Error reading game data: %s", formatted.str());
             break;
           }
         }
@@ -256,6 +264,11 @@ struct GameData {
             achievement_panels_.push_back(panel_id);
           }
 
+          if (panel_it.second["location_name"]) {
+            panels_[panel_id].location_name =
+                panel_it.second["location_name"].as<std::string>();
+          }
+
           if (panel_it.second["hunt"]) {
             panels_[panel_id].hunt = panel_it.second["hunt"].as<bool>();
           }
@@ -279,10 +292,8 @@ struct GameData {
                           [panels_[panel_id].name]
                               .as<int>();
           } else {
-            std::ostringstream errmsg;
-            errmsg << "Missing AP location ID for panel "
-                   << rooms_[room_id].name << " - " << panels_[panel_id].name;
-            TrackerLog(errmsg.str());
+            wxLogError("Missing AP location ID for panel %s - %s",
+                       rooms_[room_id].name, panels_[panel_id].name);
           }
         }
       }
@@ -345,10 +356,8 @@ struct GameData {
                             [doors_[door_id].name]["item"]
                                 .as<int>();
             } else {
-              std::ostringstream errmsg;
-              errmsg << "Missing AP item ID for door " << rooms_[room_id].name
-                     << " - " << doors_[door_id].name;
-              TrackerLog(errmsg.str());
+              wxLogError("Missing AP item ID for door %s - %s",
+                         rooms_[room_id].name, doors_[door_id].name);
             }
           }
 
@@ -362,10 +371,8 @@ struct GameData {
                   ids_config["door_groups"][doors_[door_id].group_name]
                       .as<int>();
             } else {
-              std::ostringstream errmsg;
-              errmsg << "Missing AP item ID for door group "
-                     << doors_[door_id].group_name;
-              TrackerLog(errmsg.str());
+              wxLogError("Missing AP item ID for door group %s",
+                         doors_[door_id].group_name);
             }
           }
 
@@ -375,13 +382,11 @@ struct GameData {
           } else if (!door_it.second["skip_location"] &&
                      !door_it.second["event"]) {
             if (has_external_panels) {
-              std::ostringstream errmsg;
-              errmsg
-                  << rooms_[room_id].name << " - " << doors_[door_id].name
-                  << " has panels from other rooms but does not have an "
-                     "explicit "
-                     "location name and is not marked skip_location or event";
-              TrackerLog(errmsg.str());
+              wxLogError(
+                  "%s - %s has panels from other rooms but does not have an "
+                  "explicit location name and is not marked skip_location or "
+                  "event",
+                  rooms_[room_id].name, doors_[door_id].name);
             }
 
             doors_[door_id].location_name =
@@ -401,10 +406,8 @@ struct GameData {
                             [doors_[door_id].name]["location"]
                                 .as<int>();
             } else {
-              std::ostringstream errmsg;
-              errmsg << "Missing AP location ID for door "
-                     << rooms_[room_id].name << " - " << doors_[door_id].name;
-              TrackerLog(errmsg.str());
+              wxLogError("Missing AP location ID for door %s - %s",
+                         rooms_[room_id].name, doors_[door_id].name);
             }
           }
 
@@ -478,12 +481,14 @@ struct GameData {
 
       if (room_it.second["paintings"]) {
         for (const auto &painting : room_it.second["paintings"]) {
-          std::string painting_id = painting["id"].as<std::string>();
-          room_by_painting_[painting_id] = room_id;
+          std::string internal_id = painting["id"].as<std::string>();
+          int painting_id = AddOrGetPainting(internal_id);
+          PaintingExit &painting_exit = paintings_[painting_id];
+          painting_exit.room = room_id;
 
-          if (!painting["exit_only"] || !painting["exit_only"].as<bool>()) {
-            PaintingExit painting_exit;
-            painting_exit.id = painting_id;
+          if ((!painting["exit_only"] || !painting["exit_only"].as<bool>()) &&
+              (!painting["disable"] || !painting["disable"].as<bool>())) {
+            painting_exit.entrance = true;
 
             if (painting["required_door"]) {
               std::string rd_room = rooms_[room_id].name;
@@ -494,9 +499,9 @@ struct GameData {
               painting_exit.door = AddOrGetDoor(
                   rd_room, painting["required_door"]["door"].as<std::string>());
             }
-
-            rooms_[room_id].paintings.push_back(painting_exit);
           }
+
+          rooms_[room_id].paintings.push_back(painting_exit.id);
         }
       }
 
@@ -523,10 +528,8 @@ struct GameData {
             progressive_item_id =
                 ids_config["progression"][progressive_item_name].as<int>();
           } else {
-            std::ostringstream errmsg;
-            errmsg << "Missing AP item ID for progressive item "
-                   << progressive_item_name;
-            TrackerLog(errmsg.str());
+            wxLogError("Missing AP item ID for progressive item %s",
+                       progressive_item_name);
           }
 
           if (progression_it.second["doors"]) {
@@ -600,8 +603,21 @@ struct GameData {
       std::string room_name = rooms_[room_id].name;
 
       std::string area_name = room_name;
-      if (fold_areas.count(room_name)) {
-        int fold_area_id = fold_areas[room_name];
+      std::string section_name = panel.name;
+      std::string location_name = room_name + " - " + panel.name;
+
+      if (!panel.location_name.empty()) {
+        location_name = panel.location_name;
+
+        size_t divider_pos = location_name.find(" - ");
+        if (divider_pos != std::string::npos) {
+          area_name = location_name.substr(0, divider_pos);
+          section_name = location_name.substr(divider_pos + 3);
+        }
+      }
+
+      if (fold_areas.count(area_name)) {
+        int fold_area_id = fold_areas[area_name];
         area_name = map_areas_[fold_area_id].name;
       }
 
@@ -617,15 +633,15 @@ struct GameData {
       MapArea &map_area = map_areas_[area_id];
       // room field should be the original room ID
       map_area.locations.push_back(
-          {.name = panel.name,
-           .ap_location_name = room_name + " - " + panel.name,
+          {.name = section_name,
+           .ap_location_name = location_name,
            .ap_location_id = panel.ap_location_id,
            .room = panel.room,
            .panels = {panel.id},
            .classification = classification,
            .hunt = panel.hunt});
-      locations_by_name[map_area.locations.back().ap_location_name] = {
-          area_id, map_area.locations.size() - 1};
+      locations_by_name[location_name] = {area_id,
+                                          map_area.locations.size() - 1};
     }
 
     for (int door_id : door_definition_order_) {
@@ -679,11 +695,101 @@ struct GameData {
       }
     }
 
+    for (const Room &room : rooms_) {
+      std::string area_name = room.name;
+      if (fold_areas.count(room.name)) {
+        int fold_area_id = fold_areas[room.name];
+        area_name = map_areas_[fold_area_id].name;
+      }
+
+      if (!room.paintings.empty()) {
+        int area_id = AddOrGetArea(area_name);
+        MapArea &map_area = map_areas_[area_id];
+
+        for (int painting_id : room.paintings) {
+          const PaintingExit &painting_obj = paintings_.at(painting_id);
+          if (painting_obj.entrance) {
+            map_area.paintings.push_back(painting_id);
+          }
+        }
+      }
+    }
+
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
-      std::ostringstream errstr;
-      errstr << "Area data not found for: " << area;
-      TrackerLog(errstr.str());
+      wxLogError("Area data not found for: %s", area);
+    }
+
+    // Read in subway items.
+    YAML::Node subway_config =
+        YAML::LoadFile(GetAbsolutePath("assets/subway.yaml"));
+    for (const auto &subway_it : subway_config) {
+      SubwayItem subway_item;
+      subway_item.id = subway_items_.size();
+      subway_item.x = subway_it["pos"][0].as<int>();
+      subway_item.y = subway_it["pos"][1].as<int>();
+
+      if (subway_it["door"]) {
+        subway_item.door = AddOrGetDoor(subway_it["room"].as<std::string>(),
+                                        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["tags"]) {
+        for (const auto &tag_it : subway_it["tags"]) {
+          subway_item.tags.push_back(tag_it.as<std::string>());
+        }
+      }
+
+      if (subway_it["sunwarp"]) {
+        SubwaySunwarp sunwarp;
+        sunwarp.dots = subway_it["sunwarp"]["dots"].as<int>();
+
+        std::string sunwarp_type =
+            subway_it["sunwarp"]["type"].as<std::string>();
+        if (sunwarp_type == "final") {
+          sunwarp.type = SubwaySunwarpType::kFinal;
+        } else if (sunwarp_type == "exit") {
+          sunwarp.type = SubwaySunwarpType::kExit;
+        } else {
+          sunwarp.type = SubwaySunwarpType::kEnter;
+        }
+
+        subway_item.sunwarp = sunwarp;
+
+        subway_item_by_sunwarp_[sunwarp] = subway_item.id;
+
+        subway_item.door =
+            AddOrGetDoor("Sunwarps", std::to_string(sunwarp.dots) + " Sunwarp");
+      }
+
+      if (subway_it["special"]) {
+        subway_item.special = subway_it["special"].as<std::string>();
+      }
+
+      subway_items_.push_back(subway_item);
+    }
+
+    // Find singleton subway tags.
+    std::map<std::string, std::set<int>> subway_tags;
+    for (const SubwayItem &subway_item : subway_items_) {
+      for (const std::string &tag : subway_item.tags) {
+        subway_tags[tag].insert(subway_item.id);
+      }
+    }
+
+    for (const auto &[tag, items] : subway_tags) {
+      if (items.size() == 1) {
+        wxLogWarning("Singleton subway item tag: %s", tag);
+      }
     }
   }
 
@@ -700,8 +806,10 @@ struct GameData {
     std::string full_name = room + " - " + door;
 
     if (!door_by_id_.count(full_name)) {
+      int door_id = doors_.size();
       door_by_id_[full_name] = doors_.size();
-      doors_.push_back({.room = AddOrGetRoom(room), .name = door});
+      doors_.push_back(
+          {.id = door_id, .room = AddOrGetRoom(room), .name = door});
     }
 
     return door_by_id_[full_name];
@@ -745,6 +853,16 @@ struct GameData {
 
     return area_by_id_[area];
   }
+
+  int AddOrGetPainting(std::string internal_id) {
+    if (!painting_by_id_.count(internal_id)) {
+      int painting_id = paintings_.size();
+      painting_by_id_[internal_id] = painting_id;
+      paintings_.push_back({.id = painting_id, .internal_id = internal_id});
+    }
+
+    return painting_by_id_[internal_id];
+  }
 };
 
 GameData &GetState() {
@@ -754,6 +872,10 @@ GameData &GetState() {
 
 }  // namespace
 
+bool SubwaySunwarp::operator<(const SubwaySunwarp &rhs) const {
+  return std::tie(dots, type) < std::tie(rhs.dots, rhs.type);
+}
+
 const std::vector<MapArea> &GD_GetMapAreas() { return GetState().map_areas_; }
 
 const MapArea &GD_GetMapArea(int id) { return GetState().map_areas_.at(id); }
@@ -780,8 +902,12 @@ const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
 
-int GD_GetRoomForPainting(const std::string &painting_id) {
-  return GetState().room_by_painting_.at(painting_id);
+const PaintingExit &GD_GetPaintingExit(int painting_id) {
+  return GetState().paintings_.at(painting_id);
+}
+
+int GD_GetPaintingByName(const std::string &name) {
+  return GetState().painting_by_id_.at(name);
 }
 
 const std::vector<int> &GD_GetAchievementPanels() {
@@ -799,3 +925,24 @@ const std::vector<int> &GD_GetSunwarpDoors() {
 int GD_GetRoomForSunwarp(int index) {
   return GetState().room_by_sunwarp_.at(index);
 }
+
+const std::vector<SubwayItem> &GD_GetSubwayItems() {
+  return GetState().subway_items_;
+}
+
+const SubwayItem &GD_GetSubwayItem(int id) {
+  return GetState().subway_items_.at(id);
+}
+
+int GD_GetSubwayItemForPainting(const std::string &painting_id) {
+#ifndef NDEBUG
+  if (!GetState().subway_item_by_painting_.count(painting_id)) {
+    wxLogError("No subway item for painting %s", painting_id);
+  }
+#endif
+  return GetState().subway_item_by_painting_.at(painting_id);
+}
+
+int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
+  return GetState().subway_item_by_sunwarp_.at(sunwarp);
+}