1 files changed, 387 insertions, 109 deletions

@@ -1,11 +1,6 @@
 #include "game_data.h"
 
-#include <wx/wxprec.h>
-
-#ifndef WX_PRECOMP
-#include <wx/wx.h>
-#endif
-
+#include <fmt/core.h>
 #include <hkutil/string.h>
 #include <yaml-cpp/yaml.h>
 
@@ -13,51 +8,31 @@
 #include <sstream>
 
 #include "global.h"
+#include "logger.h"
 
 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 {
-    wxLogError("Invalid color: %s", str);
-
-    return LingoColor::kNone;
-  }
-}
-
 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_;
 
   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_;
 
   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_;
 
@@ -68,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_;
 
@@ -83,10 +60,10 @@ 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 {
-        wxLogError("Missing AP item ID for color %s", color_name);
+        TrackerLog(fmt::format("Missing AP item ID for color {}", color_name));
       }
     };
 
@@ -100,8 +77,18 @@ 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>());
 
@@ -111,6 +98,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"]) {
@@ -139,13 +127,17 @@ struct GameData {
                 exit_obj.type = EntranceType::kCrossroadsRoofAccess;
               }
 
+              if (option["static_painting"] && option["static_painting"].as<bool>()) {
+                exit_obj.type = EntranceType::kStaticPainting;
+              }
+
               rooms_[from_room_id].exits.push_back(exit_obj);
             };
 
         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: {
@@ -163,7 +155,8 @@ struct GameData {
             // This shouldn't happen.
             std::ostringstream formatted;
             formatted << entrance_it;
-            wxLogError("Error reading game data: %s", formatted.str());
+            TrackerLog(
+                fmt::format("Error reading game data: {}", formatted.str()));
             break;
           }
         }
@@ -177,12 +170,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>()));
               }
             }
           }
@@ -260,6 +253,16 @@ 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["id"]) {
+            panels_[panel_id].nodepath =
+                panel_it.second["id"].as<std::string>();
+          }
+
           if (panel_it.second["hunt"]) {
             panels_[panel_id].hunt = panel_it.second["hunt"].as<bool>();
           }
@@ -278,13 +281,15 @@ 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 {
-            wxLogError("Missing AP location ID for panel %s - %s",
-                         rooms_[room_id].name, panels_[panel_id].name);
+            TrackerLog(fmt::format("Missing AP location ID for panel {} - {}",
+                                   rooms_[room_id].name,
+                                   panels_[panel_id].name));
           }
         }
       }
@@ -346,9 +351,13 @@ 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 {
-              wxLogError("Missing AP item ID for door %s - %s",
-                           rooms_[room_id].name, doors_[door_id].name);
+              TrackerLog(fmt::format("Missing AP item ID for door {} - {}",
+                                     rooms_[room_id].name,
+                                     doors_[door_id].name));
             }
           }
 
@@ -361,9 +370,12 @@ 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 {
-              wxLogError("Missing AP item ID for door group %s",
-                         doors_[door_id].group_name);
+              TrackerLog(fmt::format("Missing AP item ID for door group {}",
+                                     doors_[door_id].group_name));
             }
           }
 
@@ -373,11 +385,11 @@ struct GameData {
           } else if (!door_it.second["skip_location"] &&
                      !door_it.second["event"]) {
             if (has_external_panels) {
-              wxLogError(
-                  "%s - %s has panels from other rooms but does not have an "
+              TrackerLog(fmt::format(
+                  "{} - {} 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);
+                  rooms_[room_id].name, doors_[door_id].name));
             }
 
             doors_[door_id].location_name =
@@ -397,8 +409,9 @@ struct GameData {
                             [doors_[door_id].name]["location"]
                                 .as<int>();
             } else {
-              wxLogError("Missing AP location ID for door %s - %s",
-                         rooms_[room_id].name, doors_[door_id].name);
+              TrackerLog(fmt::format("Missing AP location ID for door {} - {}",
+                                     rooms_[room_id].name,
+                                     doors_[door_id].name));
             }
           }
 
@@ -417,14 +430,107 @@ 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);
+
+          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]
+                        [panel_door_name]) {
+            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));
+          }
+
+          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>();
+
+              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));
+            }
+          }
+        }
+      }
+
       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["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>()) {
-            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;
@@ -435,9 +541,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);
         }
       }
 
@@ -463,33 +569,74 @@ 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 {
-            wxLogError("Missing AP item ID for progressive item %s",
-                       progressive_item_name);
+            TrackerLog(fmt::format("Missing AP item ID for progressive item {}",
+                                   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++;
+            }
           }
         }
       }
     }
 
