18 files changed, 1711 insertions, 231 deletions

@@ -4,6 +4,7 @@
 #define _WEBSOCKETPP_CPP11_STRICT_
 #pragma comment(lib, "crypt32")
 
+#include <fmt/core.h>
 #include <hkutil/string.h>
 
 #include <any>
@@ -71,6 +72,7 @@ struct APState {
   bool sunwarp_shuffle = false;
 
   std::map<std::string, std::string> painting_mapping;
+  std::set<std::string> painting_codomain;
   std::map<int, SunwarpMapping> sunwarp_mapping;
 
   void Connect(std::string server, std::string player, std::string password) {
@@ -91,24 +93,25 @@ struct APState {
       }).detach();
 
       for (int panel_id : GD_GetAchievementPanels()) {
-        tracked_data_storage_keys.push_back(
-            "Achievement|" + GD_GetPanel(panel_id).achievement_name);
+        tracked_data_storage_keys.push_back(fmt::format(
+            "Achievement|{}", GD_GetPanel(panel_id).achievement_name));
       }
 
       for (const MapArea& map_area : GD_GetMapAreas()) {
         for (const Location& location : map_area.locations) {
           tracked_data_storage_keys.push_back(
-              "Hunt|" + std::to_string(location.ap_location_id));
+              fmt::format("Hunt|{}", location.ap_location_id));
         }
       }
 
       tracked_data_storage_keys.push_back("PlayerPos");
+      tracked_data_storage_keys.push_back("Paintings");
 
       initialized = true;
     }
 
     tracker_frame->SetStatusMessage("Connecting to Archipelago server....");
-    TrackerLog("Connecting to Archipelago server (" + server + ")...");
+    TrackerLog(fmt::format("Connecting to Archipelago server ({})...", server));
 
     {
       TrackerLog("Destroying old AP client...");
@@ -137,6 +140,7 @@ struct APState {
     color_shuffle = false;
     painting_shuffle = false;
     painting_mapping.clear();
+    painting_codomain.clear();
     mastery_requirement = 21;
     level_2_requirement = 223;
     location_checks = kNORMAL_LOCATIONS;
@@ -149,16 +153,17 @@ struct APState {
     sunwarp_shuffle = false;
     sunwarp_mapping.clear();
 
+    std::mutex connection_mutex;
     connected = false;
     has_connection_result = false;
 
     apclient->set_room_info_handler([this, player, password]() {
       inventory.clear();
 
-      TrackerLog("Connected to Archipelago server. Authenticating as " +
-                 player +
-                 (password.empty() ? " without password"
-                                   : " with password " + password));
+      TrackerLog(fmt::format(
+          "Connected to Archipelago server. Authenticating as {} {}", player,
+          (password.empty() ? "without password"
+                            : "with password " + password)));
       tracker_frame->SetStatusMessage(
           "Connected to Archipelago server. Authenticating...");
 
@@ -170,10 +175,10 @@ struct APState {
         [this](const std::list<int64_t>& locations) {
           for (const int64_t location_id : locations) {
             checked_locations.insert(location_id);
-            TrackerLog("Location: " + std::to_string(location_id));
+            TrackerLog(fmt::format("Location: {}", location_id));
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_slot_disconnected_handler([this]() {
@@ -194,10 +199,10 @@ struct APState {
         [this](const std::list<APClient::NetworkItem>& items) {
           for (const APClient::NetworkItem& item : items) {
             inventory[item.item]++;
-            TrackerLog("Item: " + std::to_string(item.item));
+            TrackerLog(fmt::format("Item: {}", item.item));
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_retrieved_handler(
@@ -206,23 +211,23 @@ struct APState {
             HandleDataStorage(key, value);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_set_reply_handler([this](const std::string& key,
                                            const nlohmann::json& value,
                                            const nlohmann::json&) {
       HandleDataStorage(key, value);
-      RefreshTracker();
+      RefreshTracker(false);
     });
 
-    apclient->set_slot_connected_handler([this](
+    apclient->set_slot_connected_handler([this, &connection_mutex](
                                              const nlohmann::json& slot_data) {
       tracker_frame->SetStatusMessage("Connected to Archipelago!");
       TrackerLog("Connected to Archipelago!");
 
       data_storage_prefix =
-          "Lingo_" + std::to_string(apclient->get_player_number()) + "_";
+          fmt::format("Lingo_{}_", apclient->get_player_number());
       door_shuffle_mode = slot_data["shuffle_doors"].get<DoorShuffleMode>();
       color_shuffle = slot_data["shuffle_colors"].get<int>() == 1;
       painting_shuffle = slot_data["shuffle_paintings"].get<int>() == 1;
@@ -253,6 +258,7 @@ struct APState {
         for (const auto& mapping_it :
              slot_data["painting_entrance_to_exit"].items()) {
           painting_mapping[mapping_it.key()] = mapping_it.value();
+          painting_codomain.insert(mapping_it.value());
         }
       }
 
@@ -268,33 +274,39 @@ struct APState {
         }
       }
 
-      connected = true;
-      has_connection_result = true;
-
-      RefreshTracker();
-
       std::list<std::string> corrected_keys;
       for (const std::string& key : tracked_data_storage_keys) {
         corrected_keys.push_back(data_storage_prefix + key);
       }
 
-      {
-        std::ostringstream vdsks;
-        vdsks << "_read_client_status_" << apclient->get_team_number() << "_"
-              << apclient->get_player_number();
-        victory_data_storage_key = vdsks.str();
-      }
+      victory_data_storage_key =
+          fmt::format("_read_client_status_{}_{}", apclient->get_team_number(),
+                      apclient->get_player_number());
 
       corrected_keys.push_back(victory_data_storage_key);
 
       apclient->Get(corrected_keys);
       apclient->SetNotify(corrected_keys);
+
+      ResetReachabilityRequirements();
+      RefreshTracker(true);
+
+      {
+        std::lock_guard connection_lock(connection_mutex);
+        if (!has_connection_result) {
+          connected = true;
+          has_connection_result = true;
+        }
+      }
     });
 
     apclient->set_slot_refused_handler(
-        [this](const std::list<std::string>& errors) {
-          connected = false;
-          has_connection_result = true;
+        [this, &connection_mutex](const std::list<std::string>& errors) {
+          {
+            std::lock_guard connection_lock(connection_mutex);
+            connected = false;
+            has_connection_result = true;
+          }
 
           tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
 
@@ -333,18 +345,29 @@ struct APState {
     int timeout = 5000;  // 5 seconds
     int interval = 100;
     int remaining_loops = timeout / interval;
-    while (!has_connection_result) {
-      if (interval == 0) {
-        connected = false;
-        has_connection_result = true;
+    while (true) {
+      {
+        std::lock_guard connection_lock(connection_mutex);
+        if (has_connection_result) {
+          break;
+        }
+      }
 
+      if (interval == 0) {
         DestroyClient();
 
         tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
-
         TrackerLog("Timeout while connecting to Archipelago server.");
         wxMessageBox("Timeout while connecting to Archipelago server.",
                      "Connection failed", wxOK | wxICON_ERROR);
+
+        {
+          std::lock_guard connection_lock(connection_mutex);
+          connected = false;
+          has_connection_result = true;
+        }
+
+        break;
       }
 
       std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -353,8 +376,6 @@ struct APState {
     }
 
     if (connected) {
-      RefreshTracker();
-    } else {
       client_active = false;
     }
   }
@@ -362,12 +383,12 @@ struct APState {
   void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
-      TrackerLog("Data storage " + key + " retrieved as " +
-                 (value.get<bool>() ? "true" : "false"));
+      TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
+                             (value.get<bool>() ? "true" : "false")));
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
-      TrackerLog("Data storage " + key + " retrieved as " +
-                 std::to_string(value.get<int>()));
+      TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
+                             value.get<int>()));
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
@@ -376,7 +397,7 @@ struct APState {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
 
-      TrackerLog("Data storage " + key + " retrieved as dictionary");
+      TrackerLog(fmt::format("Data storage {} retrieved as dictionary", key));
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
@@ -384,7 +405,19 @@ struct APState {
         data_storage.erase(key);
       }
 
-      TrackerLog("Data storage " + key + " retrieved as null");
+      TrackerLog(fmt::format("Data storage {} retrieved as null", key));
+    } else if (value.is_array()) {
+      auto list_value = value.get<std::vector<std::string>>();
+
+      if (key.ends_with("Paintings")) {
+        data_storage[key] =
+            std::set<std::string>(list_value.begin(), list_value.end());
+      } else {
+        data_storage[key] = list_value;
+      }
+
+      TrackerLog(fmt::format("Data storage {} retrieved as list: [{}]", key,
+                             hatkirby::implode(list_value, ", ")));
     }
   }
 
@@ -394,7 +427,7 @@ struct APState {
 
   bool HasCheckedHuntPanel(int location_id) {
     std::string key =
-        data_storage_prefix + "Hunt|" + std::to_string(location_id);
+        fmt::format("{}Hunt|{}", data_storage_prefix, location_id);
     return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
   }
 
@@ -403,26 +436,51 @@ struct APState {
   }
 
   bool HasAchievement(const std::string& name) {
-    std::string key = data_storage_prefix + "Achievement|" + name;
+    std::string key =
+        fmt::format("{}Achievement|{}", data_storage_prefix, name);
     return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
   }
 
-  void RefreshTracker() {
+  const std::set<std::string>& GetCheckedPaintings() {
+    std::string key = fmt::format("{}Paintings", data_storage_prefix);
+    if (!data_storage.count(key)) {
+      data_storage[key] = std::set<std::string>();
+    }
+
+    return std::any_cast<const std::set<std::string>&>(data_storage.at(key));
+  }
+
+  bool IsPaintingChecked(const std::string& painting_id) {
+    const auto& checked_paintings = GetCheckedPaintings();
+
+    return checked_paintings.count(painting_id) ||
+           (painting_mapping.count(painting_id) &&
+            checked_paintings.count(painting_mapping.at(painting_id)));
+  }
+
+  void RefreshTracker(bool reset) {
     TrackerLog("Refreshing display...");
 
     RecalculateReachability();
-    tracker_frame->UpdateIndicators();
+
+    if (reset) {
+      tracker_frame->ResetIndicators();
+    } else {
+      tracker_frame->UpdateIndicators();
+    }
   }
 
   int64_t GetItemId(const std::string& item_name) {
     int64_t ap_id = apclient->get_item_id(item_name);
     if (ap_id == APClient::INVALID_NAME_ID) {
-      TrackerLog("Could not find AP item ID for " + item_name);
+      TrackerLog(fmt::format("Could not find AP item ID for {}", item_name));
     }
 
     return ap_id;
   }
 
+  std::string GetItemName(int id) { return apclient->get_item_name(id); }
+
   bool HasReachedGoal() {
     return data_storage.count(victory_data_storage_key) &&
            std::any_cast<int>(data_storage.at(victory_data_storage_key)) ==
@@ -461,16 +519,32 @@ bool AP_HasItem(int item_id, int quantity) {
   return GetState().HasItem(item_id, quantity);
 }
 
+std::string AP_GetItemName(int item_id) {
+  return GetState().GetItemName(item_id);
+}
+
 DoorShuffleMode AP_GetDoorShuffleMode() { return GetState().door_shuffle_mode; }
 
 bool AP_IsColorShuffle() { return GetState().color_shuffle; }
 
 bool AP_IsPaintingShuffle() { return GetState().painting_shuffle; }
 
-const std::map<std::string, std::string> AP_GetPaintingMapping() {
+const std::map<std::string, std::string>& AP_GetPaintingMapping() {
   return GetState().painting_mapping;
 }
 
+bool AP_IsPaintingMappedTo(const std::string& painting_id) {
+  return GetState().painting_codomain.count(painting_id);
+}
+
+const std::set<std::string>& AP_GetCheckedPaintings() {
+  return GetState().GetCheckedPaintings();
+}
+
+bool AP_IsPaintingChecked(const std::string& painting_id) {
+  return GetState().IsPaintingChecked(painting_id);
+}
+
 int AP_GetMasteryRequirement() { return GetState().mastery_requirement; }
 
 int AP_GetLevel2Requirement() { return GetState().level_2_requirement; }
@@ -3,6 +3,7 @@
 
 #include <map>
 #include <optional>
+#include <set>
 #include <string>
 #include <tuple>
 
@@ -48,13 +49,21 @@ bool AP_HasCheckedHuntPanel(int location_id);
 
 bool AP_HasItem(int item_id, int quantity = 1);
 
+std::string AP_GetItemName(int item_id);
+
 DoorShuffleMode AP_GetDoorShuffleMode();
 
 bool AP_IsColorShuffle();
 
 bool AP_IsPaintingShuffle();
 
-const std::map<std::string, std::string> AP_GetPaintingMapping();
+const std::map<std::string, std::string>& AP_GetPaintingMapping();
+
+bool AP_IsPaintingMappedTo(const std::string& painting_id);
+
+const std::set<std::string>& AP_GetCheckedPaintings();
+
+bool AP_IsPaintingChecked(const std::string& painting_id);
 
 int AP_GetMasteryRequirement();
 
@@ -1,5 +1,7 @@
 #include "area_popup.h"
 
+#include <wx/dcbuffer.h>
+
 #include "ap_state.h"
 #include "game_data.h"
 #include "global.h"
@@ -8,6 +10,8 @@
 
 AreaPopup::AreaPopup(wxWindow* parent, int area_id)
     : wxScrolledCanvas(parent, wxID_ANY), area_id_(area_id) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
   unchecked_eye_ =
       wxBitmap(wxImage(GetAbsolutePath("assets/unchecked.png").c_str(),
                        wxBITMAP_TYPE_PNG)
@@ -61,6 +65,19 @@ void AreaPopup::UpdateIndicators() {
     }
   }
 
+  if (AP_IsPaintingShuffle()) {
+    for (int painting_id : map_area.paintings) {
+      const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+      wxSize item_extent = mem_dc.GetTextExtent(painting.internal_id);  // TODO: Replace with a friendly name.
+      int item_height = std::max(32, item_extent.GetHeight()) + 10;
+      acc_height += item_height;
+
+      if (item_extent.GetWidth() > col_width) {
+        col_width = item_extent.GetWidth();
+      }
+    }
+  }
+
   int item_width = col_width + 10 + 32;
   int full_width = std::max(header_extent.GetWidth(), item_width) + 20;
 
@@ -105,10 +122,31 @@ void AreaPopup::UpdateIndicators() {
 
     cur_height += 10 + 32;
   }
+
+  if (AP_IsPaintingShuffle()) {
+    for (int painting_id : map_area.paintings) {
+      const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+      bool checked = AP_IsPaintingChecked(painting.internal_id);
+      wxBitmap* eye_ptr = checked ? &checked_eye_ : &unchecked_eye_;
+
+      mem_dc.DrawBitmap(*eye_ptr, {10, cur_height});
+
+      bool reachable = IsPaintingReachable(painting_id);
+      const wxColour* text_color = reachable ? wxWHITE : wxRED;
+      mem_dc.SetTextForeground(*text_color);
+
+      wxSize item_extent = mem_dc.GetTextExtent(painting.internal_id);  // TODO: Replace with friendly name.
+      mem_dc.DrawText(painting.internal_id,
+                      {10 + 32 + 10,
+                       cur_height + (32 - mem_dc.GetFontMetrics().height) / 2});
+
+      cur_height += 10 + 32;
+    }
+  }
 }
 
 void AreaPopup::OnPaint(wxPaintEvent& event) {
-  wxPaintDC dc(this);
+  wxBufferedPaintDC dc(this);
   PrepareDC(dc);
   dc.DrawBitmap(rendered_, 0, 0);
 
@@ -1,5 +1,6 @@
 #include "game_data.h"
 
+#include <fmt/core.h>
 #include <hkutil/string.h>
 #include <yaml-cpp/yaml.h>
 
@@ -31,9 +32,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());
+    TrackerLog(fmt::format("Invalid color: {}", str));
 
     return LingoColor::kNone;
   }
@@ -44,11 +43,14 @@ struct GameData {
   std::vector<Door> doors_;
   std::vector<Panel> panels_;
   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> area_by_id_;
+  std::map<std::string, int> painting_by_id_;
 
   std::vector<int> door_definition_order_;
 
@@ -61,6 +63,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_;
 
@@ -79,9 +84,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());
+        TrackerLog(fmt::format("Missing AP item ID for color {}", color_name));
       }
     };
 
@@ -156,8 +159,10 @@ struct GameData {
           }
           default: {
             // This shouldn't happen.
-            std::cout << "Error reading game data: " << entrance_it
-                      << std::endl;
+            std::ostringstream formatted;
+            formatted << entrance_it;
+            TrackerLog(
+                fmt::format("Error reading game data: {}", formatted.str()));
             break;
           }
         }
@@ -282,10 +287,9 @@ 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());
+            TrackerLog(fmt::format("Missing AP location ID for panel {} - {}",
+                                   rooms_[room_id].name,
+                                   panels_[panel_id].name));
           }
         }
       }
@@ -348,10 +352,9 @@ 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());
+              TrackerLog(fmt::format("Missing AP item ID for door {} - {}",
+                                     rooms_[room_id].name,
+                                     doors_[door_id].name));
             }
           }
 
@@ -365,10 +368,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());
+              TrackerLog(fmt::format("Missing AP item ID for door group {}",
+                                     doors_[door_id].group_name));
             }
           }
 
@@ -378,13 +379,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());
+              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));
             }
 
             doors_[door_id].location_name =
@@ -404,10 +403,9 @@ 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());
+              TrackerLog(fmt::format("Missing AP location ID for door {} - {}",
+                                     rooms_[room_id].name,
+                                     doors_[door_id].name));
             }
           }
 
@@ -428,12 +426,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;
@@ -444,9 +444,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);
         }
       }
 
@@ -473,10 +473,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());
+            TrackerLog(fmt::format("Missing AP item ID for progressive item {}",
+                                   progressive_item_name));
           }
 
           int index = 1;
@@ -559,14 +557,13 @@ struct GameData {
       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 = 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});
+      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});
       locations_by_name[location_name] = {area_id,
                                           map_area.locations.size() - 1};
     }
@@ -622,11 +619,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());
+      TrackerLog(fmt::format("Area data not found for: {}", 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) {
+        TrackerLog(fmt::format("Singleton subway item tag: {}", tag));
+      }
     }
   }
 
@@ -643,8 +730,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];
@@ -676,6 +765,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() {
@@ -685,6 +784,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); }
@@ -707,8 +810,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() {
@@ -726,3 +833,22 @@ 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);
+}
+
+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);
+  }
+  return std::nullopt;
+}
+
+int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
+  return GetState().subway_item_by_sunwarp_.at(sunwarp);
+}
@@ -64,6 +64,7 @@ struct ProgressiveRequirement {
 };
 
 struct Door {
+  int id;
   int room;
   std::string name;
   std::string location_name;
@@ -88,14 +89,17 @@ struct Exit {
 };
 
 struct PaintingExit {
-  std::string id;
+  int id;
+  int room;
+  std::string internal_id;
   std::optional<int> door;
+  bool entrance = false;
 };
 
 struct Room {
   std::string name;
   std::vector<Exit> exits;
-  std::vector<PaintingExit> paintings;
+  std::vector<int> paintings;
   std::vector<int> sunwarps;
   std::vector<int> panels;
 };
@@ -114,12 +118,37 @@ struct MapArea {
   int id;
   std::string name;
   std::vector<Location> locations;
+  std::vector<int> paintings;
   int map_x;
   int map_y;
   int classification = 0;
   bool hunt = false;
 };
 
+enum class SubwaySunwarpType {
+  kEnter,
+  kExit,
+  kFinal
+};
+
+struct SubwaySunwarp {
+  int dots;
+  SubwaySunwarpType type;
+
+  bool operator<(const SubwaySunwarp& rhs) const;
+};
+
+struct SubwayItem {
+  int id;
+  int x;
+  int y;
+  std::optional<int> door;
+  std::vector<std::string> paintings;
+  std::vector<std::string> tags;
+  std::optional<SubwaySunwarp> sunwarp;
+  std::optional<std::string> special;
+};
+
 const std::vector<MapArea>& GD_GetMapAreas();
 const MapArea& GD_GetMapArea(int id);
 int GD_GetRoomByName(const std::string& name);
@@ -128,10 +157,15 @@ const std::vector<Door>& GD_GetDoors();
 const Door& GD_GetDoor(int door_id);
 int GD_GetDoorByName(const std::string& name);
 const Panel& GD_GetPanel(int panel_id);
-int GD_GetRoomForPainting(const std::string& painting_id);
+const PaintingExit& GD_GetPaintingExit(int painting_id);
+int GD_GetPaintingByName(const std::string& name);
 const std::vector<int>& GD_GetAchievementPanels();
 int GD_GetItemIdForColor(LingoColor color);
 const std::vector<int>& GD_GetSunwarpDoors();
 int GD_GetRoomForSunwarp(int index);
+const std::vector<SubwayItem>& GD_GetSubwayItems();
+const SubwayItem& GD_GetSubwayItem(int id);
+std::optional<int> GD_GetSubwayItemForPainting(const std::string& painting_id);
+int GD_GetSubwayItemForSunwarp(const SubwaySunwarp& sunwarp);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -26,7 +26,7 @@ class Logger {
 
 }  // namespace
 
-void TrackerLog(const std::string& text) {
+void TrackerLog(std::string text) {
   static Logger* instance = new Logger();
   instance->LogLine(text);
 }
@@ -1,8 +1,8 @@
-#ifndef LOGGER_H_6E7B9594
-#define LOGGER_H_6E7B9594
+#ifndef LOGGER_H_9BDD07EA
+#define LOGGER_H_9BDD07EA
 
 #include <string>
 
-void TrackerLog(const std::string& text);
+void TrackerLog(std::string message);
 
-#endif /* end of include guard: LOGGER_H_6E7B9594 */
+#endif /* end of include guard: LOGGER_H_9BDD07EA */
@@ -4,6 +4,7 @@
 #include <wx/wx.h>
 #endif
 
+#include "global.h"
 #include "tracker_config.h"
 #include "tracker_frame.h"
 
@@ -16,6 +17,16 @@ class TrackerApp : public wxApp {
     frame->Show(true);
     return true;
   }
+
+  bool OnExceptionInMainLoop() override {
+    try {
+      throw;
+    } catch (const std::exception& ex) {
+      wxLogError(ex.what());
+    }
+
+    return false;
+  }
 };
 
 wxIMPLEMENT_APP(TrackerApp);
@@ -0,0 +1,30 @@
+#include "network_set.h"
+
+void NetworkSet::Clear() {
+  network_by_item_.clear();
+}
+
+void NetworkSet::AddLink(int id1, int id2) {
+  if (id2 > id1) {
+    // Make sure id1 < id2
+    std::swap(id1, id2);
+  }
+
+  if (!network_by_item_.count(id1)) {
+    network_by_item_[id1] = {};
+  }
+  if (!network_by_item_.count(id2)) {
+    network_by_item_[id2] = {};
+  }
+
+  network_by_item_[id1].insert({id1, id2});
+  network_by_item_[id2].insert({id1, id2});
+}
+
+bool NetworkSet::IsItemInNetwork(int id) const {
+  return network_by_item_.count(id);
+}
+
+const std::set<std::pair<int, int>>& NetworkSet::GetNetworkGraph(int id) const {
+  return network_by_item_.at(id);
+}
@@ -0,0 +1,25 @@
+#ifndef NETWORK_SET_H_3036B8E3
+#define NETWORK_SET_H_3036B8E3
+
+#include <map>
+#include <optional>
+#include <set>
+#include <utility>
+#include <vector>
+
+class NetworkSet {
+ public:
+  void Clear();
+
+  void AddLink(int id1, int id2);
+
+  bool IsItemInNetwork(int id) const;
+
+  const std::set<std::pair<int, int>>& GetNetworkGraph(int id) const;
+
+ private:
+
+  std::map<int, std::set<std::pair<int, int>>> network_by_item_;
+};
+
+#endif /* end of include guard: NETWORK_SET_H_3036B8E3 */
@@ -0,0 +1,724 @@
+#include "subway_map.h"
+
+#include <fmt/core.h>
+#include <wx/dcbuffer.h>
+#include <wx/dcgraph.h>
+
+#include <sstream>
+
+#include "ap_state.h"
+#include "game_data.h"
+#include "global.h"
+#include "tracker_state.h"
+
+constexpr int AREA_ACTUAL_SIZE = 21;
+constexpr int OWL_ACTUAL_SIZE = 32;
+
+enum class ItemDrawType { kNone, kBox, kOwl };
+
+SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
+  map_image_ =
+      wxImage(GetAbsolutePath("assets/subway.png").c_str(), wxBITMAP_TYPE_PNG);
+  if (!map_image_.IsOk()) {
+    return;
+  }
+
+  owl_image_ =
+      wxImage(GetAbsolutePath("assets/owl.png").c_str(), wxBITMAP_TYPE_PNG);
+  if (!owl_image_.IsOk()) {
+    return;
+  }
+
+  unchecked_eye_ =
+      wxBitmap(wxImage(GetAbsolutePath("assets/unchecked.png").c_str(),
+                       wxBITMAP_TYPE_PNG)
+                   .Scale(32, 32));
+  checked_eye_ = wxBitmap(
+      wxImage(GetAbsolutePath("assets/checked.png").c_str(), wxBITMAP_TYPE_PNG)
+          .Scale(32, 32));
+
+  tree_ = std::make_unique<quadtree::Quadtree<int, GetItemBox>>(
+      quadtree::Box<float>{0, 0, static_cast<float>(map_image_.GetWidth()),
+                           static_cast<float>(map_image_.GetHeight())});
+  for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
+    tree_->add(subway_item.id);
+  }
+
+  Redraw();
+
+  scroll_timer_ = new wxTimer(this);
+
+  Bind(wxEVT_PAINT, &SubwayMap::OnPaint, this);
+  Bind(wxEVT_MOTION, &SubwayMap::OnMouseMove, this);
+  Bind(wxEVT_MOUSEWHEEL, &SubwayMap::OnMouseScroll, this);
+  Bind(wxEVT_LEAVE_WINDOW, &SubwayMap::OnMouseLeave, this);
+  Bind(wxEVT_LEFT_DOWN, &SubwayMap::OnMouseClick, this);
+  Bind(wxEVT_TIMER, &SubwayMap::OnTimer, this);
+
+  zoom_slider_ = new wxSlider(this, wxID_ANY, 0, 0, 8, {15, 15});
+  zoom_slider_->Bind(wxEVT_SLIDER, &SubwayMap::OnZoomSlide, this);
+
+  help_button_ = new wxButton(this, wxID_ANY, "Help");
+  help_button_->Bind(wxEVT_BUTTON, &SubwayMap::OnClickHelp, this);
+  SetUpHelpButton();
+}
+
+void SubwayMap::OnConnect() {
+  networks_.Clear();
+
+  std::map<std::string, std::vector<int>> tagged;
+  for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
+    if (AP_HasEarlyColorHallways() &&
+        subway_item.special == "starting_room_paintings") {
+      tagged["early_ch"].push_back(subway_item.id);
+    }
+
+    if (AP_IsPaintingShuffle() && !subway_item.paintings.empty()) {
+      continue;
+    }
+
+    for (const std::string &tag : subway_item.tags) {
+      tagged[tag].push_back(subway_item.id);
+    }
+
+    if (!AP_IsSunwarpShuffle() && subway_item.sunwarp &&
+        subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
+      std::string tag = fmt::format("subway{}", subway_item.sunwarp->dots);
+      tagged[tag].push_back(subway_item.id);
+    }
+
+    if (!AP_IsPilgrimageEnabled() &&
+        (subway_item.special == "sun_painting" ||
+         subway_item.special == "sun_painting_exit")) {
+      tagged["sun_painting"].push_back(subway_item.id);
+    }
+  }
+
+  if (AP_IsSunwarpShuffle()) {
+    for (const auto &[index, mapping] : AP_GetSunwarpMapping()) {
+      std::string tag = fmt::format("sunwarp{}", mapping.dots);
+
+      SubwaySunwarp fromWarp;
+      if (index < 6) {
+        fromWarp.dots = index + 1;
+        fromWarp.type = SubwaySunwarpType::kEnter;
+      } else {
+        fromWarp.dots = index - 5;
+        fromWarp.type = SubwaySunwarpType::kExit;
+      }
+
+      SubwaySunwarp toWarp;
+      if (mapping.exit_index < 6) {
+        toWarp.dots = mapping.exit_index + 1;
+        toWarp.type = SubwaySunwarpType::kEnter;
+      } else {
+        toWarp.dots = mapping.exit_index - 5;
+        toWarp.type = SubwaySunwarpType::kExit;
+      }
+
+      tagged[tag].push_back(GD_GetSubwayItemForSunwarp(fromWarp));
+      tagged[tag].push_back(GD_GetSubwayItemForSunwarp(toWarp));
+    }
+  }
+
+  for (const auto &[tag, items] : tagged) {
+    // Pairwise connect all items with the same tag.
+    for (auto tag_it1 = items.begin(); std::next(tag_it1) != items.end();
+         tag_it1++) {
+      for (auto tag_it2 = std::next(tag_it1); tag_it2 != items.end();
+           tag_it2++) {
+        networks_.AddLink(*tag_it1, *tag_it2);
+      }
+    }
+  }
+
+  checked_paintings_.clear();
+}
+
+void SubwayMap::UpdateIndicators() {
+  if (AP_IsPaintingShuffle()) {
+    for (const std::string &painting_id : AP_GetCheckedPaintings()) {
+      if (!checked_paintings_.count(painting_id)) {
+        checked_paintings_.insert(painting_id);
+
+        if (AP_GetPaintingMapping().count(painting_id)) {
+          std::optional<int> from_id = GD_GetSubwayItemForPainting(painting_id);
+          std::optional<int> to_id = GD_GetSubwayItemForPainting(
+              AP_GetPaintingMapping().at(painting_id));
+
+          if (from_id && to_id) {
+            networks_.AddLink(*from_id, *to_id);
+          }
+        }
+      }
+    }
+  }
+
+  Redraw();
+}
+
+void SubwayMap::UpdateSunwarp(SubwaySunwarp from_sunwarp,
+                              SubwaySunwarp to_sunwarp) {
+  networks_.AddLink(GD_GetSubwayItemForSunwarp(from_sunwarp),
+                    GD_GetSubwayItemForSunwarp(to_sunwarp));
+}
+
+void SubwayMap::Zoom(bool in) {
+  wxPoint focus_point;
+
+  if (mouse_position_) {
+    focus_point = *mouse_position_;
+  } else {
+    focus_point = {GetSize().GetWidth() / 2, GetSize().GetHeight() / 2};
+  }
+
+  if (in) {
+    if (zoom_ < 3.0) {
+      SetZoom(zoom_ + 0.25, focus_point);
+    }
+  } else {
+    if (zoom_ > 1.0) {
+      SetZoom(zoom_ - 0.25, focus_point);
+    }
+  }
+}
+
+void SubwayMap::OnPaint(wxPaintEvent &event) {
+  if (GetSize() != rendered_.GetSize()) {
+    wxSize panel_size = GetSize();
+    wxSize image_size = map_image_.GetSize();
+
+    render_x_ = 0;
+    render_y_ = 0;
+    render_width_ = panel_size.GetWidth();
+    render_height_ = panel_size.GetHeight();
+
+    if (image_size.GetWidth() * panel_size.GetHeight() >
+        panel_size.GetWidth() * image_size.GetHeight()) {
+      render_height_ = (panel_size.GetWidth() * image_size.GetHeight()) /
+                       image_size.GetWidth();
+      render_y_ = (panel_size.GetHeight() - render_height_) / 2;
+    } else {
+      render_width_ = (image_size.GetWidth() * panel_size.GetHeight()) /
+                      image_size.GetHeight();
+      render_x_ = (panel_size.GetWidth() - render_width_) / 2;
+    }
+
+    SetZoomPos({zoom_x_, zoom_y_});
+
+    SetUpHelpButton();
+  }
+
+  wxBufferedPaintDC dc(this);
+  dc.SetBackground(*wxWHITE_BRUSH);
+  dc.Clear();
+
+  {
+    wxMemoryDC rendered_dc;
+    rendered_dc.SelectObject(rendered_);
+
+    int dst_x;
+    int dst_y;
+    int dst_w;
+    int dst_h;
+    int src_x;
+    int src_y;
+    int src_w;
+    int src_h;
+
+    int zoomed_width = render_width_ * zoom_;
+    int zoomed_height = render_height_ * zoom_;
+
+    if (zoomed_width <= GetSize().GetWidth()) {
+      dst_x = (GetSize().GetWidth() - zoomed_width) / 2;
+      dst_w = zoomed_width;
+      src_x = 0;
+      src_w = map_image_.GetWidth();
+    } else {
+      dst_x = 0;
+      dst_w = GetSize().GetWidth();
+      src_x = -zoom_x_ * map_image_.GetWidth() / render_width_ / zoom_;
+      src_w =
+          GetSize().GetWidth() * map_image_.GetWidth() / render_width_ / zoom_;
+    }
+
+    if (zoomed_height <= GetSize().GetHeight()) {
+      dst_y = (GetSize().GetHeight() - zoomed_height) / 2;
+      dst_h = zoomed_height;
+      src_y = 0;
+      src_h = map_image_.GetHeight();
+    } else {
+      dst_y = 0;
+      dst_h = GetSize().GetHeight();
+      src_y = -zoom_y_ * map_image_.GetWidth() / render_width_ / zoom_;
+      src_h =
+          GetSize().GetHeight() * map_image_.GetWidth() / render_width_ / zoom_;
+    }
+
+    wxGCDC gcdc(dc);
+    gcdc.GetGraphicsContext()->SetInterpolationQuality(wxINTERPOLATION_GOOD);
+    gcdc.StretchBlit(dst_x, dst_y, dst_w, dst_h, &rendered_dc, src_x, src_y,
+                     src_w, src_h);
+  }
+
+  if (hovered_item_) {
+    // Note that these requirements are duplicated on OnMouseClick so that it
+    // knows when an item has a hover effect.
+    const SubwayItem &subway_item = GD_GetSubwayItem(*hovered_item_);
+    if (subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) {
+      const std::map<std::string, bool> &report =
+          GetDoorRequirements(*subway_item.door);
+
+      int acc_height = 10;
+      int col_width = 0;
+
+      for (const auto &[text, obtained] : report) {
+        wxSize item_extent = dc.GetTextExtent(text);
+        int item_height = std::max(32, item_extent.GetHeight()) + 10;
+        acc_height += item_height;
+
+        if (item_extent.GetWidth() > col_width) {
+          col_width = item_extent.GetWidth();
+        }
+      }
+
+      int item_width = col_width + 10 + 32;
+      int full_width = item_width + 20;
+
+      wxPoint popup_pos =
+          MapPosToRenderPos({subway_item.x + AREA_ACTUAL_SIZE / 2,
+                             subway_item.y + AREA_ACTUAL_SIZE / 2});
+
+      if (popup_pos.x + full_width > GetSize().GetWidth()) {
+        popup_pos.x = GetSize().GetWidth() - full_width;
+      }
+      if (popup_pos.y + acc_height > GetSize().GetHeight()) {
+        popup_pos.y = GetSize().GetHeight() - acc_height;
+      }
+
+      dc.SetPen(*wxTRANSPARENT_PEN);
+      dc.SetBrush(*wxBLACK_BRUSH);
+      dc.DrawRectangle(popup_pos, {full_width, acc_height});
+
+      dc.SetFont(GetFont());
+
+      int cur_height = 10;
+
+      for (const auto &[text, obtained] : report) {
+        wxBitmap *eye_ptr = obtained ? &checked_eye_ : &unchecked_eye_;
+
+        dc.DrawBitmap(*eye_ptr, popup_pos + wxPoint{10, cur_height});
+
+        dc.SetTextForeground(obtained ? *wxWHITE : *wxRED);
+        wxSize item_extent = dc.GetTextExtent(text);
+        dc.DrawText(
+            text,
+            popup_pos +
+                wxPoint{10 + 32 + 10,
+                        cur_height + (32 - dc.GetFontMetrics().height) / 2});
+
+        cur_height += 10 + 32;
+      }
+    }
+
+    if (networks_.IsItemInNetwork(*hovered_item_)) {
+      dc.SetBrush(*wxTRANSPARENT_BRUSH);
+
+      for (const auto &[item_id1, item_id2] :
+           networks_.GetNetworkGraph(*hovered_item_)) {
+        const SubwayItem &item1 = GD_GetSubwayItem(item_id1);
+        const SubwayItem &item2 = GD_GetSubwayItem(item_id2);
+
+        wxPoint item1_pos = MapPosToRenderPos(
+            {item1.x + AREA_ACTUAL_SIZE / 2, item1.y + AREA_ACTUAL_SIZE / 2});
+        wxPoint item2_pos = MapPosToRenderPos(
+            {item2.x + AREA_ACTUAL_SIZE / 2, item2.y + AREA_ACTUAL_SIZE / 2});
+
+        int left = std::min(item1_pos.x, item2_pos.x);
+        int top = std::min(item1_pos.y, item2_pos.y);
+        int right = std::max(item1_pos.x, item2_pos.x);
+        int bottom = std::max(item1_pos.y, item2_pos.y);
+
+        int halfwidth = right - left;
+        int halfheight = bottom - top;
+
+        if (halfwidth < 4 || halfheight < 4) {
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawLine(item1_pos, item2_pos);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawLine(item1_pos, item2_pos);
+        } else {
+          int ellipse_x;
+          int ellipse_y;
+          double start;
+          double end;
+
+          if (item1_pos.x > item2_pos.x) {
+            ellipse_y = top;
+
+            if (item1_pos.y > item2_pos.y) {
+              ellipse_x = left - halfwidth;
+
+              start = 0;
+              end = 90;
+            } else {
+              ellipse_x = left;
+
+              start = 90;
+              end = 180;
+            }
+          } else {
+            ellipse_y = top - halfheight;
+
+            if (item1_pos.y > item2_pos.y) {
+              ellipse_x = left - halfwidth;
+
+              start = 270;
+              end = 360;
+            } else {
+              ellipse_x = left;
+
+              start = 180;
+              end = 270;
+            }
+          }
+
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2,
+                             halfheight * 2, start, end);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2,
+                             halfheight * 2, start, end);
+        }
+      }
+    }
+  }
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseMove(wxMouseEvent &event) {
+  wxPoint mouse_pos = RenderPosToMapPos(event.GetPosition());
+
+  std::vector<int> hovered = tree_->query(
+      {static_cast<float>(mouse_pos.x), static_cast<float>(mouse_pos.y), 2, 2});
+  if (!hovered.empty()) {
+    actual_hover_ = hovered[0];
+  } else {
+    actual_hover_ = std::nullopt;
+  }
+
+  if (!sticky_hover_ && actual_hover_ != hovered_item_) {
+    hovered_item_ = actual_hover_;
+
+    Refresh();
+  }
+
+  if (scroll_mode_) {
+    EvaluateScroll(event.GetPosition());
+  }
+
+  mouse_position_ = event.GetPosition();
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseScroll(wxMouseEvent &event) {
+  double new_zoom = zoom_;
+  if (event.GetWheelRotation() > 0) {
+    new_zoom = std::min(3.0, zoom_ + 0.25);
+  } else {
+    new_zoom = std::max(1.0, zoom_ - 0.25);
+  }
+
+  if (zoom_ != new_zoom) {
+    SetZoom(new_zoom, event.GetPosition());
+  }
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseLeave(wxMouseEvent &event) {
+  SetScrollSpeed(0, 0);
+  mouse_position_ = std::nullopt;
+}
+
+void SubwayMap::OnMouseClick(wxMouseEvent &event) {
+  bool finished = false;
+
+  if (actual_hover_) {
+    const SubwayItem &subway_item = GD_GetSubwayItem(*actual_hover_);
+    if ((subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) ||
+        networks_.IsItemInNetwork(*hovered_item_)) {
+      if (actual_hover_ != hovered_item_) {
+        hovered_item_ = actual_hover_;
+
+        if (!hovered_item_) {
+          sticky_hover_ = false;
+        }
+
+        Refresh();
+      } else {
+        sticky_hover_ = !sticky_hover_;
+      }
+
+      finished = true;
+    }
+  }
+
+  if (!finished) {
+    if (scroll_mode_) {
+      scroll_mode_ = false;
+
+      SetScrollSpeed(0, 0);
+
+      SetCursor(wxCURSOR_ARROW);
+    } else if (event.GetPosition().x < GetSize().GetWidth() / 6 ||
+               event.GetPosition().x > 5 * GetSize().GetWidth() / 6 ||
+               event.GetPosition().y < GetSize().GetHeight() / 6 ||
+               event.GetPosition().y > 5 * GetSize().GetHeight() / 6) {
+      scroll_mode_ = true;
+
+      EvaluateScroll(event.GetPosition());
+
+      SetCursor(wxCURSOR_CROSS);
+    } else {
+      sticky_hover_ = false;
+    }
+  }
+}
+
+void SubwayMap::OnTimer(wxTimerEvent &event) {
+  SetZoomPos({zoom_x_ + scroll_x_, zoom_y_ + scroll_y_});
+  Refresh();
+}
+
+void SubwayMap::OnZoomSlide(wxCommandEvent &event) {
+  double new_zoom = 1.0 + 0.25 * zoom_slider_->GetValue();
+
+  if (new_zoom != zoom_) {
+    SetZoom(new_zoom, {GetSize().GetWidth() / 2, GetSize().GetHeight() / 2});
+  }
+}
+
+void SubwayMap::OnClickHelp(wxCommandEvent &event) {
+  wxMessageBox(
+      "Zoom in/out using the mouse wheel, Ctrl +/-, or the slider in the "
+      "corner.\nClick on a side of the screen to start panning. It will follow "
+      "your mouse. Click again to stop.\nHover over a door to see the "
+      "requirements to open it.\nHover over a warp or active painting to see "
+      "what it is connected to.\nIn painting shuffle, paintings that have not "
+      "yet been checked will not show their connections.\nA green shaded owl "
+      "means that there is a painting entrance there.\nA red shaded owl means "
+      "that there are only painting exits there.\nClick on a door or "
+      "warp to make the popup stick until you click again.",
+      "Subway Map Help");
+}
+
+void SubwayMap::Redraw() {
+  rendered_ = wxBitmap(map_image_);
+
+  wxMemoryDC dc;
+  dc.SelectObject(rendered_);
+
+  wxGCDC gcdc(dc);
+
+  for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
+    ItemDrawType draw_type = ItemDrawType::kNone;
+    const wxBrush *brush_color = wxGREY_BRUSH;
+    std::optional<wxColour> shade_color;
+
+    if (AP_HasEarlyColorHallways() &&
+        subway_item.special == "starting_room_paintings") {
+      draw_type = ItemDrawType::kOwl;
+      shade_color = wxColour(0, 255, 0, 128);
+    } else if (subway_item.special == "sun_painting") {
+      if (!AP_IsPilgrimageEnabled()) {
+        if (IsDoorOpen(*subway_item.door)) {
+          draw_type = ItemDrawType::kOwl;
+          shade_color = wxColour(0, 255, 0, 128);
+        } else {
+          draw_type = ItemDrawType::kBox;
+          brush_color = wxRED_BRUSH;
+        }
+      }
+    } else if (!subway_item.paintings.empty()) {
+      if (AP_IsPaintingShuffle()) {
+        bool has_checked_painting = false;
+        bool has_unchecked_painting = false;
+        bool has_mapped_painting = false;
+        bool has_codomain_painting = false;
+
+        for (const std::string &painting_id : subway_item.paintings) {
+          if (checked_paintings_.count(painting_id)) {
+            has_checked_painting = true;
+
+            if (AP_GetPaintingMapping().count(painting_id)) {
+              has_mapped_painting = true;
+            } else if (AP_IsPaintingMappedTo(painting_id)) {
+              has_codomain_painting = true;
+            }
+          } else {
+            has_unchecked_painting = true;
+          }
+        }
+
+        if (has_unchecked_painting || has_mapped_painting ||
+            has_codomain_painting) {
+          draw_type = ItemDrawType::kOwl;
+
+          if (has_checked_painting) {
+            if (has_mapped_painting) {
+              shade_color = wxColour(0, 255, 0, 128);
+            } else {
+              shade_color = wxColour(255, 0, 0, 128);
+            }
+          }
+        }
+      } else if (!subway_item.tags.empty()) {
+        draw_type = ItemDrawType::kOwl;
+      }
+    } else if (subway_item.door) {
+      draw_type = ItemDrawType::kBox;
+
+      if (IsDoorOpen(*subway_item.door)) {
+        brush_color = wxGREEN_BRUSH;
+      } else {
+        brush_color = wxRED_BRUSH;
+      }
+    }
+
+    wxPoint real_area_pos = {subway_item.x, subway_item.y};
+
+    int real_area_size =
+        (draw_type == ItemDrawType::kOwl ? OWL_ACTUAL_SIZE : AREA_ACTUAL_SIZE);
+
+    if (draw_type == ItemDrawType::kBox) {
+      gcdc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 1));
+      gcdc.SetBrush(*brush_color);
+      gcdc.DrawRectangle(real_area_pos, {real_area_size, real_area_size});
+    } else if (draw_type == ItemDrawType::kOwl) {
+      wxBitmap owl_bitmap = wxBitmap(owl_image_.Scale(
+          real_area_size, real_area_size, wxIMAGE_QUALITY_BILINEAR));
+      gcdc.DrawBitmap(owl_bitmap, real_area_pos);
+
+      if (shade_color) {
+        gcdc.SetBrush(wxBrush(*shade_color));
+        gcdc.DrawRectangle(real_area_pos, {real_area_size, real_area_size});
+      }
+    }
+  }
+}
+
+void SubwayMap::SetUpHelpButton() {
+  help_button_->SetPosition({
+      GetSize().GetWidth() - help_button_->GetSize().GetWidth() - 15,
+      15,
+  });
+}
+
+void SubwayMap::EvaluateScroll(wxPoint pos) {
+  int scroll_x;
+  int scroll_y;
+  if (pos.x < GetSize().GetWidth() / 9) {
+    scroll_x = 20;
+  } else if (pos.x < GetSize().GetWidth() / 6) {
+    scroll_x = 5;
+  } else if (pos.x > 8 * GetSize().GetWidth() / 9) {
+    scroll_x = -20;
+  } else if (pos.x > 5 * GetSize().GetWidth() / 6) {
+    scroll_x = -5;
+  } else {
+    scroll_x = 0;
+  }
+  if (pos.y < GetSize().GetHeight() / 9) {
+    scroll_y = 20;
+  } else if (pos.y < GetSize().GetHeight() / 6) {
+    scroll_y = 5;
+  } else if (pos.y > 8 * GetSize().GetHeight() / 9) {
+    scroll_y = -20;
+  } else if (pos.y > 5 * GetSize().GetHeight() / 6) {
+    scroll_y = -5;
+  } else {
+    scroll_y = 0;
+  }
+
+  SetScrollSpeed(scroll_x, scroll_y);
+}
+
+wxPoint SubwayMap::MapPosToRenderPos(wxPoint pos) const {
+  return {static_cast<int>(pos.x * render_width_ * zoom_ /
+                               map_image_.GetSize().GetWidth() +
+                           zoom_x_),
+          static_cast<int>(pos.y * render_width_ * zoom_ /
+                               map_image_.GetSize().GetWidth() +
+                           zoom_y_)};
+}
+
+wxPoint SubwayMap::MapPosToVirtualPos(wxPoint pos) const {
+  return {static_cast<int>(pos.x * render_width_ * zoom_ /
+                           map_image_.GetSize().GetWidth()),
+          static_cast<int>(pos.y * render_width_ * zoom_ /
+                           map_image_.GetSize().GetWidth())};
+}
+
+wxPoint SubwayMap::RenderPosToMapPos(wxPoint pos) const {
+  return {
+      std::clamp(static_cast<int>((pos.x - zoom_x_) * map_image_.GetWidth() /
+                                  render_width_ / zoom_),
+                 0, map_image_.GetWidth() - 1),
+      std::clamp(static_cast<int>((pos.y - zoom_y_) * map_image_.GetWidth() /
+                                  render_width_ / zoom_),
+                 0, map_image_.GetHeight() - 1)};
+}
+
+void SubwayMap::SetZoomPos(wxPoint pos) {
+  if (render_width_ * zoom_ <= GetSize().GetWidth()) {
+    zoom_x_ = (GetSize().GetWidth() - render_width_ * zoom_) / 2;
+  } else {
+    zoom_x_ = std::clamp(
+        pos.x, GetSize().GetWidth() - static_cast<int>(render_width_ * zoom_),
+        0);
+  }
+  if (render_height_ * zoom_ <= GetSize().GetHeight()) {
+    zoom_y_ = (GetSize().GetHeight() - render_height_ * zoom_) / 2;
+  } else {
+    zoom_y_ = std::clamp(
+        pos.y, GetSize().GetHeight() - static_cast<int>(render_height_ * zoom_),
+        0);
+  }
+}
+
+void SubwayMap::SetScrollSpeed(int scroll_x, int scroll_y) {
+  bool should_timer = (scroll_x != 0 || scroll_y != 0);
+  if (should_timer != scroll_timer_->IsRunning()) {
+    if (should_timer) {
+      scroll_timer_->Start(1000 / 60);
+    } else {
+      scroll_timer_->Stop();
+    }
+  }
+
+  scroll_x_ = scroll_x;
+  scroll_y_ = scroll_y;
+}
+
+void SubwayMap::SetZoom(double zoom, wxPoint static_point) {
+  wxPoint map_pos = RenderPosToMapPos(static_point);
+  zoom_ = zoom;
+
+  wxPoint virtual_pos = MapPosToVirtualPos(map_pos);
+  SetZoomPos(-(virtual_pos - static_point));
+
+  Refresh();
+
+  zoom_slider_->SetValue((zoom - 1.0) / 0.25);
+}
+
+quadtree::Box<float> SubwayMap::GetItemBox::operator()(const int &id) const {
+  const SubwayItem &subway_item = GD_GetSubwayItem(id);
+  return {static_cast<float>(subway_item.x), static_cast<float>(subway_item.y),
+          AREA_ACTUAL_SIZE, AREA_ACTUAL_SIZE};
+}
@@ -0,0 +1,92 @@
+#ifndef SUBWAY_MAP_H_BD2D843E
+#define SUBWAY_MAP_H_BD2D843E
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <quadtree/Quadtree.h>
+
+#include "game_data.h"
+#include "network_set.h"
+
+class SubwayMap : public wxPanel {
+ public:
+  SubwayMap(wxWindow *parent);
+
+  void OnConnect();
+  void UpdateIndicators();
+  void UpdateSunwarp(SubwaySunwarp from_sunwarp, SubwaySunwarp to_sunwarp);
+  void Zoom(bool in);
+
+ private:
+  void OnPaint(wxPaintEvent &event);
+  void OnMouseMove(wxMouseEvent &event);
+  void OnMouseScroll(wxMouseEvent &event);
+  void OnMouseLeave(wxMouseEvent &event);
+  void OnMouseClick(wxMouseEvent &event);
+  void OnTimer(wxTimerEvent &event);
+  void OnZoomSlide(wxCommandEvent &event);
+  void OnClickHelp(wxCommandEvent &event);
+
+  void Redraw();
+  void SetUpHelpButton();
+
+  wxPoint MapPosToRenderPos(wxPoint pos) const;
+  wxPoint MapPosToVirtualPos(wxPoint pos) const;
+  wxPoint RenderPosToMapPos(wxPoint pos) const;
+
+  void EvaluateScroll(wxPoint pos);
+
+  void SetZoomPos(wxPoint pos);
+  void SetScrollSpeed(int scroll_x, int scroll_y);
+  void SetZoom(double zoom, wxPoint static_point);
+
+  wxImage map_image_;
+  wxImage owl_image_;
+  wxBitmap unchecked_eye_;
+  wxBitmap checked_eye_;
+
+  wxBitmap rendered_;
+  int render_x_ = 0;
+  int render_y_ = 0;
+  int render_width_ = 1;
+  int render_height_ = 1;
+
+  double zoom_ = 1.0;
+  int zoom_x_ = 0; // in render space
+  int zoom_y_ = 0;
+
+  bool scroll_mode_ = false;
+  wxTimer* scroll_timer_;
+  int scroll_x_ = 0;
+  int scroll_y_ = 0;
+
+  wxSlider *zoom_slider_;
+
+  wxButton *help_button_;
+
+  std::optional<wxPoint> mouse_position_;
+
+  struct GetItemBox {
+    quadtree::Box<float> operator()(const int &id) const;
+  };
+  
+  std::unique_ptr<quadtree::Quadtree<int, GetItemBox>> tree_;
+  std::optional<int> hovered_item_;
+  std::optional<int> actual_hover_;
+  bool sticky_hover_ = false;
+
+  NetworkSet networks_;
+  std::set<std::string> checked_paintings_;
+};
+
+#endif /* end of include guard: SUBWAY_MAP_H_BD2D843E */
@@ -1,6 +1,8 @@
 #include "tracker_frame.h"
 