+    // 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;
@@ -510,13 +657,28 @@ 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;
 
       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);
+        }
+      } else {
+        panel.location_name = location_name;
+      }
+
+      if (fold_areas.count(area_name)) {
+        int fold_area_id = fold_areas[area_name];
         area_name = map_areas_[fold_area_id].name;
       }
 
@@ -528,19 +690,23 @@ struct GameData {
         }
       }
 
+      if (room_name == "Starting Room") {
+        classification |= kLOCATION_SMALL_SPHERE_ONE;
+      }
+
       int area_id = AddOrGetArea(area_name);
       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,
-           .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};
+      map_area.locations.push_back({.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,
+                                    .single_panel = panel.id});
+      locations_by_name[location_name] = {area_id,
+                                          map_area.locations.size() - 1};
     }
 
     for (int door_id : door_definition_order_) {
@@ -591,14 +757,36 @@ struct GameData {
       for (const Location &location : map_area.locations) {
         map_area.classification |= location.classification;
         map_area.hunt |= location.hunt;
+        map_area.has_single_panel |= location.single_panel.has_value();
+      }
+    }
+
+    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) {
+          PaintingExit &painting_obj = paintings_.at(painting_id);
+          painting_obj.map_area = area_id;
+          if (painting_obj.entrance) {
+            map_area.paintings.push_back(painting_id);
+          }
+        }
       }
     }
 
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
-      wxLogError("Area data not found for: %s", area);
+      TrackerLog(fmt::format("Area data not found for: {}", area));
     }
-    
+
     // Read in subway items.
     YAML::Node subway_config =
         YAML::LoadFile(GetAbsolutePath("assets/subway.yaml"));
@@ -613,13 +801,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"]) {
@@ -628,6 +813,18 @@ struct GameData {
         }
       }
 
+      if (subway_it["entrances"]) {
+        for (const auto &entrance_it : subway_it["entrances"]) {
+          subway_item.entrances.push_back(entrance_it.as<std::string>());
+        }
+      }
+
+      if (subway_it["exits"]) {
+        for (const auto &exit_it : subway_it["exits"]) {
+          subway_item.exits.push_back(exit_it.as<std::string>());
+        }
+      }
+
       if (subway_it["sunwarp"]) {
         SubwaySunwarp sunwarp;
         sunwarp.dots = subway_it["sunwarp"]["dots"].as<int>();
@@ -654,6 +851,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);
     }
 
@@ -667,7 +868,7 @@ struct GameData {
 
     for (const auto &[tag, items] : subway_tags) {
       if (items.size() == 1) {
-        wxLogWarning("Singleton subway item tag: %s", tag);
+        TrackerLog(fmt::format("Singleton subway item tag: {}", tag));
       }
     }
   }
@@ -687,7 +888,8 @@ struct GameData {
     if (!door_by_id_.count(full_name)) {
       int door_id = doors_.size();
       door_by_id_[full_name] = doors_.size();
-      doors_.push_back({.id = door_id, .room = AddOrGetRoom(room), .name = door});
+      doors_.push_back(
+          {.id = door_id, .room = AddOrGetRoom(room), .name = door});
     }
 
     return door_by_id_[full_name];
@@ -706,6 +908,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_) {
@@ -719,6 +933,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() {
@@ -728,7 +952,12 @@ GameData &GetState() {
 
 }  // namespace
 
-bool SubwaySunwarp::operator<(const SubwaySunwarp& rhs) const {
+bool SubwayItem::HasWarps() const {
+  return !(this->tags.empty() && this->entrances.empty() &&
+           this->exits.empty());
+}
+
+bool SubwaySunwarp::operator<(const SubwaySunwarp &rhs) const {
   return std::tie(dots, type) < std::tie(rhs.dots, rhs.type);
 }
 
@@ -746,6 +975,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);
 }
@@ -754,8 +987,20 @@ 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);
+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);
+}
+
+int GD_GetPaintingByName(const std::string &name) {
+  return GetState().painting_by_id_.at(name);
 }
 
 const std::vector<int> &GD_GetAchievementPanels() {
@@ -782,15 +1027,48 @@ 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);
+std::optional<int> GD_GetSubwayItemForPainting(const std::string &painting_id) {
+  if (GetState().subway_item_by_painting_.count(painting_id)) {
+    return GetState().subway_item_by_painting_.at(painting_id);
   }
-#endif
-  return GetState().subway_item_by_painting_.at(painting_id);
+  return std::nullopt;
 }
 
 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;
+  }
+}