+#include <wx/aboutdlg.h>
 #include <wx/choicebk.h>
+#include <wx/notebook.h>
 #include <wx/webrequest.h>
 
 #include <nlohmann/json.hpp>
@@ -10,6 +12,7 @@
 #include "ap_state.h"
 #include "connection_dialog.h"
 #include "settings_dialog.h"
+#include "subway_map.h"
 #include "tracker_config.h"
 #include "tracker_panel.h"
 #include "version.h"
@@ -17,9 +20,12 @@
 enum TrackerFrameIds {
   ID_CONNECT = 1,
   ID_CHECK_FOR_UPDATES = 2,
-  ID_SETTINGS = 3
+  ID_SETTINGS = 3,
+  ID_ZOOM_IN = 4,
+  ID_ZOOM_OUT = 5,
 };
 
+wxDEFINE_EVENT(STATE_RESET, wxCommandEvent);
 wxDEFINE_EVENT(STATE_CHANGED, wxCommandEvent);
 wxDEFINE_EVENT(STATUS_CHANGED, wxCommandEvent);
 
@@ -35,12 +41,20 @@ TrackerFrame::TrackerFrame()
   menuFile->Append(ID_SETTINGS, "&Settings");
   menuFile->Append(wxID_EXIT);
 
+  wxMenu *menuView = new wxMenu();
+  zoom_in_menu_item_ = menuView->Append(ID_ZOOM_IN, "Zoom In\tCtrl-+");
+  zoom_out_menu_item_ = menuView->Append(ID_ZOOM_OUT, "Zoom Out\tCtrl--");
+
+  zoom_in_menu_item_->Enable(false);
+  zoom_out_menu_item_->Enable(false);
+
   wxMenu *menuHelp = new wxMenu();
   menuHelp->Append(wxID_ABOUT);
   menuHelp->Append(ID_CHECK_FOR_UPDATES, "Check for Updates");
 
   wxMenuBar *menuBar = new wxMenuBar();
   menuBar->Append(menuFile, "&File");
+  menuBar->Append(menuView, "&View");
   menuBar->Append(menuHelp, "&Help");
 
   SetMenuBar(menuBar);
@@ -54,18 +68,26 @@ TrackerFrame::TrackerFrame()
   Bind(wxEVT_MENU, &TrackerFrame::OnSettings, this, ID_SETTINGS);
   Bind(wxEVT_MENU, &TrackerFrame::OnCheckForUpdates, this,
        ID_CHECK_FOR_UPDATES);
+  Bind(wxEVT_MENU, &TrackerFrame::OnZoomIn, this, ID_ZOOM_IN);
+  Bind(wxEVT_MENU, &TrackerFrame::OnZoomOut, this, ID_ZOOM_OUT);
+  Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, &TrackerFrame::OnChangePage, this);
+  Bind(STATE_RESET, &TrackerFrame::OnStateReset, this);
   Bind(STATE_CHANGED, &TrackerFrame::OnStateChanged, this);
   Bind(STATUS_CHANGED, &TrackerFrame::OnStatusChanged, this);
 
   wxChoicebook *choicebook = new wxChoicebook(this, wxID_ANY);
-  achievements_pane_ = new AchievementsPane(this);
+  achievements_pane_ = new AchievementsPane(choicebook);
   choicebook->AddPage(achievements_pane_, "Achievements");
 
-  tracker_panel_ = new TrackerPanel(this);
+  notebook_ = new wxNotebook(this, wxID_ANY);
+  tracker_panel_ = new TrackerPanel(notebook_);
+  subway_map_ = new SubwayMap(notebook_);
+  notebook_->AddPage(tracker_panel_, "Map");
+  notebook_->AddPage(subway_map_, "Subway");
 
   wxBoxSizer *top_sizer = new wxBoxSizer(wxHORIZONTAL);
   top_sizer->Add(choicebook, wxSizerFlags().Expand().Proportion(1));
-  top_sizer->Add(tracker_panel_, wxSizerFlags().Expand().Proportion(3));
+  top_sizer->Add(notebook_, wxSizerFlags().Expand().Proportion(3));
 
   SetSizerAndFit(top_sizer);
   SetSize(1280, 728);
@@ -96,17 +118,23 @@ void TrackerFrame::SetStatusMessage(std::string message) {
   QueueEvent(event);
 }
 
+void TrackerFrame::ResetIndicators() {
+  QueueEvent(new wxCommandEvent(STATE_RESET));
+}
+
 void TrackerFrame::UpdateIndicators() {
   QueueEvent(new wxCommandEvent(STATE_CHANGED));
 }
 
 void TrackerFrame::OnAbout(wxCommandEvent &event) {
-  std::ostringstream message_text;
-  message_text << "Lingo Archipelago Tracker " << kTrackerVersion
-               << " by hatkirby";
-
-  wxMessageBox(message_text.str(), "About lingo-ap-tracker",
-               wxOK | wxICON_INFORMATION);
+  wxAboutDialogInfo about_info;
+  about_info.SetName("Lingo Archipelago Tracker");
+  about_info.SetVersion(kTrackerVersion.ToString());
+  about_info.AddDeveloper("hatkirby");
+  about_info.AddArtist("Brenton Wildes");
+  about_info.AddArtist("kinrah");
+
+  wxAboutBox(about_info);
 }
 
 void TrackerFrame::OnExit(wxCommandEvent &event) { Close(true); }
@@ -122,7 +150,8 @@ void TrackerFrame::OnConnect(wxCommandEvent &event) {
     std::deque<ConnectionDetails> new_history;
     new_history.push_back(GetTrackerConfig().connection_details);
 
-    for (const ConnectionDetails& details : GetTrackerConfig().connection_history) {
+    for (const ConnectionDetails &details :
+         GetTrackerConfig().connection_history) {
       if (details != GetTrackerConfig().connection_details) {
         new_history.push_back(details);
       }
@@ -158,9 +187,34 @@ void TrackerFrame::OnCheckForUpdates(wxCommandEvent &event) {
   CheckForUpdates(/*manual=*/true);
 }
 
+void TrackerFrame::OnZoomIn(wxCommandEvent &event) {
+  if (notebook_->GetSelection() == 1) {
+    subway_map_->Zoom(true);
+  }
+}
+
+void TrackerFrame::OnZoomOut(wxCommandEvent& event) {
+  if (notebook_->GetSelection() == 1) {
+    subway_map_->Zoom(false);
+  }
+}
+
+void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
+  zoom_in_menu_item_->Enable(event.GetSelection() == 1);
+  zoom_out_menu_item_->Enable(event.GetSelection() == 1);
+}
+
+void TrackerFrame::OnStateReset(wxCommandEvent& event) {
+  tracker_panel_->UpdateIndicators();
+  achievements_pane_->UpdateIndicators();
+  subway_map_->OnConnect();
+  Refresh();
+}
+
 void TrackerFrame::OnStateChanged(wxCommandEvent &event) {
   tracker_panel_->UpdateIndicators();
   achievements_pane_->UpdateIndicators();
+  subway_map_->UpdateIndicators();
   Refresh();
 }
 
@@ -192,8 +246,10 @@ void TrackerFrame::CheckForUpdates(bool manual) {
         std::ostringstream message_text;
         message_text << "There is a newer version of Lingo AP Tracker "
                         "available. You have "
-                     << kTrackerVersion << ", and the latest version is "
-                     << latest_version << ". Would you like to update?";
+                     << kTrackerVersion.ToString()
+                     << ", and the latest version is "
+                     << latest_version.ToString()
+                     << ". Would you like to update?";
 
         if (wxMessageBox(message_text.str(), "Update available", wxYES_NO) ==
             wxYES) {
@@ -8,8 +8,12 @@
 #endif
 
 class AchievementsPane;
+class SubwayMap;
 class TrackerPanel;
+class wxBookCtrlEvent;
+class wxNotebook;
 
+wxDECLARE_EVENT(STATE_RESET, wxCommandEvent);
 wxDECLARE_EVENT(STATE_CHANGED, wxCommandEvent);
 wxDECLARE_EVENT(STATUS_CHANGED, wxCommandEvent);
 
@@ -19,6 +23,7 @@ class TrackerFrame : public wxFrame {
 
   void SetStatusMessage(std::string message);
 
+  void ResetIndicators();
   void UpdateIndicators();
 
  private:
@@ -27,14 +32,23 @@ class TrackerFrame : public wxFrame {
   void OnConnect(wxCommandEvent &event);
   void OnSettings(wxCommandEvent &event);
   void OnCheckForUpdates(wxCommandEvent &event);
+  void OnZoomIn(wxCommandEvent &event);
+  void OnZoomOut(wxCommandEvent &event);
+  void OnChangePage(wxBookCtrlEvent &event);
 
+  void OnStateReset(wxCommandEvent &event);
   void OnStateChanged(wxCommandEvent &event);
   void OnStatusChanged(wxCommandEvent &event);
 
   void CheckForUpdates(bool manual);
 
+  wxNotebook *notebook_;
   TrackerPanel *tracker_panel_;
   AchievementsPane *achievements_pane_;
+  SubwayMap *subway_map_;
+
+  wxMenuItem *zoom_in_menu_item_;
+  wxMenuItem *zoom_out_menu_item_;
 };
 
 #endif /* end of include guard: TRACKER_FRAME_H_86BD8DFB */
@@ -1,5 +1,7 @@
 #include "tracker_panel.h"
 
+#include <wx/dcbuffer.h>
+
 #include "ap_state.h"
 #include "area_popup.h"
 #include "game_data.h"
@@ -13,6 +15,8 @@ constexpr int AREA_EFFECTIVE_SIZE = AREA_ACTUAL_SIZE + AREA_BORDER_SIZE * 2;
 constexpr int PLAYER_SIZE = 96;
 
 TrackerPanel::TrackerPanel(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
   map_image_ = wxImage(GetAbsolutePath("assets/lingo_map.png").c_str(),
                        wxBITMAP_TYPE_PNG);
   if (!map_image_.IsOk()) {
@@ -54,7 +58,7 @@ void TrackerPanel::OnPaint(wxPaintEvent &event) {
     Redraw();
   }
 
-  wxPaintDC dc(this);
+  wxBufferedPaintDC dc(this);
   dc.DrawBitmap(rendered_, 0, 0);
 
   if (AP_GetPlayerPosition().has_value()) {
@@ -139,7 +143,8 @@ void TrackerPanel::Redraw() {
   for (AreaIndicator &area : areas_) {
     const MapArea &map_area = GD_GetMapArea(area.area_id);
     if (!AP_IsLocationVisible(map_area.classification) &&
-        !(map_area.hunt && GetTrackerConfig().show_hunt_panels)) {
+        !(map_area.hunt && GetTrackerConfig().show_hunt_panels) &&
+        !(AP_IsPaintingShuffle() && !map_area.paintings.empty())) {
       area.active = false;
       continue;
     } else {
@@ -167,6 +172,21 @@ void TrackerPanel::Redraw() {
       }
     }
 
+    if (AP_IsPaintingShuffle()) {
+      for (int painting_id : map_area.paintings) {
+        const PaintingExit &painting = GD_GetPaintingExit(painting_id);
+        if (!AP_IsPaintingChecked(painting.internal_id)) {
+          bool reachable = IsPaintingReachable(painting_id);
+
+          if (reachable) {
+            has_reachable_unchecked = true;
+          } else {
+            has_unreachable_unchecked = true;
+          }
+        }
+      }
+    }
+
     int real_area_x = final_x + (map_area.map_x - (AREA_EFFECTIVE_SIZE / 2)) *
                                     final_width / image_size.GetWidth();
     int real_area_y = final_y + (map_area.map_y - (AREA_EFFECTIVE_SIZE / 2)) *
@@ -12,9 +12,142 @@
 
 namespace {
 
+struct Requirements {
+  bool disabled = false;
+
+  std::set<int> doors;      // non-grouped, handles progressive
+  std::set<int> items;      // all other items
+  std::set<int> rooms;      // maybe
+  bool mastery = false;     // maybe
+  bool panel_hunt = false;  // maybe
+
+  void Merge(const Requirements& rhs) {
+    if (rhs.disabled) {
+      return;
+    }
+
+    for (int id : rhs.doors) {
+      doors.insert(id);
+    }
+    for (int id : rhs.items) {
+      items.insert(id);
+    }
+    for (int id : rhs.rooms) {
+      rooms.insert(id);
+    }
+    mastery = mastery || rhs.mastery;
+    panel_hunt = panel_hunt || rhs.panel_hunt;
+  }
+};
+
+class RequirementCalculator {
+ public:
+  void Reset() {
+    doors_.clear();
+    panels_.clear();
+  }
+
+  const Requirements& GetDoor(int door_id) {
+    if (!doors_.count(door_id)) {
+      Requirements requirements;
+      const Door& door_obj = GD_GetDoor(door_id);
+
+      if (door_obj.type == DoorType::kSunPainting) {
+        if (!AP_IsPilgrimageEnabled()) {
+          requirements.items.insert(door_obj.ap_item_id);
+        } else {
+          requirements.disabled = true;
+        }
+      } else if (door_obj.type == DoorType::kSunwarp) {
+        switch (AP_GetSunwarpAccess()) {
+          case kSUNWARP_ACCESS_NORMAL:
+            // Do nothing.
+            break;
+          case kSUNWARP_ACCESS_DISABLED:
+            requirements.disabled = true;
+            break;
+          case kSUNWARP_ACCESS_UNLOCK:
+            requirements.items.insert(door_obj.group_ap_item_id);
+            break;
+          case kSUNWARP_ACCESS_INDIVIDUAL:
+          case kSUNWARP_ACCESS_PROGRESSIVE:
+            requirements.doors.insert(door_obj.id);
+            break;
+        }
+      } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
+        requirements.rooms.insert(door_obj.room);
+
+        for (int panel_id : door_obj.panels) {
+          const Requirements& panel_reqs = GetPanel(panel_id);
+          requirements.Merge(panel_reqs);
+        }
+      } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
+                 !door_obj.group_name.empty()) {
+        requirements.items.insert(door_obj.group_ap_item_id);
+      } else {
+        requirements.doors.insert(door_obj.id);
+      }
+
+      doors_[door_id] = requirements;
+    }
+
+    return doors_[door_id];
+  }
+
+  const Requirements& GetPanel(int panel_id) {
+    if (!panels_.count(panel_id)) {
+      Requirements requirements;
+      const Panel& panel_obj = GD_GetPanel(panel_id);
+
+      requirements.rooms.insert(panel_obj.room);
+
+      if (panel_obj.name == "THE MASTER") {
+        requirements.mastery = true;
+      }
+
+      if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
+          AP_GetLevel2Requirement() > 1) {
+        requirements.panel_hunt = true;
+      }
+
+      for (int room_id : panel_obj.required_rooms) {
+        requirements.rooms.insert(room_id);
+      }
+
+      for (int door_id : panel_obj.required_doors) {
+        const Requirements& door_reqs = GetDoor(door_id);
+        requirements.Merge(door_reqs);
+      }
+
+      for (int panel_id : panel_obj.required_panels) {
+        const Requirements& panel_reqs = GetPanel(panel_id);
+        requirements.Merge(panel_reqs);
+      }
+
+      if (AP_IsColorShuffle()) {
+        for (LingoColor color : panel_obj.colors) {
+          requirements.items.insert(GD_GetItemIdForColor(color));
+        }
+      }
+
+      panels_[panel_id] = requirements;
+    }
+
+    return panels_[panel_id];
+  }
+
+ private:
+  std::map<int, Requirements> doors_;
+  std::map<int, Requirements> panels_;
+};
+
 struct TrackerState {
   std::map<int, bool> reachability;
+  std::set<int> reachable_doors;
+  std::set<int> reachable_paintings;
   std::mutex reachability_mutex;
+  RequirementCalculator requirements;
+  std::map<int, std::map<std::string, bool>> door_reports;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -41,6 +174,7 @@ class StateCalculator {
 
   void Calculate() {
     std::list<int> panel_boundary;
+    std::list<int> painting_boundary;
     std::list<Exit> flood_boundary;
     flood_boundary.push_back({.destination_room = options_.start});
 
@@ -48,6 +182,8 @@ class StateCalculator {
     while (reachable_changed) {
       reachable_changed = false;
 
+      std::list<Exit> new_boundary;
+
       std::list<int> new_panel_boundary;
       for (int panel_id : panel_boundary) {
         if (solveable_panels_.count(panel_id)) {
@@ -63,7 +199,33 @@ class StateCalculator {
         }
       }
 
-      std::list<Exit> new_boundary;
+      std::list<int> new_painting_boundary;
+      for (int painting_id : painting_boundary) {
+        if (reachable_paintings_.count(painting_id)) {
+          continue;
+        }
+
+        Decision painting_reachable = IsPaintingReachable(painting_id);
+        if (painting_reachable == kYes) {
+          reachable_paintings_.insert(painting_id);
+          reachable_changed = true;
+
+          PaintingExit cur_painting = GD_GetPaintingExit(painting_id);
+          if (AP_GetPaintingMapping().count(cur_painting.internal_id) &&
+              AP_GetCheckedPaintings().count(cur_painting.internal_id)) {
+            Exit painting_exit;
+            PaintingExit target_painting =
+                GD_GetPaintingExit(GD_GetPaintingByName(
+                    AP_GetPaintingMapping().at(cur_painting.internal_id)));
+            painting_exit.destination_room = target_painting.room;
+
+            new_boundary.push_back(painting_exit);
+          }
+        } else if (painting_reachable == kMaybe) {
+          new_painting_boundary.push_back(painting_id);
+        }
+      }
+
       for (const Exit& room_exit : flood_boundary) {
         if (reachable_rooms_.count(room_exit.destination_room)) {
           continue;
@@ -98,15 +260,8 @@ class StateCalculator {
           }
 
           if (AP_IsPaintingShuffle()) {
-            for (const PaintingExit& out_edge : room_obj.paintings) {
-              if (AP_GetPaintingMapping().count(out_edge.id)) {
-                Exit painting_exit;
-                painting_exit.destination_room = GD_GetRoomForPainting(
-                    AP_GetPaintingMapping().at(out_edge.id));
-                painting_exit.door = out_edge.door;
-
-                new_boundary.push_back(painting_exit);
-              }
+            for (int out_edge : room_obj.paintings) {
+              new_painting_boundary.push_back(out_edge);
             }
           }
 
@@ -155,6 +310,13 @@ class StateCalculator {
 
       flood_boundary = new_boundary;
       panel_boundary = new_panel_boundary;
+      painting_boundary = new_painting_boundary;
+    }
+
+    // Now that we know the full reachable area, let's make sure all doors are
+    // evaluated.
+    for (const Door& door : GD_GetDoors()) {
+      int discard = IsDoorReachable(door.id);
     }
   }
 
@@ -166,6 +328,14 @@ class StateCalculator {
 
   const std::set<int>& GetSolveablePanels() const { return solveable_panels_; }
 
+  const std::set<int>& GetReachablePaintings() const {
+    return reachable_paintings_;
+  }
+
+  const std::map<int, std::map<std::string, bool>>& GetDoorReports() const {
+    return door_report_;
+  }
+
  private:
   Decision IsNonGroupedDoorReachable(const Door& door_obj) {
     bool has_item = AP_HasItem(door_obj.ap_item_id);
@@ -182,68 +352,52 @@ class StateCalculator {
     return has_item ? kYes : kNo;
   }
 
-  Decision IsDoorReachable_Helper(int door_id) {
-    const Door& door_obj = GD_GetDoor(door_id);
-
-    if (!AP_IsPilgrimageEnabled() && door_obj.type == DoorType::kSunPainting) {
-      return AP_HasItem(door_obj.ap_item_id) ? kYes : kNo;
-    } else if (door_obj.type == DoorType::kSunwarp) {
-      switch (AP_GetSunwarpAccess()) {
-        case kSUNWARP_ACCESS_NORMAL:
-          return kYes;
-        case kSUNWARP_ACCESS_DISABLED:
-          return kNo;
-        case kSUNWARP_ACCESS_UNLOCK:
-          return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
-        case kSUNWARP_ACCESS_INDIVIDUAL:
-        case kSUNWARP_ACCESS_PROGRESSIVE:
-          return IsNonGroupedDoorReachable(door_obj);
-      }
-    } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
-      if (!reachable_rooms_.count(door_obj.room)) {
-        return kMaybe;
-      }
-
-      for (int panel_id : door_obj.panels) {
-        if (!solveable_panels_.count(panel_id)) {
-          return kMaybe;
-        }
-      }
-
-      return kYes;
-    } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
-               !door_obj.group_name.empty()) {
-      return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
-    } else {
-      return IsNonGroupedDoorReachable(door_obj);
+  Decision AreRequirementsSatisfied(
+      const Requirements& reqs, std::map<std::string, bool>* report = nullptr) {
+    if (reqs.disabled) {
+      return kNo;
     }
-  }
 
-  Decision IsDoorReachable(int door_id) {
-    if (options_.parent) {
-      return options_.parent->IsDoorReachable(door_id);
-    }
+    Decision final_decision = kYes;
 
-    if (door_decisions_.count(door_id)) {
-      return door_decisions_.at(door_id);
+    for (int door_id : reqs.doors) {
+      const Door& door_obj = GD_GetDoor(door_id);
+      Decision decision = IsNonGroupedDoorReachable(door_obj);
+
+      if (report) {
+        (*report)[door_obj.item_name] = (decision == kYes);
+      }
+
+      if (decision != kYes) {
+        final_decision = decision;
+      }
     }
 
-    Decision result = IsDoorReachable_Helper(door_id);
-    if (result != kMaybe) {
-      door_decisions_[door_id] = result;
+    for (int item_id : reqs.items) {
+      bool has_item = AP_HasItem(item_id);
+      if (report) {
+        (*report)[AP_GetItemName(item_id)] = has_item;
+      }
+
+      if (!has_item) {
+        final_decision = kNo;
+      }
     }
 
-    return result;
-  }
+    for (int room_id : reqs.rooms) {
+      bool reachable = reachable_rooms_.count(room_id);
 
-  Decision IsPanelReachable(int panel_id) {
-    const Panel& panel_obj = GD_GetPanel(panel_id);
+      if (report) {
+        std::string report_name = "Reach \"" + GD_GetRoom(room_id).name + "\"";
+        (*report)[report_name] = reachable;
+      }
 
-    if (!reachable_rooms_.count(panel_obj.room)) {
-      return kMaybe;
+      if (!reachable && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    if (panel_obj.name == "THE MASTER") {
+    if (reqs.mastery) {
       int achievements_accessible = 0;
 
       for (int achieve_id : GD_GetAchievementPanels()) {
@@ -256,12 +410,18 @@ class StateCalculator {
         }
       }
 
-      return (achievements_accessible >= AP_GetMasteryRequirement()) ? kYes
-                                                                     : kMaybe;
+      bool can_mastery =
+          (achievements_accessible >= AP_GetMasteryRequirement());
+      if (report) {
+        (*report)["Mastery"] = can_mastery;
+      }
+
+      if (!can_mastery && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
-        AP_GetLevel2Requirement() > 1) {
+    if (reqs.panel_hunt) {
       int counting_panels_accessible = 0;
 
       for (int solved_panel_id : solveable_panels_) {
@@ -272,41 +432,58 @@ class StateCalculator {
         }
       }
 
-      return (counting_panels_accessible >= AP_GetLevel2Requirement() - 1)
-                 ? kYes
-                 : kMaybe;
-    }
+      bool can_level2 =
+          (counting_panels_accessible >= AP_GetLevel2Requirement() - 1);
+      if (report) {
+        std::string report_name =
+            std::to_string(AP_GetLevel2Requirement()) + " Panels";
+        (*report)[report_name] = can_level2;
+      }
 
-    for (int room_id : panel_obj.required_rooms) {
-      if (!reachable_rooms_.count(room_id)) {
-        return kMaybe;
+      if (!can_level2 && final_decision != kNo) {
+        final_decision = kMaybe;
       }
     }
 
-    for (int door_id : panel_obj.required_doors) {
-      Decision door_reachable = IsDoorReachable(door_id);
-      if (door_reachable == kNo) {
-        const Door& door_obj = GD_GetDoor(door_id);
-        return (door_obj.is_event || AP_GetDoorShuffleMode() == kNO_DOORS)
-                   ? kMaybe
-                   : kNo;
-      } else if (door_reachable == kMaybe) {
-        return kMaybe;
-      }
+    return final_decision;
+  }
+
+  Decision IsDoorReachable_Helper(int door_id) {
+    if (door_report_.count(door_id)) {
+      door_report_[door_id].clear();
+    } else {
+      door_report_[door_id] = {};
     }
 
-    for (int panel_id : panel_obj.required_panels) {
-      if (!solveable_panels_.count(panel_id)) {
-        return kMaybe;
-      }
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id),
+                                    &door_report_[door_id]);
+  }
+
+  Decision IsDoorReachable(int door_id) {
+    if (options_.parent) {
+      return options_.parent->IsDoorReachable(door_id);
     }
 
-    if (AP_IsColorShuffle()) {
-      for (LingoColor color : panel_obj.colors) {
-        if (!AP_HasItem(GD_GetItemIdForColor(color))) {
-          return kNo;
-        }
-      }
+    if (door_decisions_.count(door_id)) {
+      return door_decisions_.at(door_id);
+    }
+
+    Decision result = IsDoorReachable_Helper(door_id);
+    if (result != kMaybe) {
+      door_decisions_[door_id] = result;
+    }
+
+    return result;
+  }
+
+  Decision IsPanelReachable(int panel_id) {
+    return AreRequirementsSatisfied(GetState().requirements.GetPanel(panel_id));
+  }
+
+  Decision IsPaintingReachable(int painting_id) {
+    const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+    if (painting.door) {
+      return IsDoorReachable(*painting.door);
     }
 
     return kYes;
@@ -395,11 +572,20 @@ class StateCalculator {
   std::set<int> reachable_rooms_;
   std::map<int, Decision> door_decisions_;
   std::set<int> solveable_panels_;
+  std::set<int> reachable_paintings_;
+  std::map<int, std::map<std::string, bool>> door_report_;
 };
 
 }  // namespace
 
+void ResetReachabilityRequirements() {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+  GetState().requirements.Reset();
+}
+
 void RecalculateReachability() {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
   state_calculator.Calculate();
 
@@ -422,10 +608,21 @@ void RecalculateReachability() {
     }
   }
 
-  {
-    std::lock_guard reachability_guard(GetState().reachability_mutex);
-    std::swap(GetState().reachability, new_reachability);
+  std::set<int> new_reachable_doors;
+  for (const auto& [door_id, decision] : state_calculator.GetDoorDecisions()) {
+    if (decision == kYes) {
+      new_reachable_doors.insert(door_id);
+    }
   }
+
+  std::set<int> reachable_paintings = state_calculator.GetReachablePaintings();
+  std::map<int, std::map<std::string, bool>> door_reports =
+      state_calculator.GetDoorReports();
+  
+  std::swap(GetState().reachability, new_reachability);
+  std::swap(GetState().reachable_doors, new_reachable_doors);
+  std::swap(GetState().reachable_paintings, reachable_paintings);
+  std::swap(GetState().door_reports, door_reports);
 }
 
 bool IsLocationReachable(int location_id) {
@@ -437,3 +634,21 @@ bool IsLocationReachable(int location_id) {
     return false;
   }
 }
+
+bool IsDoorOpen(int door_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().reachable_doors.count(door_id);
+}
+
+bool IsPaintingReachable(int painting_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().reachable_paintings.count(painting_id);
+}
+
+const std::map<std::string, bool>& GetDoorRequirements(int door_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().door_reports[door_id];
+}
@@ -1,8 +1,19 @@
 #ifndef TRACKER_STATE_H_8639BC90
 #define TRACKER_STATE_H_8639BC90
 
+#include <map>
+#include <string>
+
+void ResetReachabilityRequirements();
+
 void RecalculateReachability();
 
 bool IsLocationReachable(int location_id);
 
+bool IsDoorOpen(int door_id);
+
+bool IsPaintingReachable(int painting_id);
+
+const std::map<std::string, bool>& GetDoorRequirements(int door_id);
+
 #endif /* end of include guard: TRACKER_STATE_H_8639BC90 */
@@ -1,9 +1,10 @@
 #ifndef VERSION_H_C757E53C
 #define VERSION_H_C757E53C
 
-#include <iostream>
 #include <regex>
 
+#include <fmt/core.h>
+
 struct Version {
   int major = 0;
   int minor = 0;
@@ -23,6 +24,10 @@ struct Version {
     }
   }
 
+  std::string ToString() const {
+    return fmt::format("v{}.{}.{}", major, minor, revision);
+  }
+
   bool operator<(const Version& rhs) const {
     return (major < rhs.major) ||
            (major == rhs.major &&
@@ -31,10 +36,6 @@ struct Version {
   }
 };
 
-std::ostream& operator<<(std::ostream& out, const Version& ver) {
-  return out << "v" << ver.major << "." << ver.minor << "." << ver.revision;
-}
-
-constexpr const Version kTrackerVersion = Version(0, 9, 1);
+constexpr const Version kTrackerVersion = Version(0, 10, 3);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file