49 files changed, 2256 insertions, 880 deletions

@@ -8,23 +8,24 @@ AchievementsPane::AchievementsPane(wxWindow* parent)
   AppendColumn("Achievement");
 
   for (int panel_id : GD_GetAchievementPanels()) {
-    achievement_names_.push_back(GD_GetPanel(panel_id).achievement_name);
+    const Panel& panel = GD_GetPanel(panel_id);
+    achievements_.emplace_back(panel.achievement_name, panel.solve_index);
   }
 
-  std::sort(std::begin(achievement_names_), std::end(achievement_names_));
+  std::sort(std::begin(achievements_), std::end(achievements_));
 
-  for (int i = 0; i < achievement_names_.size(); i++) {
-    InsertItem(i, achievement_names_.at(i));
+  for (int i = 0; i < achievements_.size(); i++) {
+    InsertItem(i, std::get<0>(achievements_.at(i)));
   }
 
-  SetColumnWidth(0, wxLIST_AUTOSIZE);
+  SetColumnWidth(0, wxLIST_AUTOSIZE_USEHEADER);
 
   UpdateIndicators();
 }
 
 void AchievementsPane::UpdateIndicators() {
-  for (int i = 0; i < achievement_names_.size(); i++) {
-    if (AP_HasAchievement(achievement_names_.at(i))) {
+  for (int i = 0; i < achievements_.size(); i++) {
+    if (AP_IsPanelSolved(std::get<1>(achievements_.at(i)))) {
       SetItemTextColour(i, *wxBLACK);
     } else {
       SetItemTextColour(i, *wxRED);
@@ -9,6 +9,10 @@
 
 #include <wx/listctrl.h>
 
+#include <string>
+#include <tuple>
+#include <vector>
+
 class AchievementsPane : public wxListView {
  public:
   explicit AchievementsPane(wxWindow* parent);
@@ -16,7 +20,7 @@ class AchievementsPane : public wxListView {
   void UpdateIndicators();
 
  private:
-  std::vector<std::string> achievement_names_;
+  std::vector<std::tuple<std::string, int>> achievements_; // name, solve index
 };
 
 #endif /* end of include guard: ACHIEVEMENTS_PANE_H_C320D0B8 */
\ No newline at end of file
@@ -10,6 +10,7 @@
 #include <any>
 #include <apclient.hpp>
 #include <apuuid.hpp>
+#include <bitset>
 #include <chrono>
 #include <exception>
 #include <filesystem>
@@ -28,8 +29,8 @@
 #include "tracker_state.h"
 
 constexpr int AP_MAJOR = 0;
-constexpr int AP_MINOR = 4;
-constexpr int AP_REVISION = 5;
+constexpr int AP_MINOR = 6;
+constexpr int AP_REVISION = 1;
 
 constexpr const char* CERT_STORE_PATH = "cacert.pem";
 constexpr int ITEM_HANDLING = 7;  // <- all
@@ -37,8 +38,24 @@ constexpr int ITEM_HANDLING = 7;  // <- all
 constexpr int CONNECTION_TIMEOUT = 50000;  // 50 seconds
 constexpr int CONNECTION_BACKOFF_INTERVAL = 100;
 
+constexpr int PANEL_COUNT = 803;
+constexpr int PANEL_BITFIELD_LENGTH = 48;
+constexpr int PANEL_BITFIELDS = 17;
+
 namespace {
 
+const std::set<long> kNonProgressionItems = {
+    444409,  // :)
+    444575,  // The Feeling of Being Lost
+    444576,  // Wanderlust
+    444577,  // Empty White Hallways
+    444410,  // Slowness Trap
+    444411,  // Iceland Trap
+    444412,  // Atbash Trap
+    444413,  // Puzzle Skip
+    444680,  // Speed Boost
+};
+
 struct APState {
   // Initialized on main thread
   bool initialized = false;
@@ -67,10 +84,12 @@ struct APState {
   std::set<int64_t> checked_locations;
   std::map<std::string, std::any> data_storage;
   std::optional<std::tuple<int, int>> player_pos;
+  std::bitset<PANEL_COUNT> solved_panels;
 
   DoorShuffleMode door_shuffle_mode = kNO_DOORS;
   bool group_doors = false;
   bool color_shuffle = false;
+  PanelShuffleMode panel_shuffle_mode = kNO_PANELS;
   bool painting_shuffle = false;
   int mastery_requirement = 21;
   int level_2_requirement = 223;
@@ -82,6 +101,7 @@ struct APState {
   bool pilgrimage_allows_paintings = false;
   SunwarpAccess sunwarp_access = kSUNWARP_ACCESS_NORMAL;
   bool sunwarp_shuffle = false;
+  bool postgame_shuffle = true;
 
   std::map<std::string, std::string> painting_mapping;
   std::set<std::string> painting_codomain;
@@ -128,10 +148,12 @@ struct APState {
         checked_locations.clear();
         data_storage.clear();
         player_pos = std::nullopt;
+        solved_panels.reset();
         victory_data_storage_key.clear();
         door_shuffle_mode = kNO_DOORS;
         group_doors = false;
         color_shuffle = false;
+        panel_shuffle_mode = kNO_PANELS;
         painting_shuffle = false;
         painting_mapping.clear();
         painting_codomain.clear();
@@ -146,6 +168,7 @@ struct APState {
         sunwarp_access = kSUNWARP_ACCESS_NORMAL;
         sunwarp_shuffle = false;
         sunwarp_mapping.clear();
+        postgame_shuffle = true;
       }
 
       apclient->set_room_info_handler(
@@ -200,24 +223,13 @@ struct APState {
     return checked_locations.count(location_id);
   }
 
-  bool HasCheckedHuntPanel(int location_id) {
-    std::lock_guard state_guard(state_mutex);
-
-    std::string key =
-        fmt::format("{}Hunt|{}", data_storage_prefix, location_id);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
-  }
-
   bool HasItem(int item_id, int quantity) {
     return inventory.count(item_id) && inventory.at(item_id) >= quantity;
   }
 
-  bool HasAchievement(const std::string& name) {
+  bool HasItemSafe(int item_id, int quantity) {
     std::lock_guard state_guard(state_mutex);
-
-    std::string key =
-        fmt::format("{}Achievement|{}", data_storage_prefix, name);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
+    return HasItem(item_id, quantity);
   }
 
   const std::set<std::string>& GetCheckedPaintings() {
@@ -241,7 +253,21 @@ struct APState {
             checked_paintings.count(painting_mapping.at(painting_id)));
   }
 
-  std::string GetItemName(int id) { return apclient->get_item_name(id); }
+  void RevealPaintings() {
+    std::lock_guard state_guard(state_mutex);
+
+    std::vector<std::string> paintings;
+    for (const PaintingExit& painting : GD_GetPaintings()) {
+      paintings.push_back(painting.internal_id);
+    }
+
+    APClient::DataStorageOperation operation;
+    operation.operation = "replace";
+    operation.value = paintings;
+
+    apclient->Set(fmt::format("{}Paintings", data_storage_prefix), "", true,
+                  {operation});
+  }
 
   bool HasReachedGoal() {
     std::lock_guard state_guard(state_mutex);
@@ -251,6 +277,12 @@ struct APState {
                30;  // CLIENT_GOAL
   }
 
+  bool IsPanelSolved(int solve_index) {
+    std::lock_guard state_guard(state_mutex);
+
+    return solved_panels.test(solve_index);
+  }
+
  private:
   void Initialize() {
     if (!initialized) {
@@ -258,16 +290,8 @@ struct APState {
 
       std::thread([this]() { Thread(); }).detach();
 
-      for (int panel_id : GD_GetAchievementPanels()) {
-        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(
-              fmt::format("Hunt|{}", location.ap_location_id));
-        }
+      for (int i = 0; i < PANEL_BITFIELDS; i++) {
+        tracked_data_storage_keys.push_back(fmt::format("Panels_{}", i));
       }
 
       tracked_data_storage_keys.push_back("PlayerPos");
@@ -351,7 +375,7 @@ struct APState {
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(StateUpdate{.cleared_locations = true});
   }
 
   void OnSlotDisconnected() {
@@ -373,37 +397,59 @@ struct APState {
   }
 
   void OnItemsReceived(const std::list<APClient::NetworkItem>& items) {
+    std::vector<ItemState> item_states;
+    bool progression_items = false;
+
     {
       std::lock_guard state_guard(state_mutex);
 
+      std::map<int64_t, int> index_by_item;
+
       for (const APClient::NetworkItem& item : items) {
         inventory[item.item]++;
         TrackerLog(fmt::format("Item: {}", item.item));
+
+        index_by_item[item.item] = item.index;
+
+        if (!kNonProgressionItems.count(item.item)) {
+          progression_items = true;
+        }
+      }
+
+      for (const auto& [item_id, item_index] : index_by_item) {
+        item_states.push_back(ItemState{.name = GD_GetItemName(item_id),
+                                        .amount = inventory[item_id],
+                                        .index = item_index});
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(StateUpdate{.items = item_states,
+                               .progression_items = progression_items});
   }
 
   void OnRetrieved(const std::map<std::string, nlohmann::json>& data) {
+    StateUpdate state_update;
+
     {
       std::lock_guard state_guard(state_mutex);
 
       for (const auto& [key, value] : data) {
-        HandleDataStorage(key, value);
+        HandleDataStorage(key, value, state_update);
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(state_update);
   }
 
   void OnSetReply(const std::string& key, const nlohmann::json& value) {
+    StateUpdate state_update;
+
     {
       std::lock_guard state_guard(state_mutex);
-      HandleDataStorage(key, value);
+      HandleDataStorage(key, value, state_update);
     }
 
-    RefreshTracker(false);
+    RefreshTracker(state_update);
   }
 
   void OnSlotConnected(std::string player, std::string server,
@@ -435,6 +481,7 @@ struct APState {
         }
       }
       color_shuffle = slot_data["shuffle_colors"].get<int>() == 1;
+      panel_shuffle_mode = slot_data["shuffle_panels"].get<PanelShuffleMode>();
       painting_shuffle = slot_data["shuffle_paintings"].get<int>() == 1;
       mastery_requirement = slot_data["mastery_achievements"].get<int>();
       level_2_requirement = slot_data["level_2_requirement"].get<int>();
@@ -456,6 +503,9 @@ struct APState {
                            : kSUNWARP_ACCESS_NORMAL;
       sunwarp_shuffle = slot_data.contains("shuffle_sunwarps") &&
                         slot_data["shuffle_sunwarps"].get<int>() == 1;
+      postgame_shuffle = slot_data.contains("shuffle_postgame")
+                             ? (slot_data["shuffle_postgame"].get<int>() == 1)
+                             : true;
 
       if (painting_shuffle && slot_data.contains("painting_entrance_to_exit")) {
         painting_mapping.clear();
@@ -497,7 +547,7 @@ struct APState {
     }
 
     ResetReachabilityRequirements();
-    RefreshTracker(true);
+    RefreshTracker(std::nullopt);
   }
 
   void OnSlotRefused(const std::list<std::string>& errors) {
@@ -540,19 +590,40 @@ struct APState {
   }
 
   // Assumes state mutex is locked.
-  void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
+  void HandleDataStorage(const std::string& key, const nlohmann::json& value, StateUpdate& state_update) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
       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(fmt::format("Data storage {} retrieved as {}", key,
                              value.get<int>()));
+
+      if (key == victory_data_storage_key) {
+        state_update.cleared_locations = true;
+      } else if (key.find("Panels_") != std::string::npos) {
+        int bitfield_num =
+            std::stoi(key.substr(data_storage_prefix.size() + 7));
+        uint64_t bitfield_value = value.get<uint64_t>();
+        for (int i = 0; i < PANEL_BITFIELD_LENGTH; i++) {
+          if ((bitfield_value & (1LL << i)) != 0) {
+            int solve_index = bitfield_num * PANEL_BITFIELD_LENGTH + i;
+            
+            if (!solved_panels.test(solve_index)) {
+              state_update.panels.insert(solve_index);
+            }
+            
+            solved_panels.set(solve_index);
+          }
+        }
+      }
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
         player_pos = std::tuple<int, int>(map_value["x"], map_value["z"]);
+        state_update.player_position = true;
       } else {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
@@ -561,6 +632,7 @@ struct APState {
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
+        state_update.player_position = true;
       } else {
         data_storage.erase(key);
       }
@@ -572,6 +644,8 @@ struct APState {
       if (key.ends_with("Paintings")) {
         data_storage[key] =
             std::set<std::string>(list_value.begin(), list_value.end());
+        state_update.paintings =
+            std::vector<std::string>(list_value.begin(), list_value.end());
       } else {
         data_storage[key] = list_value;
       }
@@ -582,29 +656,34 @@ struct APState {
   }
 
   // State mutex should NOT be locked.
-  void RefreshTracker(bool reset) {
+  // nullopt state_update indicates a reset.
+  void RefreshTracker(std::optional<StateUpdate> state_update) {
     TrackerLog("Refreshing display...");
 
-    std::string prev_msg;
-    {
-      std::lock_guard state_guard(state_mutex);
+    if (!state_update || state_update->progression_items ||
+        !state_update->paintings.empty()) {
+      std::string prev_msg;
+      {
+        std::lock_guard state_guard(state_mutex);
 
-      prev_msg = status_message;
-      SetStatusMessage(fmt::format("{} Recalculating...", status_message));
-    }
+        prev_msg = status_message;
+        SetStatusMessage(fmt::format("{} Recalculating...", status_message));
+      }
 
-    RecalculateReachability();
+      RecalculateReachability();
 
-    if (reset) {
-      tracker_frame->ResetIndicators();
-    } else {
-      tracker_frame->UpdateIndicators();
-    }
+      {
+        std::lock_guard state_guard(state_mutex);
 
-    {
-      std::lock_guard state_guard(state_mutex);
+        SetStatusMessage(prev_msg);
+      }
+    }
+    
 
-      SetStatusMessage(prev_msg);
+    if (!state_update) {
+      tracker_frame->ResetIndicators();
+    } else {
+      tracker_frame->UpdateIndicators(*state_update);
     }
   }
 
@@ -639,16 +718,12 @@ bool AP_HasCheckedGameLocation(int location_id) {
   return GetState().HasCheckedGameLocation(location_id);
 }
 
-bool AP_HasCheckedHuntPanel(int location_id) {
-  return GetState().HasCheckedHuntPanel(location_id);
-}
-
 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);
+bool AP_HasItemSafe(int item_id, int quantity) {
+  return GetState().HasItemSafe(item_id, quantity);
 }
 
 DoorShuffleMode AP_GetDoorShuffleMode() {
@@ -695,6 +770,8 @@ bool AP_IsPaintingChecked(const std::string& painting_id) {
   return GetState().IsPaintingChecked(painting_id);
 }
 
+void AP_RevealPaintings() { GetState().RevealPaintings(); }
+
 int AP_GetMasteryRequirement() {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -707,6 +784,12 @@ int AP_GetLevel2Requirement() {
   return GetState().level_2_requirement;
 }
 
+LocationChecks AP_GetLocationsChecks() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().location_checks;
+}
+
 bool AP_IsLocationVisible(int classification) {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -734,14 +817,16 @@ bool AP_IsLocationVisible(int classification) {
   return (world_state & classification);
 }
 
-VictoryCondition AP_GetVictoryCondition() {
+PanelShuffleMode AP_GetPanelShuffleMode() {
   std::lock_guard state_guard(GetState().state_mutex);
 
-  return GetState().victory_condition;
+  return GetState().panel_shuffle_mode;
 }
 
-bool AP_HasAchievement(const std::string& achievement_name) {
-  return GetState().HasAchievement(achievement_name);
+VictoryCondition AP_GetVictoryCondition() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().victory_condition;
 }
 
 bool AP_HasEarlyColorHallways() {
@@ -784,6 +869,8 @@ std::map<int, SunwarpMapping> AP_GetSunwarpMapping() {
   return GetState().sunwarp_mapping;
 }
 
+bool AP_IsPostgameShuffle() { return GetState().postgame_shuffle; }
+
 bool AP_HasReachedGoal() { return GetState().HasReachedGoal(); }
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
@@ -791,3 +878,7 @@ std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
 
   return GetState().player_pos;
 }
+
+bool AP_IsPanelSolved(int solve_index) {
+  return GetState().IsPanelSolved(solve_index);
+}
@@ -26,6 +26,8 @@ enum LocationChecks {
   kPANELSANITY = 2
 };
 
+enum PanelShuffleMode { kNO_PANELS = 0, kREARRANGE_PANELS = 1 };
+
 enum SunwarpAccess {
   kSUNWARP_ACCESS_NORMAL = 0,
   kSUNWARP_ACCESS_DISABLED = 1,
@@ -39,6 +41,12 @@ struct SunwarpMapping {
   int exit_index;
 };
 
+struct ItemState {
+  std::string name;
+  int amount = 0;
+  int index = 0;
+};
+
 void AP_SetTrackerFrame(TrackerFrame* tracker_frame);
 
 void AP_Connect(std::string server, std::string player, std::string password);
@@ -49,16 +57,11 @@ std::string AP_GetSaveName();
 
 bool AP_HasCheckedGameLocation(int location_id);
 
-bool AP_HasCheckedHuntPanel(int location_id);
-
 // This doesn't lock the state mutex, for speed, so it must ONLY be called from
 // RecalculateReachability, which is only called from the APState thread anyway.
 bool AP_HasItem(int item_id, int quantity = 1);
 
-// This doesn't lock the client mutex because it is ONLY to be called from
-// RecalculateReachability, which is only called from within a client callback
-// anyway.
-std::string AP_GetItemName(int item_id);
+bool AP_HasItemSafe(int item_id, int quantity = 1);
 
 DoorShuffleMode AP_GetDoorShuffleMode();
 
@@ -76,15 +79,19 @@ std::set<std::string> AP_GetCheckedPaintings();
 
 bool AP_IsPaintingChecked(const std::string& painting_id);
 
+void AP_RevealPaintings();
+
 int AP_GetMasteryRequirement();
 
 int AP_GetLevel2Requirement();
 
+LocationChecks AP_GetLocationsChecks();
+
 bool AP_IsLocationVisible(int classification);
 
-VictoryCondition AP_GetVictoryCondition();
+PanelShuffleMode AP_GetPanelShuffleMode();
 
-bool AP_HasAchievement(const std::string& achievement_name);
+VictoryCondition AP_GetVictoryCondition();
 
 bool AP_HasEarlyColorHallways();
 
@@ -100,8 +107,12 @@ bool AP_IsSunwarpShuffle();
 
 std::map<int, SunwarpMapping> AP_GetSunwarpMapping();
 
+bool AP_IsPostgameShuffle();
+
 bool AP_HasReachedGoal();
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition();
 
+bool AP_IsPanelSolved(int solve_index);
+
 #endif /* end of include guard: AP_STATE_H_664A4180 */
@@ -7,6 +7,7 @@
 #include "ap_state.h"
 #include "game_data.h"
 #include "global.h"
+#include "icons.h"
 #include "tracker_config.h"
 #include "tracker_panel.h"
 #include "tracker_state.h"
@@ -15,60 +16,54 @@ 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)
-                   .Scale(32, 32));
-  checked_eye_ = wxBitmap(
-      wxImage(GetAbsolutePath("assets/checked.png").c_str(), wxBITMAP_TYPE_PNG)
-          .Scale(32, 32));
+  LoadIcons();
 
+  // TODO: This is slow on high-DPI screens.
   SetScrollRate(5, 5);
 
   SetBackgroundColour(*wxBLACK);
   Hide();
 
   Bind(wxEVT_PAINT, &AreaPopup::OnPaint, this);
+  Bind(wxEVT_DPI_CHANGED, &AreaPopup::OnDPIChanged, this);
 
-  UpdateIndicators();
+  ResetIndicators();
 }
 
-void AreaPopup::UpdateIndicators() {
+void AreaPopup::ResetIndicators() {
+  indicators_.clear();
+
   const MapArea& map_area = GD_GetMapArea(area_id_);
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  TrackerPanel* tracker_panel = dynamic_cast<TrackerPanel*>(GetParent());
 
   // Start calculating extents.
   wxMemoryDC mem_dc;
-  mem_dc.SetFont(GetFont().Bold());
-  wxSize header_extent = mem_dc.GetTextExtent(map_area.name);
+  mem_dc.SetFont(the_font.Bold());
+  header_extent_ = mem_dc.GetTextExtent(map_area.name);
 
-  int acc_height = header_extent.GetHeight() + 20;
+  int acc_height = header_extent_.GetHeight() + FromDIP(20);
   int col_width = 0;
 
-  mem_dc.SetFont(GetFont());
-
-  TrackerPanel* tracker_panel = dynamic_cast<TrackerPanel*>(GetParent());
-
-  std::vector<int> real_locations;
+  mem_dc.SetFont(the_font);
 
   for (int section_id = 0; section_id < map_area.locations.size();
        section_id++) {
     const Location& location = map_area.locations.at(section_id);
-
-    if (tracker_panel->IsPanelsMode()) {
-      if (!location.single_panel) {
-        continue;
-      }
-    } else {
-      if (!AP_IsLocationVisible(location.classification) &&
-          !(location.hunt && GetTrackerConfig().show_hunt_panels)) {
-        continue;
-      }
+    if ((!AP_IsLocationVisible(location.classification) ||
+         IsLocationPostgame(location.ap_location_id)) &&
+        !(location.hunt &&
+          GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) &&
+        !(location.single_panel &&
+          GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS)) {
+      continue;
     }
 
-    real_locations.push_back(section_id);
+    indicators_.emplace_back(section_id, kLOCATION, acc_height);
 
     wxSize item_extent = mem_dc.GetTextExtent(location.name);
-    int item_height = std::max(32, item_extent.GetHeight()) + 10;
+    int item_height =
+        std::max(FromDIP(32), item_extent.GetHeight()) + FromDIP(10);
     acc_height += item_height;
 
     if (item_extent.GetWidth() > col_width) {
@@ -76,11 +71,18 @@ void AreaPopup::UpdateIndicators() {
     }
   }
 
-  if (AP_IsPaintingShuffle() && !tracker_panel->IsPanelsMode()) {
+  if (AP_IsPaintingShuffle()) {
     for (int painting_id : map_area.paintings) {
+      if (IsPaintingPostgame(painting_id)) {
+        continue;
+      }
+
+      indicators_.emplace_back(painting_id, kPAINTING, acc_height);
+
       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;
+      wxSize item_extent = mem_dc.GetTextExtent(painting.display_name);
+      int item_height =
+          std::max(FromDIP(32), item_extent.GetHeight()) + FromDIP(10);
       acc_height += item_height;
 
       if (item_extent.GetWidth() > col_width) {
@@ -89,80 +91,86 @@ void AreaPopup::UpdateIndicators() {
     }
   }
 
-  int item_width = col_width + 10 + 32;
-  int full_width = std::max(header_extent.GetWidth(), item_width) + 20;
+  int item_width = col_width + FromDIP(10 + 32);
+  full_width_ = std::max(header_extent_.GetWidth(), item_width) + FromDIP(20);
+  full_height_ = acc_height;
 
   Fit();
-  SetVirtualSize(full_width, acc_height);
+  SetVirtualSize(full_width_, full_height_);
+
+  UpdateIndicators();
+}
+
+void AreaPopup::UpdateIndicators() {
+  const MapArea& map_area = GD_GetMapArea(area_id_);
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  TrackerPanel* tracker_panel = dynamic_cast<TrackerPanel*>(GetParent());
+
+  rendered_ = wxBitmap(full_width_, full_height_);
 
-  rendered_ = wxBitmap(full_width, acc_height);
+  wxMemoryDC mem_dc;
   mem_dc.SelectObject(rendered_);
   mem_dc.SetPen(*wxTRANSPARENT_PEN);
   mem_dc.SetBrush(*wxBLACK_BRUSH);
-  mem_dc.DrawRectangle({0, 0}, {full_width, acc_height});
+  mem_dc.DrawRectangle({0, 0}, {full_width_, full_height_});
 
-  mem_dc.SetFont(GetFont().Bold());
+  mem_dc.SetFont(the_font.Bold());
   mem_dc.SetTextForeground(*wxWHITE);
   mem_dc.DrawText(map_area.name,
-                  {(full_width - header_extent.GetWidth()) / 2, 10});
+                  {(full_width_ - header_extent_.GetWidth()) / 2, FromDIP(10)});
 
-  int cur_height = header_extent.GetHeight() + 20;
+  mem_dc.SetFont(the_font);
 
-  mem_dc.SetFont(GetFont());
+  for (const IndicatorInfo& indicator : indicators_) {
+    switch (indicator.type) {
+      case kLOCATION: {
+        const Location& location = map_area.locations.at(indicator.id);
 
-  for (int section_id : real_locations) {
-    const Location& location = map_area.locations.at(section_id);
+        bool checked = false;
+        if (IsLocationWinCondition(location)) {
+          checked = AP_HasReachedGoal();
+        } else {
+          checked = AP_HasCheckedGameLocation(location.ap_location_id) ||
+                    (location.single_panel &&
+                     AP_IsPanelSolved(
+                         GD_GetPanel(*location.single_panel).solve_index));
+        }
 
-    bool checked = false;
-    if (IsLocationWinCondition(location)) {
-      checked = AP_HasReachedGoal();
-    } else if (tracker_panel->IsPanelsMode()) {
-      const Panel& panel = GD_GetPanel(*location.single_panel);
-      if (panel.non_counting) {
-        checked = AP_HasCheckedGameLocation(location.ap_location_id);
-      } else {
-        checked = tracker_panel->GetSolvedPanels().contains(panel.nodepath);
-      }
-    } else {
-      checked =
-          AP_HasCheckedGameLocation(location.ap_location_id) ||
-          (location.hunt && AP_HasCheckedHuntPanel(location.ap_location_id));
-    }
-
-    wxBitmap* eye_ptr = checked ? &checked_eye_ : &unchecked_eye_;
+        const wxBitmap* eye_ptr = checked ? checked_eye_ : unchecked_eye_;
 
-    mem_dc.DrawBitmap(*eye_ptr, {10, cur_height});
+        mem_dc.DrawBitmap(*eye_ptr, {FromDIP(10), indicator.y});
 
-    bool reachable = IsLocationReachable(location.ap_location_id);
-    const wxColour* text_color = reachable ? wxWHITE : wxRED;
-    mem_dc.SetTextForeground(*text_color);
+        bool reachable = IsLocationReachable(location.ap_location_id);
+        const wxColour* text_color = reachable ? wxWHITE : wxRED;
+        mem_dc.SetTextForeground(*text_color);
 
-    wxSize item_extent = mem_dc.GetTextExtent(location.name);
-    mem_dc.DrawText(
-        location.name,
-        {10 + 32 + 10, cur_height + (32 - mem_dc.GetFontMetrics().height) / 2});
-
-    cur_height += 10 + 32;
-  }
+        wxSize item_extent = mem_dc.GetTextExtent(location.name);
+        mem_dc.DrawText(
+            location.name,
+            {FromDIP(10 + 32 + 10),
+             indicator.y + (FromDIP(32) - mem_dc.GetFontMetrics().height) / 2});
 
-  if (AP_IsPaintingShuffle() && !tracker_panel->IsPanelsMode()) {
-    for (int painting_id : map_area.paintings) {
-      const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+        break;
+      }
+      case kPAINTING: {
+        const PaintingExit& painting = GD_GetPaintingExit(indicator.id);
 
-      bool reachable = IsPaintingReachable(painting_id);
-      const wxColour* text_color = reachable ? wxWHITE : wxRED;
-      mem_dc.SetTextForeground(*text_color);
+        bool reachable = IsPaintingReachable(indicator.id);
+        const wxColour* text_color = reachable ? wxWHITE : wxRED;
+        mem_dc.SetTextForeground(*text_color);
 
-      bool checked = reachable && AP_IsPaintingChecked(painting.internal_id);
-      wxBitmap* eye_ptr = checked ? &checked_eye_ : &unchecked_eye_;
-      mem_dc.DrawBitmap(*eye_ptr, {10, cur_height});
+        bool checked = reachable && AP_IsPaintingChecked(painting.internal_id);
+        const wxBitmap* eye_ptr = checked ? checked_owl_ : unchecked_owl_;
+        mem_dc.DrawBitmap(*eye_ptr, {FromDIP(10), indicator.y});
 
-      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});
+        wxSize item_extent = mem_dc.GetTextExtent(painting.display_name);
+        mem_dc.DrawText(
+            painting.display_name,
+            {FromDIP(10 + 32 + 10),
+             indicator.y + (FromDIP(32) - mem_dc.GetFontMetrics().height) / 2});
 
-      cur_height += 10 + 32;
+        break;
+      }
     }
   }
 }
@@ -174,3 +182,21 @@ void AreaPopup::OnPaint(wxPaintEvent& event) {
 
   event.Skip();
 }
+
+void AreaPopup::OnDPIChanged(wxDPIChangedEvent& event) {
+  LoadIcons();
+  ResetIndicators();
+
+  event.Skip();
+}
+
+void AreaPopup::LoadIcons() {
+  unchecked_eye_ = GetTheIconCache().GetIcon("assets/unchecked.png",
+                                             FromDIP(wxSize{32, 32}));
+  checked_eye_ =
+      GetTheIconCache().GetIcon("assets/checked.png", FromDIP(wxSize{32, 32}));
+  unchecked_owl_ =
+      GetTheIconCache().GetIcon("assets/owl.png", FromDIP(wxSize{32, 32}));
+  checked_owl_ = GetTheIconCache().GetIcon("assets/checked_owl.png",
+                                           FromDIP(wxSize{32, 32}));
+}
@@ -7,19 +7,53 @@
 #include <wx/wx.h>
 #endif
 
+#include <vector>
+
 class AreaPopup : public wxScrolledCanvas {
  public:
   AreaPopup(wxWindow* parent, int area_id);
 
+  void ResetIndicators();
   void UpdateIndicators();
 
+  int GetFullWidth() const { return full_width_; }
+  int GetFullHeight() const { return full_height_; }
+
  private:
+  enum IndicatorType {
+    kLOCATION,
+    kPAINTING,
+  };
+
+  struct IndicatorInfo {
+    // For locations, the id is an index into the map area's locations list.
+    // For paintings, it is a real painting id.
+    int id;
+    IndicatorType type;
+    int y;
+
+    IndicatorInfo(int id, IndicatorType type, int y)
+        : id(id), type(type), y(y) {}
+  };
+
   void OnPaint(wxPaintEvent& event);
+  void OnDPIChanged(wxDPIChangedEvent& event);
+
+  void LoadIcons();
 
   int area_id_;
 
-  wxBitmap unchecked_eye_;
-  wxBitmap checked_eye_;
+  const wxBitmap* unchecked_eye_;
+  const wxBitmap* checked_eye_;
+  const wxBitmap* unchecked_owl_;
+  const wxBitmap* checked_owl_;
+
+  int full_width_ = 0;
+  int full_height_ = 0;
+  wxSize header_extent_;
+
+  std::vector<IndicatorInfo> indicators_;
+
   wxBitmap rendered_;
 };
 
@@ -4,17 +4,21 @@
 
 ConnectionDialog::ConnectionDialog()
     : wxDialog(nullptr, wxID_ANY, "Connect to Archipelago") {
-  server_box_ =
-      new wxTextCtrl(this, -1, GetTrackerConfig().connection_details.ap_server,
-                     wxDefaultPosition, {300, -1});
-  player_box_ =
-      new wxTextCtrl(this, -1, GetTrackerConfig().connection_details.ap_player,
-                     wxDefaultPosition, {300, -1});
+  server_box_ = new wxTextCtrl(
+      this, -1,
+      wxString::FromUTF8(GetTrackerConfig().connection_details.ap_server),
+      wxDefaultPosition, FromDIP(wxSize{300, -1}));
+  player_box_ = new wxTextCtrl(
+      this, -1,
+      wxString::FromUTF8(GetTrackerConfig().connection_details.ap_player),
+      wxDefaultPosition, FromDIP(wxSize{300, -1}));
   password_box_ = new wxTextCtrl(
-      this, -1, GetTrackerConfig().connection_details.ap_password,
-      wxDefaultPosition, {300, -1});
+      this, -1,
+      wxString::FromUTF8(GetTrackerConfig().connection_details.ap_password),
+      wxDefaultPosition, FromDIP(wxSize{300, -1}));
 
-  wxFlexGridSizer* form_sizer = new wxFlexGridSizer(2, 10, 10);
+  wxFlexGridSizer* form_sizer =
+      new wxFlexGridSizer(2, FromDIP(10), FromDIP(10));
 
   form_sizer->Add(
       new wxStaticText(this, -1, "Server:"),
@@ -30,17 +34,19 @@ ConnectionDialog::ConnectionDialog()
   form_sizer->Add(password_box_, wxSizerFlags().Expand());
 
   history_list_ = new wxListBox(this, -1);
-  for (const ConnectionDetails& details : GetTrackerConfig().connection_history) {
+  for (const ConnectionDetails& details :
+       GetTrackerConfig().connection_history) {
     wxString display_text;
-    display_text << details.ap_player;
+    display_text << wxString::FromUTF8(details.ap_player);
     display_text << " (";
-    display_text << details.ap_server;
+    display_text << wxString::FromUTF8(details.ap_server);
     display_text << ")";
 
     history_list_->Append(display_text);
   }
 
-  history_list_->Bind(wxEVT_LISTBOX, &ConnectionDialog::OnOldConnectionChosen, this);
+  history_list_->Bind(wxEVT_LISTBOX, &ConnectionDialog::OnOldConnectionChosen,
+                      this);
 
   wxBoxSizer* mid_sizer = new wxBoxSizer(wxHORIZONTAL);
   mid_sizer->Add(form_sizer, wxSizerFlags().Proportion(3).Expand());
@@ -52,7 +58,8 @@ ConnectionDialog::ConnectionDialog()
                      this, -1, "Enter the details to connect to Archipelago."),
                  wxSizerFlags().Align(wxALIGN_LEFT).DoubleBorder());
   top_sizer->Add(mid_sizer, wxSizerFlags().DoubleBorder().Expand());
-  top_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), wxSizerFlags().Border().Center());
+  top_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL),
+                 wxSizerFlags().Border().Center());
 
   SetSizerAndFit(top_sizer);
 
@@ -62,9 +69,10 @@ ConnectionDialog::ConnectionDialog()
 
 void ConnectionDialog::OnOldConnectionChosen(wxCommandEvent& e) {
   if (e.IsSelection()) {
-    const ConnectionDetails& details = GetTrackerConfig().connection_history.at(e.GetSelection());
-    server_box_->SetValue(details.ap_server);
-    player_box_->SetValue(details.ap_player);
-    password_box_->SetValue(details.ap_password);
+    const ConnectionDetails& details =
+        GetTrackerConfig().connection_history.at(e.GetSelection());
+    server_box_->SetValue(wxString::FromUTF8(details.ap_server));
+    player_box_->SetValue(wxString::FromUTF8(details.ap_player));
+    password_box_->SetValue(wxString::FromUTF8(details.ap_password));
   }
 }
@@ -14,12 +14,12 @@ class ConnectionDialog : public wxDialog {
  public:
   ConnectionDialog();
 
-  std::string GetServerValue() { return server_box_->GetValue().ToStdString(); }
+  std::string GetServerValue() { return server_box_->GetValue().utf8_string(); }
 
-  std::string GetPlayerValue() { return player_box_->GetValue().ToStdString(); }
+  std::string GetPlayerValue() { return player_box_->GetValue().utf8_string(); }
 
   std::string GetPasswordValue() {
-    return password_box_->GetValue().ToStdString();
+    return password_box_->GetValue().utf8_string();
   }
 
  private:
@@ -12,32 +12,6 @@
 
 namespace {
 
-LingoColor GetColorForString(const std::string &str) {
-  if (str == "black") {
-    return LingoColor::kBlack;
-  } else if (str == "red") {
-    return LingoColor::kRed;
-  } else if (str == "blue") {
-    return LingoColor::kBlue;
-  } else if (str == "yellow") {
-    return LingoColor::kYellow;
-  } else if (str == "orange") {
-    return LingoColor::kOrange;
-  } else if (str == "green") {
-    return LingoColor::kGreen;
-  } else if (str == "gray") {
-    return LingoColor::kGray;
-  } else if (str == "brown") {
-    return LingoColor::kBrown;
-  } else if (str == "purple") {
-    return LingoColor::kPurple;
-  } else {
-    TrackerLog(fmt::format("Invalid color: {}", str));
-
-    return LingoColor::kNone;
-  }
-}
-
 struct GameData {
   std::vector<Room> rooms_;
   std::vector<Door> doors_;
@@ -55,10 +29,10 @@ struct GameData {
   std::map<std::string, int> painting_by_id_;
 
   std::vector<int> door_definition_order_;
-  std::vector<int> room_definition_order_;
 
   std::map<std::string, int> room_by_painting_;
   std::map<int, int> room_by_sunwarp_;
+  std::map<int, int> panel_by_solve_index_;
 
   std::vector<int> achievement_panels_;
 
@@ -69,6 +43,8 @@ struct GameData {
   std::map<std::string, int> subway_item_by_painting_;
   std::map<SubwaySunwarp, int> subway_item_by_sunwarp_;
 
+  std::map<int, std::string> item_by_ap_id_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -84,7 +60,7 @@ struct GameData {
           ids_config["special_items"][color_name]) {
         std::string input_name = color_name;
         input_name[0] = std::tolower(input_name[0]);
-        ap_id_by_color_[GetColorForString(input_name)] =
+        ap_id_by_color_[GetLingoColorForString(input_name)] =
             ids_config["special_items"][color_name].as<int>();
       } else {
         TrackerLog(fmt::format("Missing AP item ID for color {}", color_name));
@@ -101,11 +77,20 @@ struct GameData {
     init_color_id("Brown");
     init_color_id("Gray");
 
+    if (ids_config["special_items"]) {
+      for (const auto& special_item_it : ids_config["special_items"])
+      {
+        item_by_ap_id_[special_item_it.second.as<int>()] =
+            special_item_it.first.as<std::string>();
+      }
+    }
+
     rooms_.reserve(lingo_config.size() * 2);
 
+    std::vector<int> panel_location_ids;
+
     for (const auto &room_it : lingo_config) {
       int room_id = AddOrGetRoom(room_it.first.as<std::string>());
-      room_definition_order_.push_back(room_id);
 
       for (const auto &entrance_it : room_it.second["entrances"]) {
         int from_room_id = AddOrGetRoom(entrance_it.first.as<std::string>());
@@ -142,6 +127,10 @@ 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);
             };
 
@@ -181,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>()));
               }
             }
           }
@@ -292,10 +281,11 @@ struct GameData {
               ids_config["panels"][rooms_[room_id].name] &&
               ids_config["panels"][rooms_[room_id].name]
                         [panels_[panel_id].name]) {
-            panels_[panel_id].ap_location_id =
-                ids_config["panels"][rooms_[room_id].name]
-                          [panels_[panel_id].name]
-                              .as<int>();
+            int location_id = ids_config["panels"][rooms_[room_id].name]
+                                        [panels_[panel_id].name]
+                                            .as<int>();
+            panels_[panel_id].ap_location_id = location_id;
+            panel_location_ids.push_back(location_id);
           } else {
             TrackerLog(fmt::format("Missing AP location ID for panel {} - {}",
                                    rooms_[room_id].name,
@@ -361,6 +351,9 @@ struct GameData {
                   ids_config["doors"][rooms_[room_id].name]
                             [doors_[door_id].name]["item"]
                                 .as<int>();
+
+              item_by_ap_id_[doors_[door_id].ap_item_id] =
+                  doors_[door_id].item_name;
             } else {
               TrackerLog(fmt::format("Missing AP item ID for door {} - {}",
                                      rooms_[room_id].name,
@@ -377,6 +370,9 @@ struct GameData {
               doors_[door_id].group_ap_item_id =
                   ids_config["door_groups"][doors_[door_id].group_name]
                       .as<int>();
+
+              item_by_ap_id_[doors_[door_id].group_ap_item_id] =
+                  doors_[door_id].group_name;
             } else {
               TrackerLog(fmt::format("Missing AP item ID for door group {}",
                                      doors_[door_id].group_name));
@@ -440,21 +436,50 @@ struct GameData {
           int panel_door_id =
               AddOrGetPanelDoor(rooms_[room_id].name, panel_door_name);
 
+          std::map<std::string, std::vector<std::string>> panel_per_room;
+          int num_panels = 0;
           for (const auto &panel_node : panel_door_it.second["panels"]) {
+            num_panels++;
+
             int panel_id = -1;
 
             if (panel_node.IsScalar()) {
               panel_id = AddOrGetPanel(rooms_[room_id].name,
                                        panel_node.as<std::string>());
+              
+              panel_per_room[rooms_[room_id].name].push_back(
+                  panel_node.as<std::string>());
             } else {
               panel_id = AddOrGetPanel(panel_node["room"].as<std::string>(),
                                        panel_node["panel"].as<std::string>());
+
+              panel_per_room[panel_node["room"].as<std::string>()].push_back(
+                  panel_node["panel"].as<std::string>());
             }
 
             Panel &panel = panels_[panel_id];
             panel.panel_door = panel_door_id;
           }
 
+          if (panel_door_it.second["item_name"]) {
+            panel_doors_[panel_door_id].item_name =
+                panel_door_it.second["item_name"].as<std::string>();
+          } else {
+            std::vector<std::string> room_strs;
+            for (const auto &[room_str, panels_str] : panel_per_room) {
+              room_strs.push_back(fmt::format(
+                  "{} - {}", room_str, hatkirby::implode(panels_str, ", ")));
+            }
+
+            if (num_panels == 1) {
+              panel_doors_[panel_door_id].item_name =
+                  fmt::format("{} (Panel)", room_strs[0]);
+            } else {
+              panel_doors_[panel_door_id].item_name = fmt::format(
+                  "{} (Panels)", hatkirby::implode(room_strs, " and "));
+            }
+          }
+
           if (ids_config["panel_doors"] &&
               ids_config["panel_doors"][rooms_[room_id].name] &&
               ids_config["panel_doors"][rooms_[room_id].name]
@@ -462,6 +487,9 @@ struct GameData {
             panel_doors_[panel_door_id].ap_item_id =
                 ids_config["panel_doors"][rooms_[room_id].name][panel_door_name]
                     .as<int>();
+
+            item_by_ap_id_[panel_doors_[panel_door_id].ap_item_id] =
+                panel_doors_[panel_door_id].item_name;
           } else {
             TrackerLog(fmt::format("Missing AP item ID for panel door {} - {}",
                                    rooms_[room_id].name, panel_door_name));
@@ -475,6 +503,9 @@ struct GameData {
                 ids_config["panel_groups"][panel_group]) {
               panel_doors_[panel_door_id].group_ap_item_id =
                   ids_config["panel_groups"][panel_group].as<int>();
+
+              item_by_ap_id_[panel_doors_[panel_door_id].group_ap_item_id] =
+                  panel_group;
             } else {
               TrackerLog(fmt::format(
                   "Missing AP item ID for panel door group {}", panel_group));
@@ -490,6 +521,13 @@ struct GameData {
           PaintingExit &painting_exit = paintings_[painting_id];
           painting_exit.room = room_id;
 
+          if (painting["display_name"]) {
+            painting_exit.display_name =
+                painting["display_name"].as<std::string>();
+          } else {
+            painting_exit.display_name = painting_exit.internal_id;
+          }
+
           if ((!painting["exit_only"] || !painting["exit_only"].as<bool>()) &&
               (!painting["disable"] || !painting["disable"].as<bool>())) {
             painting_exit.entrance = true;
@@ -531,6 +569,8 @@ struct GameData {
               ids_config["progression"][progressive_item_name]) {
             progressive_item_id =
                 ids_config["progression"][progressive_item_name].as<int>();
+
+            item_by_ap_id_[progressive_item_id] = progressive_item_name;
           } else {
             TrackerLog(fmt::format("Missing AP item ID for progressive item {}",
                                    progressive_item_name));
@@ -582,6 +622,21 @@ struct GameData {
       }
     }
 
+    // Determine the panel solve indices from the sorted location IDs.
+    std::sort(panel_location_ids.begin(), panel_location_ids.end());
+
+    std::map<int, int> solve_index_by_location_id;
+    for (int i = 0; i < panel_location_ids.size(); i++) {
+      solve_index_by_location_id[panel_location_ids[i]] = i;
+    }
+
+    for (Panel &panel : panels_) {
+      if (panel.ap_location_id != -1) {
+        panel.solve_index = solve_index_by_location_id[panel.ap_location_id];
+        panel_by_solve_index_[panel.solve_index] = panel.id;
+      }
+    }
+
     map_areas_.reserve(areas_config.size());
 
     std::map<std::string, int> fold_areas;
@@ -602,7 +657,7 @@ struct GameData {
     // Only locations for the panels are kept here.
     std::map<std::string, std::tuple<int, int>> locations_by_name;
 
-    for (const Panel &panel : panels_) {
+    for (Panel &panel : panels_) {
       int room_id = panel.room;
       std::string room_name = rooms_[room_id].name;
 
@@ -618,6 +673,8 @@ struct GameData {
           area_name = location_name.substr(0, divider_pos);
           section_name = location_name.substr(divider_pos + 3);
         }
+      } else {
+        panel.location_name = location_name;
       }
 
       if (fold_areas.count(area_name)) {
@@ -716,7 +773,8 @@ struct GameData {
         MapArea &map_area = map_areas_[area_id];
 
         for (int painting_id : room.paintings) {
-          const PaintingExit &painting_obj = paintings_.at(painting_id);
+          PaintingExit &painting_obj = paintings_.at(painting_id);
+          painting_obj.map_area = area_id;
           if (painting_obj.entrance) {
             map_area.paintings.push_back(painting_id);
           }
@@ -724,31 +782,6 @@ struct GameData {
       }
     }
 
-    // As a workaround for a generator bug in 0.5.1, we are going to remove the
-    // panel door requirement on panels that are defined earlier in the file than
-    // the panel door is. This results in logic that matches the generator, even
-    // if it is not true to how the game should work. This will be reverted once
-    // the logic bug is fixed and released.
-    // See: https://github.com/ArchipelagoMW/Archipelago/pull/4342
-    for (Panel& panel : panels_) {
-      if (panel.panel_door == -1) {
-        continue;
-      }
-      const PanelDoor &panel_door = panel_doors_[panel.panel_door];
-      for (int room_id : room_definition_order_) {
-        if (room_id == panel_door.room) {
-          // The panel door was defined first (or at the same time as the panel),
-          // so we're good.
-          break;
-        } else if (room_id == panel.room) {
-          // The panel was defined first, so we have to pretend the panel door is
-          // not required for this panel.
-          panel.panel_door = -1;
-          break;
-        }
-      }
-    }
-
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
       TrackerLog(fmt::format("Area data not found for: {}", area));
@@ -768,13 +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"]) {
@@ -821,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);
     }
 
@@ -880,7 +914,7 @@ struct GameData {
     if (!panel_doors_by_id_.count(full_name)) {
       int panel_door_id = panel_doors_.size();
       panel_doors_by_id_[full_name] = panel_door_id;
-      panel_doors_.push_back({.room = AddOrGetRoom(room)});
+      panel_doors_.push_back({});
     }
 
     return panel_doors_by_id_[full_name];
@@ -953,6 +987,14 @@ const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
 
+int GD_GetPanelBySolveIndex(int solve_index) {
+  return GetState().panel_by_solve_index_.at(solve_index);
+}
+
+const std::vector<PaintingExit> &GD_GetPaintings() {
+  return GetState().paintings_;
+}
+
 const PaintingExit &GD_GetPaintingExit(int painting_id) {
   return GetState().paintings_.at(painting_id);
 }
@@ -995,3 +1037,38 @@ std::optional<int> GD_GetSubwayItemForPainting(const std::string &painting_id) {
 int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
   return GetState().subway_item_by_sunwarp_.at(sunwarp);
 }
+
+std::string GD_GetItemName(int id) {
+  auto it = GetState().item_by_ap_id_.find(id);
+  if (it != GetState().item_by_ap_id_.end()) {
+    return it->second;
+  } else {
+    return "Unknown";
+  }
+}
+
+LingoColor GetLingoColorForString(const std::string &str) {
+  if (str == "black") {
+    return LingoColor::kBlack;
+  } else if (str == "red") {
+    return LingoColor::kRed;
+  } else if (str == "blue") {
+    return LingoColor::kBlue;
+  } else if (str == "yellow") {
+    return LingoColor::kYellow;
+  } else if (str == "orange") {
+    return LingoColor::kOrange;
+  } else if (str == "green") {
+    return LingoColor::kGreen;
+  } else if (str == "gray") {
+    return LingoColor::kGray;
+  } else if (str == "brown") {
+    return LingoColor::kBrown;
+  } else if (str == "purple") {
+    return LingoColor::kPurple;
+  } else {
+    TrackerLog(fmt::format("Invalid color: {}", str));
+
+    return LingoColor::kNone;
+  }
+}
@@ -31,6 +31,7 @@ enum class EntranceType {
   kWarp,
   kPilgrimage,
   kCrossroadsRoofAccess,
+  kStaticPainting,
 };
 
 enum class DoorType {
@@ -57,6 +58,7 @@ struct Panel {
   int ap_location_id = -1;
   bool hunt = false;
   int panel_door = -1;
+  int solve_index = -1;
 };
 
 struct ProgressiveRequirement {
@@ -85,10 +87,10 @@ struct Door {
 };
 
 struct PanelDoor {
-  int room;
   int ap_item_id = -1;
   int group_ap_item_id = -1;
   std::vector<ProgressiveRequirement> progressives;
+  std::string item_name;
 };
 
 struct Exit {
@@ -102,8 +104,10 @@ struct PaintingExit {
   int id;
   int room;
   std::string internal_id;
+  std::string display_name;
   std::optional<int> door;
   bool entrance = false;
+  int map_area;
 };
 
 struct Room {
@@ -154,8 +158,9 @@ struct SubwayItem {
   int id;
   int x;
   int y;
+  bool tilted = false;
   std::optional<int> door;
-  std::vector<std::string> paintings;
+  std::optional<std::string> painting;
   std::vector<std::string> tags; // 2-way teleports
   std::vector<std::string> entrances; // teleport entrances
   std::vector<std::string> exits; // teleport exits
@@ -173,7 +178,9 @@ 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_GetPanelBySolveIndex(int solve_index);
 const PanelDoor& GD_GetPanelDoor(int panel_door_id);
+const std::vector<PaintingExit>& GD_GetPaintings();
 const PaintingExit& GD_GetPaintingExit(int painting_id);
 int GD_GetPaintingByName(const std::string& name);
 const std::vector<int>& GD_GetAchievementPanels();
@@ -184,5 +191,8 @@ 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);
+std::string GD_GetItemName(int id);
+
+LingoColor GetLingoColorForString(const std::string& str);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -26,17 +26,19 @@ std::string GetAbsolutePath(std::string_view path) {
   return (GetExecutableDirectory() / path).string();
 }
 
-bool IsLocationWinCondition(const Location& location) {
+std::string GetWinCondition() {
   switch (AP_GetVictoryCondition()) {
     case kTHE_END:
-      return location.ap_location_name ==
-             "Orange Tower Seventh Floor - THE END";
+      return "Orange Tower Seventh Floor - THE END";
     case kTHE_MASTER:
-      return location.ap_location_name ==
-             "Orange Tower Seventh Floor - THE MASTER";
+      return "Orange Tower Seventh Floor - THE MASTER";
     case kLEVEL_2:
-      return location.ap_location_name == "Second Room - LEVEL 2";
+      return "Second Room - LEVEL 2";
     case kPILGRIMAGE:
-      return location.ap_location_name == "Pilgrim Antechamber - PILGRIM";
+      return "Pilgrim Antechamber - PILGRIM";
   }
 }
+
+bool IsLocationWinCondition(const Location& location) {
+  return location.ap_location_name == GetWinCondition();
+}
@@ -10,6 +10,8 @@ const std::filesystem::path& GetExecutableDirectory();
 
 std::string GetAbsolutePath(std::string_view path);
 
+std::string GetWinCondition();
+
 bool IsLocationWinCondition(const Location& location);
 
 #endif /* end of include guard: GLOBAL_H_44945DBA */
@@ -1,84 +0,0 @@
-// Godot save decoder algorithm by Chris Souvey.
-
-#include "godot_variant.h"
-
-#include <algorithm>
-#include <charconv>
-#include <cstddef>
-#include <cstdint>
-#include <fstream>
-#include <string>
-#include <tuple>
-#include <variant>
-#include <vector>
-
-namespace {
-
-uint16_t ReadUint16(std::basic_istream<char>& stream) {
-  uint16_t result;
-  stream.read(reinterpret_cast<char*>(&result), 2);
-  return result;
-}
-
-uint32_t ReadUint32(std::basic_istream<char>& stream) {
-  uint32_t result;
-  stream.read(reinterpret_cast<char*>(&result), 4);
-  return result;
-}
-
-GodotVariant ParseVariant(std::basic_istream<char>& stream) {
-  uint16_t type = ReadUint16(stream);
-  stream.ignore(2);
-
-  switch (type) {
-    case 1: {
-      // bool
-      bool boolval = (ReadUint32(stream) == 1);
-      return {boolval};
-    }
-    case 15: {
-      // nodepath
-      uint32_t name_length = ReadUint32(stream) & 0x7fffffff;
-      uint32_t subname_length = ReadUint32(stream) & 0x7fffffff;
-      uint32_t flags = ReadUint32(stream);
-
-      std::vector<std::string> result;
-      for (size_t i = 0; i < name_length + subname_length; i++) {
-        uint32_t char_length = ReadUint32(stream);
-        uint32_t padded_length = (char_length % 4 == 0)
-                                     ? char_length
-                                     : (char_length + 4 - (char_length % 4));
-        std::vector<char> next_bytes(padded_length);
-        stream.read(next_bytes.data(), padded_length);
-        std::string next_piece;
-        std::copy(next_bytes.begin(),
-                  std::next(next_bytes.begin(), char_length),
-                  std::back_inserter(next_piece));
-        result.push_back(next_piece);
-      }
-
-      return {result};
-    }
-    case 19: {
-      // array
-      uint32_t length = ReadUint32(stream) & 0x7fffffff;
-      std::vector<GodotVariant> result;
-      for (size_t i = 0; i < length; i++) {
-        result.push_back(ParseVariant(stream));
-      }
-      return {result};
-    }
-    default: {
-      // eh
-      return {std::monostate{}};
-    }
-  }
-}
-
-}  // namespace
-
-GodotVariant ParseGodotFile(std::string filename) {
-  std::ifstream file_stream(filename, std::ios_base::binary);
-  file_stream.ignore(4);
-  return ParseVariant(file_stream);
-}
@@ -1,28 +0,0 @@
-#ifndef GODOT_VARIANT_H_ED7F2EB6
-#define GODOT_VARIANT_H_ED7F2EB6
-
-#include <string>
-#include <variant>
-#include <vector>
-
-struct GodotVariant {
-  using value_type = std::variant<std::monostate, bool, std::vector<std::string>, std::vector<GodotVariant>>;
-
-  value_type value;
-
-  GodotVariant(value_type v) : value(v) {}
-
-  bool AsBool() const { return std::get<bool>(value); }
-
-  const std::vector<std::string>& AsNodePath() const {
-    return std::get<std::vector<std::string>>(value);
-  }
-
-  const std::vector<GodotVariant>& AsArray() const {
-    return std::get<std::vector<GodotVariant>>(value);
-  }
-};
-
-GodotVariant ParseGodotFile(std::string filename);
-
-#endif /* end of include guard: GODOT_VARIANT_H_ED7F2EB6 */
@@ -0,0 +1,22 @@
+#include "icons.h"
+
+#include "global.h"
+
+const wxBitmap* IconCache::GetIcon(const std::string& filename, wxSize size) {
+  std::tuple<std::string, int, int> key = {filename, size.x, size.y};
+
+  if (!icons_.count(key)) {
+    icons_[key] =
+        wxBitmap(wxImage(GetAbsolutePath(filename).c_str(),
+                         wxBITMAP_TYPE_PNG)
+                     .Scale(size.x, size.y));
+  }
+
+  return &icons_.at(key);
+}
+
+static IconCache* ICON_CACHE_INSTANCE = nullptr;
+
+void SetTheIconCache(IconCache* instance) { ICON_CACHE_INSTANCE = instance; }
+
+IconCache& GetTheIconCache() { return *ICON_CACHE_INSTANCE; }
@@ -0,0 +1,25 @@
+#ifndef ICONS_H_B95159A6
+#define ICONS_H_B95159A6
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <map>
+#include <string>
+#include <tuple>
+
+class IconCache {
+ public:
+  const wxBitmap* GetIcon(const std::string& filename, wxSize size);
+
+ private:
+  std::map<std::tuple<std::string, int, int>, wxBitmap> icons_;
+};
+
+void SetTheIconCache(IconCache* instance);
+IconCache& GetTheIconCache();
+
+#endif /* end of include guard: ICONS_H_B95159A6 */
@@ -12,13 +12,14 @@ IpcDialog::IpcDialog() : wxDialog(nullptr, wxID_ANY, "Connect to game") {
     address_value = GetTrackerConfig().ipc_address;
   }
 
-  address_box_ =
-      new wxTextCtrl(this, -1, address_value, wxDefaultPosition, {300, -1});
+  address_box_ = new wxTextCtrl(this, -1, wxString::FromUTF8(address_value),
+                                wxDefaultPosition, FromDIP(wxSize{300, -1}));
 
   wxButton* reset_button = new wxButton(this, -1, "Use Default");
   reset_button->Bind(wxEVT_BUTTON, &IpcDialog::OnResetClicked, this);
 
-  wxFlexGridSizer* form_sizer = new wxFlexGridSizer(3, 10, 10);
+  wxFlexGridSizer* form_sizer =
+      new wxFlexGridSizer(3, FromDIP(10), FromDIP(10));
   form_sizer->Add(
       new wxStaticText(this, -1, "Address:"),
       wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
@@ -13,7 +13,7 @@ class IpcDialog : public wxDialog {
  public:
   IpcDialog();
 
-  std::string GetIpcAddress() { return address_box_->GetValue().ToStdString(); }
+  std::string GetIpcAddress() { return address_box_->GetValue().utf8_string(); }
 
  private:
   void OnResetClicked(wxCommandEvent& event);
@@ -39,7 +39,6 @@ struct IPCState {
   std::string game_ap_user;
 
   std::optional<std::tuple<int, int>> player_position;
-  std::set<std::string> solved_panels;
 
   // Thread state
   std::unique_ptr<wswrap::WS> ws;
@@ -103,12 +102,6 @@ struct IPCState {
     return player_position;
   }
 
-  std::set<std::string> GetSolvedPanels() {
-    std::lock_guard state_guard(state_mutex);
-
-    return solved_panels;
-  }
-
  private:
   void Thread() {
     for (;;) {
@@ -134,7 +127,6 @@ struct IPCState {
         game_ap_user.clear();
 
         player_position = std::nullopt;
-        solved_panels.clear();
 
         if (address.empty()) {
           initialized = false;
@@ -273,7 +265,6 @@ struct IPCState {
 
       slot_matches = false;
       player_position = std::nullopt;
-      solved_panels.clear();
     }
   }
 
@@ -313,15 +304,7 @@ struct IPCState {
       player_position =
           std::make_tuple<int, int>(msg["position"]["x"], msg["position"]["z"]);
 
-      tracker_frame->RedrawPosition();
-    } else if (msg["cmd"] == "SolvePanels") {
-      std::lock_guard state_guard(state_mutex);
-
-      for (std::string panel : msg["panels"]) {
-        solved_panels.insert(std::move(panel));
-      }
-
-      tracker_frame->UpdateIndicators(kUPDATE_ONLY_PANELS);
+      tracker_frame->UpdateIndicators(StateUpdate{.player_position = true});
     }
   }
 
@@ -382,7 +365,3 @@ bool IPC_IsConnected() { return GetState().IsConnected(); }
 std::optional<std::tuple<int, int>> IPC_GetPlayerPosition() {
   return GetState().GetPlayerPosition();
 }
-
-std::set<std::string> IPC_GetSolvedPanels() {
-  return GetState().GetSolvedPanels();
-}
@@ -20,6 +20,4 @@ bool IPC_IsConnected();
 
 std::optional<std::tuple<int, int>> IPC_GetPlayerPosition();
 
-std::set<std::string> IPC_GetSolvedPanels();
-
 #endif /* end of include guard: IPC_STATE_H_6B3B0958 */
@@ -0,0 +1,145 @@
+#include "items_pane.h"
+
+#include <map>
+
+namespace {
+
+enum SortInstruction {
+  SI_NONE = 0,
+  SI_ASC = 1 << 0,
+  SI_DESC = 1 << 1,
+  SI_NAME = 1 << 2,
+  SI_AMOUNT = 1 << 3,
+  SI_ORDER = 1 << 4,
+};
+
+inline SortInstruction operator|(SortInstruction lhs, SortInstruction rhs) {
+  return static_cast<SortInstruction>(static_cast<int>(lhs) |
+                                      static_cast<int>(rhs));
+}
+
+template <typename T>
+int ItemCompare(const T& lhs, const T& rhs, bool ascending) {
+  if (lhs < rhs) {
+    return ascending ? -1 : 1;
+  } else if (lhs > rhs) {
+    return ascending ? 1 : -1;
+  } else {
+    return 0;
+  }
+}
+
+int wxCALLBACK RowCompare(wxIntPtr item1, wxIntPtr item2, wxIntPtr sortData) {
+  const ItemState& lhs = *reinterpret_cast<const ItemState*>(item1);
+  const ItemState& rhs = *reinterpret_cast<const ItemState*>(item2);
+  SortInstruction instruction = static_cast<SortInstruction>(sortData);
+
+  bool ascending = (instruction & SI_ASC) != 0;
+  if ((instruction & SI_NAME) != 0) {
+    return ItemCompare(lhs.name, rhs.name, ascending);
+  } else if ((instruction & SI_AMOUNT) != 0) {
+    return ItemCompare(lhs.amount, rhs.amount, ascending);
+  } else if ((instruction & SI_ORDER) != 0) {
+    return ItemCompare(lhs.index, rhs.index, ascending);
+  } else {
+    return 0;
+  }
+}
+
+}  // namespace
+
+ItemsPane::ItemsPane(wxWindow* parent)
+    : wxListView(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                 wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_HRULES) {
+  AppendColumn("Item", wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER);
+  AppendColumn("Amount", wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER);
+  AppendColumn("Order", wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER);
+
+  Bind(wxEVT_LIST_COL_CLICK, &ItemsPane::OnColClick, this);
+  Bind(wxEVT_DPI_CHANGED, &ItemsPane::OnDPIChanged, this);
+}
+
+void ItemsPane::ResetIndicators() {
+  DeleteAllItems();
+  items_.clear();
+}
+
+void ItemsPane::UpdateIndicators(const std::vector<ItemState>& items) {
+  std::map<std::string, ItemState> items_by_name;
+
+  for (const ItemState& item : items) {
+    items_by_name[item.name] = item;
+  }
+
+  for (int i = 0; i < GetItemCount(); i++) {
+    std::string item_name = GetItemText(i).utf8_string();
+    auto it = items_by_name.find(item_name);
+
+    if (it != items_by_name.end()) {
+      SetItem(i, 1, std::to_string(it->second.amount));
+      SetItem(i, 2, std::to_string(it->second.index));
+
+      *reinterpret_cast<ItemState*>(GetItemData(i)) = it->second;
+
+      items_by_name.erase(item_name);
+    }
+  }
+
+  for (const auto& [name, item] : items_by_name) {
+    int i = InsertItem(GetItemCount(), name);
+    SetItem(i, 1, std::to_string(item.amount));
+    SetItem(i, 2, std::to_string(item.index));
+
+    auto item_ptr = std::make_unique<ItemState>(item);
+    SetItemPtrData(i, reinterpret_cast<wxUIntPtr>(item_ptr.get()));
+    items_.push_back(std::move(item_ptr));
+  }
+
+  SetColumnWidth(0, wxLIST_AUTOSIZE);
+  SetColumnWidth(1, wxLIST_AUTOSIZE_USEHEADER);
+  SetColumnWidth(2, wxLIST_AUTOSIZE_USEHEADER);
+
+  if (GetSortIndicator() != -1) {
+    DoSort(GetSortIndicator(), IsAscendingSortIndicator());
+  }
+}
+
+void ItemsPane::OnColClick(wxListEvent& event) {
+  int col = event.GetColumn();
+  if (col == -1) {
+    return;
+  }
+
+  bool ascending = GetUpdatedAscendingSortIndicator(col);
+
+  DoSort(col, ascending);
+}
+
+void ItemsPane::OnDPIChanged(wxDPIChangedEvent& event) {
+  SetColumnWidth(0, wxLIST_AUTOSIZE);
+  SetColumnWidth(1, wxLIST_AUTOSIZE_USEHEADER);
+  SetColumnWidth(2, wxLIST_AUTOSIZE_USEHEADER);
+
+  event.Skip();
+}
+
+void ItemsPane::DoSort(int col, bool ascending) {
+  SortInstruction instruction = SI_NONE;
+  if (ascending) {
+    instruction = instruction | SI_ASC;
+  } else {
+    instruction = instruction | SI_DESC;
+  }
+
+  if (col == 0) {
+    instruction = instruction | SI_NAME;
+  } else if (col == 1) {
+    instruction = instruction | SI_AMOUNT;
+  } else if (col == 2) {
+    instruction = instruction | SI_ORDER;
+  }
+
+  if (SortItems(RowCompare, instruction)) {
+    ShowSortIndicator(col, ascending);
+  }
+}
@@ -0,0 +1,33 @@
+#ifndef ITEMS_PANE_H_EB637EE3
+#define ITEMS_PANE_H_EB637EE3
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <wx/listctrl.h>
+
+#include <memory>
+#include <vector>
+
+#include "ap_state.h"
+
+class ItemsPane : public wxListView {
+ public:
+  explicit ItemsPane(wxWindow* parent);
+
+  void ResetIndicators();
+  void UpdateIndicators(const std::vector<ItemState>& items);
+
+ private:
+  void OnColClick(wxListEvent& event);
+  void OnDPIChanged(wxDPIChangedEvent& event);
+
+  void DoSort(int col, bool ascending);
+
+  std::vector<std::unique_ptr<ItemState>> items_;
+};
+
+#endif /* end of include guard: ITEMS_PANE_H_EB637EE3 */
@@ -0,0 +1,37 @@
+#include "log_dialog.h"
+
+#include "logger.h"
+
+wxDEFINE_EVENT(LOG_MESSAGE, wxCommandEvent);
+
+LogDialog::LogDialog(wxWindow* parent)
+    : wxDialog(parent, wxID_ANY, "Debug Log", wxDefaultPosition, wxDefaultSize,
+               wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER) {
+  SetSize(FromDIP(wxSize{512, 280}));
+
+  text_area_ =
+      new wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize,
+                     wxTE_MULTILINE | wxTE_READONLY | wxTE_DONTWRAP);
+  text_area_->SetValue(TrackerReadPastLog());
+
+  wxBoxSizer* top_sizer = new wxBoxSizer(wxVERTICAL);
+  top_sizer->Add(text_area_,
+                 wxSizerFlags().DoubleBorder().Expand().Proportion(1));
+
+  SetSizer(top_sizer);
+
+  Bind(LOG_MESSAGE, &LogDialog::OnLogMessage, this);
+}
+
+void LogDialog::LogMessage(const std::string& message) {
+  wxCommandEvent* event = new wxCommandEvent(LOG_MESSAGE);
+  event->SetString(message);
+  QueueEvent(event);
+}
+
+void LogDialog::OnLogMessage(wxCommandEvent& event) {
+  if (!text_area_->IsEmpty()) {
+    text_area_->AppendText("\n");
+  }
+  text_area_->AppendText(event.GetString());
+}
@@ -0,0 +1,24 @@
+#ifndef LOG_DIALOG_H_EEFD45B6
+#define LOG_DIALOG_H_EEFD45B6
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+wxDECLARE_EVENT(LOG_MESSAGE, wxCommandEvent);
+
+class LogDialog : public wxDialog {
+ public:
+  explicit LogDialog(wxWindow* parent);
+
+  void LogMessage(const std::string& message);
+
+ private:
+  void OnLogMessage(wxCommandEvent& event);
+
+  wxTextCtrl* text_area_;
+};
+
+#endif /* end of include guard: LOG_DIALOG_H_EEFD45B6 */
@@ -3,8 +3,10 @@
 #include <chrono>
 #include <fstream>
 #include <mutex>
+#include <sstream>
 
 #include "global.h"
+#include "log_dialog.h"
 
 namespace {
 
@@ -14,19 +16,49 @@ class Logger {
 
   void LogLine(const std::string& text) {
     std::lock_guard guard(file_mutex_);
-    logfile_ << "[" << std::chrono::system_clock::now() << "] " << text
-             << std::endl;
+    std::ostringstream line;
+    line << "[" << std::chrono::system_clock::now() << "] " << text;
+
+    logfile_ << line.str() << std::endl;
     logfile_.flush();
+
+    if (log_dialog_ != nullptr) {
+      log_dialog_->LogMessage(line.str());
+    }
+  }
+
+  std::string GetContents() {
+    std::lock_guard guard(file_mutex_);
+
+    std::ifstream file_in(GetAbsolutePath("debug.log"));
+    std::ostringstream buffer;
+    buffer << file_in.rdbuf();
+
+    return buffer.str();
+  }
+
+  void SetLogDialog(LogDialog* log_dialog) {
+    std::lock_guard guard(file_mutex_);
+    log_dialog_ = log_dialog;
   }
 
  private:
   std::ofstream logfile_;
   std::mutex file_mutex_;
+  LogDialog* log_dialog_ = nullptr;
 };
 
+Logger& GetLogger() {
+  static Logger* instance = new Logger();
+  return *instance;
+}
+
 }  // namespace
 
-void TrackerLog(std::string text) {
-  static Logger* instance = new Logger();
-  instance->LogLine(text);
+void TrackerLog(std::string text) { GetLogger().LogLine(text); }
+
+std::string TrackerReadPastLog() { return GetLogger().GetContents(); }
+
+void TrackerSetLogDialog(LogDialog* log_dialog) {
+  GetLogger().SetLogDialog(log_dialog);
 }
@@ -3,6 +3,12 @@
 
 #include <string>
 
+class LogDialog;
+
 void TrackerLog(std::string message);
 
+std::string TrackerReadPastLog();
+
+void TrackerSetLogDialog(LogDialog* log_dialog);
+
 #endif /* end of include guard: LOGGER_H_9BDD07EA */
@@ -10,7 +10,7 @@
 
 class TrackerApp : public wxApp {
  public:
-  virtual bool OnInit() {
+  virtual bool OnInit() override {
     GetTrackerConfig().Load();
 
     TrackerFrame *frame = new TrackerFrame();
@@ -0,0 +1,71 @@
+#include "options_pane.h"
+
+#include "ap_state.h"
+
+namespace {
+
+const char* kDoorShuffleLabels[] = {"None", "Panels", "Doors"};
+const char* kLocationChecksLabels[] = {"Normal", "Reduced", "Insanity"};
+const char* kPanelShuffleLabels[] = {"None", "Rearrange"};
+const char* kVictoryConditionLabels[] = {"The End", "The Master", "Level 2",
+                                         "Pilgrimage"};
+const char* kSunwarpAccessLabels[] = {"Normal", "Disabled", "Unlock",
+                                      "Individual", "Progressive"};
+
+void AddRow(wxDataViewListCtrl* list, const std::string& text) {
+  wxVector<wxVariant> data;
+  data.push_back(wxVariant{text + ": "});
+  data.push_back(wxVariant{""});
+  list->AppendItem(data);
+}
+
+}  // namespace
+
+OptionsPane::OptionsPane(wxWindow* parent)
+    : wxDataViewListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                         wxDV_ROW_LINES) {
+  AppendTextColumn("Name", wxDATAVIEW_CELL_INERT, wxCOL_WIDTH_AUTOSIZE);
+  AppendTextColumn("Value");
+  AddRow(this, "Shuffle Doors");
+  AddRow(this, "Group Doors");
+  AddRow(this, "Location Checks");
+  AddRow(this, "Shuffle Colors");
+  AddRow(this, "Shuffle Panels");
+  AddRow(this, "Shuffle Paintings");
+  AddRow(this, "Victory Condition");
+  AddRow(this, "Early Color Hallways");
+  AddRow(this, "Shuffle Postgame");
+  AddRow(this, "Enable Pilgrimage");
+  AddRow(this, "Pilgrimage Roof Access");
+  AddRow(this, "Pilgrimage Paintings");
+  AddRow(this, "Sunwarp Access");
+  AddRow(this, "Shuffle Sunwarps");
+  AddRow(this, "Mastery Achievements");
+  AddRow(this, "Level 2 Requirement");
+}
+
+void OptionsPane::OnConnect() {
+  SetTextValue(kDoorShuffleLabels[static_cast<size_t>(AP_GetDoorShuffleMode())],
+               0, 1);
+  SetTextValue(AP_AreDoorsGrouped() ? "Yes" : "No", 1, 1);
+  SetTextValue(
+      kLocationChecksLabels[static_cast<size_t>(AP_GetLocationsChecks())], 2,
+      1);
+  SetTextValue(AP_IsColorShuffle() ? "Yes" : "No", 3, 1);
+  SetTextValue(
+      kPanelShuffleLabels[static_cast<size_t>(AP_GetPanelShuffleMode())], 4, 1);
+  SetTextValue(AP_IsPaintingShuffle() ? "Yes" : "No", 5, 1);
+  SetTextValue(
+      kVictoryConditionLabels[static_cast<size_t>(AP_GetVictoryCondition())], 6,
+      1);
+  SetTextValue(AP_HasEarlyColorHallways() ? "Yes" : "No", 7, 1);
+  SetTextValue(AP_IsPostgameShuffle() ? "Yes" : "No", 8, 1);
+  SetTextValue(AP_IsPilgrimageEnabled() ? "Yes" : "No", 9, 1);
+  SetTextValue(AP_DoesPilgrimageAllowRoofAccess() ? "Yes" : "No", 10, 1);
+  SetTextValue(AP_DoesPilgrimageAllowPaintings() ? "Yes" : "No", 11, 1);
+  SetTextValue(kSunwarpAccessLabels[static_cast<size_t>(AP_GetSunwarpAccess())],
+               12, 1);
+  SetTextValue(AP_IsSunwarpShuffle() ? "Yes" : "No", 13, 1);
+  SetTextValue(std::to_string(AP_GetMasteryRequirement()), 14, 1);
+  SetTextValue(std::to_string(AP_GetLevel2Requirement()), 15, 1);
+}
@@ -0,0 +1,19 @@
+#ifndef OPTIONS_PANE_H_026A0EC0
+#define OPTIONS_PANE_H_026A0EC0
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <wx/dataview.h>
+
+class OptionsPane : public wxDataViewListCtrl {
+ public:
+  explicit OptionsPane(wxWindow* parent);
+
+  void OnConnect();
+};
+
+#endif /* end of include guard: OPTIONS_PANE_H_026A0EC0 */
@@ -0,0 +1,86 @@
+#include "paintings_pane.h"
+
+#include <fmt/core.h>
+#include <wx/dataview.h>
+
+#include <map>
+#include <set>
+
+#include "ap_state.h"
+#include "game_data.h"
+#include "tracker_state.h"
+
+namespace {
+
+std::string GetPaintingDisplayName(const std::string& id) {
+  const PaintingExit& painting = GD_GetPaintingExit(GD_GetPaintingByName(id));
+  const MapArea& map_area = GD_GetMapArea(painting.map_area);
+
+  return fmt::format("{} - {}", map_area.name, painting.display_name);
+}
+
+}  // namespace
+
+PaintingsPane::PaintingsPane(wxWindow* parent) : wxPanel(parent, wxID_ANY) {
+  wxStaticText* label = new wxStaticText(
+      this, wxID_ANY, "Shuffled paintings grouped by destination:");
+  tree_ctrl_ = new wxDataViewTreeCtrl(this, wxID_ANY);
+
+  reveal_btn_ = new wxButton(this, wxID_ANY, "Reveal shuffled paintings");
+  reveal_btn_->Disable();
+
+  wxBoxSizer* top_sizer = new wxBoxSizer(wxVERTICAL);
+  top_sizer->Add(label, wxSizerFlags().Border());
+  top_sizer->Add(tree_ctrl_, wxSizerFlags().Expand().Proportion(1));
+  top_sizer->Add(reveal_btn_, wxSizerFlags().Border().Expand());
+
+  SetSizerAndFit(top_sizer);
+
+  tree_ctrl_->Bind(wxEVT_DATAVIEW_ITEM_START_EDITING,
+                   &PaintingsPane::OnStartEditingCell, this);
+  reveal_btn_->Bind(wxEVT_BUTTON, &PaintingsPane::OnClickRevealPaintings, this);
+}
+
+void PaintingsPane::ResetIndicators() {
+  tree_ctrl_->DeleteAllItems();
+  reveal_btn_->Enable(AP_IsPaintingShuffle());
+}
+
+void PaintingsPane::UpdateIndicators(const std::vector<std::string>&) {
+  // TODO: Optimize this by using the paintings delta.
+
+  tree_ctrl_->DeleteAllItems();
+
+  std::map<std::string, std::set<std::string>> grouped_paintings;
+
+  for (const auto& [from, to] : AP_GetPaintingMapping()) {
+    if (IsPaintingReachable(GD_GetPaintingByName(from)) &&
+        AP_IsPaintingChecked(from)) {
+      grouped_paintings[GetPaintingDisplayName(to)].insert(
+          GetPaintingDisplayName(from));
+    }
+  }
+
+  for (const auto& [to, froms] : grouped_paintings) {
+    wxDataViewItem tree_branch =
+        tree_ctrl_->AppendContainer(wxDataViewItem(0), to);
+
+    for (const std::string& from : froms) {
+      tree_ctrl_->AppendItem(tree_branch, from);
+    }
+  }
+}
+
+void PaintingsPane::OnClickRevealPaintings(wxCommandEvent& event) {
+  if (wxMessageBox("Clicking yes will reveal the mapping between all shuffled "
+                   "paintings. This is usually considered a spoiler, and is "
+                   "likely not allowed during competitions. This action is not "
+                   "reversible. Are you sure you want to proceed?",
+                   "Warning", wxYES_NO | wxICON_WARNING) == wxNO) {
+    return;
+  }
+
+  AP_RevealPaintings();
+}
+
+void PaintingsPane::OnStartEditingCell(wxDataViewEvent& event) { event.Veto(); }
@@ -0,0 +1,28 @@
+#ifndef PAINTINGS_PANE_H_815370D2
+#define PAINTINGS_PANE_H_815370D2
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+class wxDataViewEvent;
+class wxDataViewTreeCtrl;
+
+class PaintingsPane : public wxPanel {
+ public:
+  explicit PaintingsPane(wxWindow* parent);
+
+  void ResetIndicators();
+  void UpdateIndicators(const std::vector<std::string>& paintings);
+
+ private:
+  void OnClickRevealPaintings(wxCommandEvent& event);
+  void OnStartEditingCell(wxDataViewEvent& event);
+
+  wxDataViewTreeCtrl* tree_ctrl_;
+  wxButton* reveal_btn_;
+};
+
+#endif /* end of include guard: PAINTINGS_PANE_H_815370D2 */
@@ -0,0 +1,131 @@
+#include "report_popup.h"
+
+#include <wx/dcbuffer.h>
+
+#include <map>
+#include <string>
+
+#include "global.h"
+#include "icons.h"
+#include "tracker_state.h"
+
+ReportPopup::ReportPopup(wxWindow* parent)
+    : wxScrolledCanvas(parent, wxID_ANY) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
+  LoadIcons();
+
+  // TODO: This is slow on high-DPI screens.
+  SetScrollRate(5, 5);
+
+  SetBackgroundColour(*wxBLACK);
+  Hide();
+
+  Bind(wxEVT_PAINT, &ReportPopup::OnPaint, this);
+  Bind(wxEVT_DPI_CHANGED, &ReportPopup::OnDPIChanged, this);
+}
+
+void ReportPopup::SetDoorId(int door_id) {
+  door_id_ = door_id;
+
+  ResetIndicators();
+}
+
+void ReportPopup::Reset() {
+  door_id_ = -1;
+}
+
+void ReportPopup::ResetIndicators() {
+  if (door_id_ == -1) {
+    return;
+  }
+
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  const std::map<std::string, bool>& report = GetDoorRequirements(door_id_);
+
+  wxMemoryDC mem_dc;
+  mem_dc.SetFont(the_font);
+
+  int acc_height = FromDIP(10);
+  int col_width = 0;
+
+  for (const auto& [text, obtained] : report) {
+    wxSize item_extent = mem_dc.GetTextExtent(text);
+    int item_height =
+        std::max(FromDIP(32), item_extent.GetHeight()) + FromDIP(10);
+    acc_height += item_height;
+
+    if (item_extent.GetWidth() > col_width) {
+      col_width = item_extent.GetWidth();
+    }
+  }
+
+  int item_width = col_width + FromDIP(10 + 32);
+  full_width_ = item_width + FromDIP(20);
+  full_height_ = acc_height;
+
+  Fit();
+  SetVirtualSize(full_width_, full_height_);
+
+  UpdateIndicators();
+}
+
+void ReportPopup::UpdateIndicators() {
+  if (door_id_ == -1) {
+    return;
+  }
+
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  const std::map<std::string, bool>& report = GetDoorRequirements(door_id_);
+
+  rendered_ = wxBitmap(full_width_, full_height_);
+
+  wxMemoryDC mem_dc;
+  mem_dc.SelectObject(rendered_);
+  mem_dc.SetPen(*wxTRANSPARENT_PEN);
+  mem_dc.SetBrush(*wxBLACK_BRUSH);
+  mem_dc.DrawRectangle({0, 0}, {full_width_, full_height_});
+
+  mem_dc.SetFont(the_font);
+
+  int cur_height = FromDIP(10);
+
+  for (const auto& [text, obtained] : report) {
+    const wxBitmap* eye_ptr = obtained ? checked_eye_ : unchecked_eye_;
+
+    mem_dc.DrawBitmap(*eye_ptr, wxPoint{FromDIP(10), cur_height});
+
+    mem_dc.SetTextForeground(obtained ? *wxWHITE : *wxRED);
+    wxSize item_extent = mem_dc.GetTextExtent(text);
+    mem_dc.DrawText(
+        text, wxPoint{FromDIP(10 + 32 + 10),
+                      cur_height +
+                          (FromDIP(32) - mem_dc.GetFontMetrics().height) / 2});
+
+    cur_height += FromDIP(10 + 32);
+  }
+}
+
+void ReportPopup::OnPaint(wxPaintEvent& event) {
+  if (door_id_ != -1) {
+    wxBufferedPaintDC dc(this);
+    PrepareDC(dc);
+    dc.DrawBitmap(rendered_, 0, 0);
+  }
+
+  event.Skip();
+}
+
+void ReportPopup::OnDPIChanged(wxDPIChangedEvent& event) {
+  LoadIcons();
+  ResetIndicators();
+
+  event.Skip();
+}
+
+void ReportPopup::LoadIcons() {
+  unchecked_eye_ = GetTheIconCache().GetIcon("assets/unchecked.png",
+                                             FromDIP(wxSize{32, 32}));
+  checked_eye_ =
+      GetTheIconCache().GetIcon("assets/checked.png", FromDIP(wxSize{32, 32}));
+}
@@ -0,0 +1,38 @@
+#ifndef REPORT_POPUP_H_E065BED4
+#define REPORT_POPUP_H_E065BED4
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+class ReportPopup : public wxScrolledCanvas {
+ public:
+  explicit ReportPopup(wxWindow* parent);
+
+  void SetDoorId(int door_id);
+
+  void Reset();
+
+  void ResetIndicators();
+  void UpdateIndicators();
+
+ private:
+  void OnPaint(wxPaintEvent& event);
+  void OnDPIChanged(wxDPIChangedEvent& event);
+
+  void LoadIcons();
+
+  int door_id_ = -1;
+
+  const wxBitmap* unchecked_eye_;
+  const wxBitmap* checked_eye_;
+
+  int full_width_ = 0;
+  int full_height_ = 0;
+
+  wxBitmap rendered_;
+};
+
+#endif /* end of include guard: REPORT_POPUP_H_E065BED4 */
@@ -3,30 +3,43 @@
 #include "tracker_config.h"
 
 SettingsDialog::SettingsDialog() : wxDialog(nullptr, wxID_ANY, "Settings") {
-  should_check_for_updates_box_ = new wxCheckBox(
-      this, wxID_ANY, "Check for updates when the tracker opens");
+  wxStaticBoxSizer* main_box =
+      new wxStaticBoxSizer(wxVERTICAL, this, "General settings");
+
+  should_check_for_updates_box_ =
+      new wxCheckBox(main_box->GetStaticBox(), wxID_ANY,
+                     "Check for updates when the tracker opens");
   hybrid_areas_box_ = new wxCheckBox(
-      this, wxID_ANY,
+      main_box->GetStaticBox(), wxID_ANY,
       "Use two colors to show that an area has partial availability");
-  show_hunt_panels_box_ = new wxCheckBox(this, wxID_ANY, "Show hunt panels");
+  track_position_box_ = new wxCheckBox(main_box->GetStaticBox(), wxID_ANY,
+                                       "Track player position");
 
   should_check_for_updates_box_->SetValue(
       GetTrackerConfig().should_check_for_updates);
   hybrid_areas_box_->SetValue(GetTrackerConfig().hybrid_areas);
-  show_hunt_panels_box_->SetValue(GetTrackerConfig().show_hunt_panels);
+  track_position_box_->SetValue(GetTrackerConfig().track_position);
+
+  main_box->Add(should_check_for_updates_box_, wxSizerFlags().Border());
+  main_box->AddSpacer(2);
+  main_box->Add(hybrid_areas_box_, wxSizerFlags().Border());
+  main_box->AddSpacer(2);
+  main_box->Add(track_position_box_, wxSizerFlags().Border());
+
+  const wxString visible_panels_choices[] = {"Only show locations",
+                                             "Show locations and hunt panels",
+                                             "Show all panels"};
+  visible_panels_box_ =
+      new wxRadioBox(this, wxID_ANY, "Visible panels", wxDefaultPosition,
+                     wxDefaultSize, 3, visible_panels_choices, 1);
+  visible_panels_box_->SetSelection(
+      static_cast<int>(GetTrackerConfig().visible_panels));
 
   wxBoxSizer* form_sizer = new wxBoxSizer(wxVERTICAL);
-
-  form_sizer->Add(should_check_for_updates_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(hybrid_areas_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(show_hunt_panels_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), wxSizerFlags().Center());
+  form_sizer->Add(main_box, wxSizerFlags().Border().Expand());
+  form_sizer->Add(visible_panels_box_, wxSizerFlags().Border().Expand());
+  form_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL),
+                  wxSizerFlags().Center().Border());
 
   SetSizerAndFit(form_sizer);
 
@@ -7,6 +7,10 @@
 #include <wx/wx.h>
 #endif
 
+#include <wx/radiobox.h>
+
+#include "tracker_config.h"
+
 class SettingsDialog : public wxDialog {
  public:
   SettingsDialog();
@@ -15,12 +19,17 @@ class SettingsDialog : public wxDialog {
     return should_check_for_updates_box_->GetValue();
   }
   bool GetHybridAreas() const { return hybrid_areas_box_->GetValue(); }
-  bool GetShowHuntPanels() const { return show_hunt_panels_box_->GetValue(); }
+  TrackerConfig::VisiblePanels GetVisiblePanels() const {
+    return static_cast<TrackerConfig::VisiblePanels>(
+        visible_panels_box_->GetSelection());
+  }
+  bool GetTrackPosition() const { return track_position_box_->GetValue(); }
 
  private:
   wxCheckBox* should_check_for_updates_box_;
   wxCheckBox* hybrid_areas_box_;
-  wxCheckBox* show_hunt_panels_box_;
+  wxRadioBox* visible_panels_box_;
+  wxCheckBox* track_position_box_;
 };
 
 #endif /* end of include guard: SETTINGS_DIALOG_H_D8635719 */
@@ -9,12 +9,28 @@
 #include "ap_state.h"
 #include "game_data.h"
 #include "global.h"
+#include "report_popup.h"
 #include "tracker_state.h"
 
 constexpr int AREA_ACTUAL_SIZE = 21;
 constexpr int OWL_ACTUAL_SIZE = 32;
+constexpr int PAINTING_RADIUS = 9; // the actual circles on the map are radius 11
+constexpr int PAINTING_EXIT_RADIUS = 6;
 
-enum class ItemDrawType { kNone, kBox, kOwl };
+enum class ItemDrawType { kNone, kBox, kOwl, kOwlExit };
+
+namespace {
+
+wxPoint GetSubwayItemMapCenter(const SubwayItem &subway_item) {
+  if (subway_item.painting) {
+    return {subway_item.x, subway_item.y};
+  } else {
+    return {subway_item.x + AREA_ACTUAL_SIZE / 2,
+            subway_item.y + AREA_ACTUAL_SIZE / 2};
+  }
+}
+
+}  // namespace
 
 SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
   SetBackgroundStyle(wxBG_STYLE_PAINT);
@@ -31,14 +47,6 @@ SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
     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())});
@@ -57,12 +65,14 @@ SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
   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_ = new wxSlider(this, wxID_ANY, 0, 0, 8, FromDIP(wxPoint{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();
+
+  report_popup_ = new ReportPopup(this);
 }
 
 void SubwayMap::OnConnect() {
@@ -73,11 +83,11 @@ void SubwayMap::OnConnect() {
   std::map<std::string, std::vector<int>> exits;
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     if (AP_HasEarlyColorHallways() &&
-        subway_item.special == "starting_room_paintings") {
+        subway_item.special == "early_color_hallways") {
       entrances["early_ch"].push_back(subway_item.id);
     }
 
-    if (AP_IsPaintingShuffle() && !subway_item.paintings.empty()) {
+    if (AP_IsPaintingShuffle() && subway_item.painting) {
       continue;
     }
 
@@ -174,6 +184,8 @@ void SubwayMap::OnConnect() {
   }
 
   checked_paintings_.clear();
+
+  UpdateIndicators();
 }
 
 void SubwayMap::UpdateIndicators() {
@@ -202,6 +214,8 @@ void SubwayMap::UpdateIndicators() {
     }
   }
 
+  report_popup_->UpdateIndicators();
+
   Redraw();
 }
 
@@ -255,6 +269,9 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
     SetZoomPos({zoom_x_, zoom_y_});
 
     SetUpHelpButton();
+
+    zoom_slider_->SetSize(FromDIP(15), FromDIP(15), wxDefaultCoord,
+                          wxDefaultCoord, wxSIZE_AUTO);
   }
 
   wxBufferedPaintDC dc(this);
@@ -310,67 +327,6 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
   }
 
   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_);
-    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
-
-    if (subway_door && !GetDoorRequirements(*subway_door).empty()) {
-      const std::map<std::string, bool> &report =
-          GetDoorRequirements(*subway_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);
 
@@ -378,10 +334,8 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
         const SubwayItem &item1 = GD_GetSubwayItem(node.entry);
         const SubwayItem &item2 = GD_GetSubwayItem(node.exit);
 
-        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});
+        wxPoint item1_pos = MapPosToRenderPos(GetSubwayItemMapCenter(item1));
+        wxPoint item2_pos = MapPosToRenderPos(GetSubwayItemMapCenter(item2));
 
         int left = std::min(item1_pos.x, item2_pos.x);
         int top = std::min(item1_pos.y, item2_pos.y);
@@ -470,9 +424,7 @@ void SubwayMap::OnMouseMove(wxMouseEvent &event) {
   }
 
   if (!sticky_hover_ && actual_hover_ != hovered_item_) {
-    hovered_item_ = actual_hover_;
-
-    Refresh();
+    EvaluateHover();
   }
 
   if (scroll_mode_) {
@@ -514,13 +466,11 @@ void SubwayMap::OnMouseClick(wxMouseEvent &event) {
     if ((subway_door && !GetDoorRequirements(*subway_door).empty()) ||
         networks_.IsItemInNetwork(*hovered_item_)) {
       if (actual_hover_ != hovered_item_) {
-        hovered_item_ = actual_hover_;
+        EvaluateHover();
 
         if (!hovered_item_) {
           sticky_hover_ = false;
         }
-
-        Refresh();
       } else {
         sticky_hover_ = !sticky_hover_;
       }
@@ -571,11 +521,12 @@ void SubwayMap::OnClickHelp(wxCommandEvent &event) {
       "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.\nFor one-way connections, there will be a "
-      "circle at the exit.\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.",
+      "circle at the exit.\nCircles represent paintings.\nA red circle means "
+      "that the painting is locked by a door.\nA blue circle means painting "
+      "shuffle is enabled and the painting has not been checked yet.\nA black "
+      "circle means the painting is not a warp.\nA green circle means that the "
+      "painting is a warp.\nPainting exits will be indicated with an X.\nClick "
+      "on a door or warp to make the popup stick until you click again.",
       "Subway Map Help");
 }
 
@@ -592,20 +543,32 @@ void SubwayMap::Redraw() {
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     ItemDrawType draw_type = ItemDrawType::kNone;
     const wxBrush *brush_color = wxGREY_BRUSH;
-    std::optional<wxColour> shade_color;
     std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
 
     if (AP_HasEarlyColorHallways() &&
-        subway_item.special == "starting_room_paintings") {
+        subway_item.special == "early_color_hallways") {
       draw_type = ItemDrawType::kOwl;
-      shade_color = wxColour(0, 255, 0, 128);
+      brush_color = wxGREEN_BRUSH;
+    } else if (subway_item.special == "starting_room_overhead") {
+      // Do not draw.
+    } else if (AP_IsColorShuffle() && subway_item.special &&
+               subway_item.special->starts_with("color_")) {
+      std::string color_name = subway_item.special->substr(6);
+      LingoColor lingo_color = GetLingoColorForString(color_name);
+      int color_item_id = GD_GetItemIdForColor(lingo_color);
+
+      draw_type = ItemDrawType::kBox;
+      if (AP_HasItemSafe(color_item_id)) {
+        brush_color = wxGREEN_BRUSH;
+      } else {
+        brush_color = wxRED_BRUSH;
+      }
     } else if (subway_item.special == "sun_painting") {
       if (!AP_IsPilgrimageEnabled()) {
+        draw_type = ItemDrawType::kOwl;
         if (IsDoorOpen(*subway_item.door)) {
-          draw_type = ItemDrawType::kOwl;
-          shade_color = wxColour(0, 255, 0, 128);
+          brush_color = wxGREEN_BRUSH;
         } else {
-          draw_type = ItemDrawType::kBox;
           brush_color = wxRED_BRUSH;
         }
       }
@@ -619,41 +582,28 @@ void SubwayMap::Redraw() {
       } else {
         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 (painting_mapping.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) {
+    } else if (subway_item.painting) {
+      if (subway_door && !IsDoorOpen(*subway_door)) {
+        draw_type = ItemDrawType::kOwl;
+        brush_color = wxRED_BRUSH;
+      } else if (AP_IsPaintingShuffle()) {
+        if (!checked_paintings_.count(*subway_item.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);
-            }
-          }
+          brush_color = wxBLUE_BRUSH;
+        } else if (painting_mapping.count(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwl;
+          brush_color = wxGREEN_BRUSH;
+        } else if (AP_IsPaintingMappedTo(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwlExit;
+          brush_color = wxGREEN_BRUSH;
         }
       } else if (subway_item.HasWarps()) {
-        draw_type = ItemDrawType::kOwl;
+        brush_color = wxGREEN_BRUSH;
+        if (!subway_item.exits.empty()) {
+          draw_type = ItemDrawType::kOwlExit;
+        } else {
+          draw_type = ItemDrawType::kOwl;
+        }
       }
     } else if (subway_door) {
       draw_type = ItemDrawType::kBox;
@@ -673,21 +623,40 @@ void SubwayMap::Redraw() {
     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));
+
+      if (subway_item.tilted) {
+        constexpr int AREA_TILTED_SIDE =
+            static_cast<int>(AREA_ACTUAL_SIZE / 1.41421356237);
+        const wxPoint poly_points[] = {{AREA_TILTED_SIDE, 0},
+                                       {2 * AREA_TILTED_SIDE, AREA_TILTED_SIDE},
+                                       {AREA_TILTED_SIDE, 2 * AREA_TILTED_SIDE},
+                                       {0, AREA_TILTED_SIDE}};
+        gcdc.DrawPolygon(4, poly_points, subway_item.x, subway_item.y);
+      } else {
         gcdc.DrawRectangle(real_area_pos, {real_area_size, real_area_size});
       }
+    } else if (draw_type == ItemDrawType::kOwl || draw_type == ItemDrawType::kOwlExit) {
+      gcdc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 1));
+      gcdc.SetBrush(*brush_color);
+      gcdc.DrawCircle(real_area_pos, PAINTING_RADIUS);
+
+      if (draw_type == ItemDrawType::kOwlExit) {
+        gcdc.DrawLine(subway_item.x - PAINTING_EXIT_RADIUS,
+                      subway_item.y - PAINTING_EXIT_RADIUS,
+                      subway_item.x + PAINTING_EXIT_RADIUS,
+                      subway_item.y + PAINTING_EXIT_RADIUS);
+        gcdc.DrawLine(subway_item.x + PAINTING_EXIT_RADIUS,
+                      subway_item.y - PAINTING_EXIT_RADIUS,
+                      subway_item.x - PAINTING_EXIT_RADIUS,
+                      subway_item.y + PAINTING_EXIT_RADIUS);
+      }
     }
   }
 }
 
 void SubwayMap::SetUpHelpButton() {
+  help_button_->SetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord,
+                        wxDefaultCoord, wxSIZE_AUTO);
   help_button_->SetPosition({
       GetSize().GetWidth() - help_button_->GetSize().GetWidth() - 15,
       15,
@@ -723,6 +692,51 @@ void SubwayMap::EvaluateScroll(wxPoint pos) {
   SetScrollSpeed(scroll_x, scroll_y);
 }
 
+void SubwayMap::EvaluateHover() {
+  hovered_item_ = actual_hover_;
+
+  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_);
+    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
+
+    if (subway_door && !GetDoorRequirements(*subway_door).empty()) {
+      report_popup_->SetDoorId(*subway_door);
+
+      wxPoint popupPos =
+          MapPosToRenderPos({subway_item.x + AREA_ACTUAL_SIZE / 2,
+                             subway_item.y + AREA_ACTUAL_SIZE / 2});
+
+      report_popup_->SetClientSize(
+          report_popup_->GetVirtualSize().GetWidth(),
+          std::min(GetSize().GetHeight(),
+                   report_popup_->GetVirtualSize().GetHeight()));
+
+      if (popupPos.x + report_popup_->GetSize().GetWidth() >
+          GetSize().GetWidth()) {
+        popupPos.x = GetSize().GetWidth() - report_popup_->GetSize().GetWidth();
+      }
+      if (popupPos.y + report_popup_->GetSize().GetHeight() >
+          GetSize().GetHeight()) {
+        popupPos.y =
+            GetSize().GetHeight() - report_popup_->GetSize().GetHeight();
+      }
+      report_popup_->SetPosition(popupPos);
+
+      report_popup_->Show();
+    } else {
+      report_popup_->Reset();
+      report_popup_->Hide();
+    }
+  } else {
+    report_popup_->Reset();
+    report_popup_->Hide();
+  }
+
+  Refresh();
+}
+
 wxPoint SubwayMap::MapPosToRenderPos(wxPoint pos) const {
   return {static_cast<int>(pos.x * render_width_ * zoom_ /
                                map_image_.GetSize().GetWidth() +
@@ -812,6 +826,13 @@ std::optional<int> SubwayMap::GetRealSubwayDoor(const SubwayItem subway_item) {
 
 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};
+  if (subway_item.painting) {
+    return {static_cast<float>(subway_item.x) - PAINTING_RADIUS,
+            static_cast<float>(subway_item.y) - PAINTING_RADIUS,
+            PAINTING_RADIUS * 2, PAINTING_RADIUS * 2};
+  } else {
+    return {static_cast<float>(subway_item.x),
+            static_cast<float>(subway_item.y), AREA_ACTUAL_SIZE,
+            AREA_ACTUAL_SIZE};
+  }
 }
@@ -19,6 +19,8 @@
 #include "game_data.h"
 #include "network_set.h"
 
+class ReportPopup;
+
 class SubwayMap : public wxPanel {
  public:
   SubwayMap(wxWindow *parent);
@@ -46,6 +48,7 @@ class SubwayMap : public wxPanel {
   wxPoint RenderPosToMapPos(wxPoint pos) const;
 
   void EvaluateScroll(wxPoint pos);
+  void EvaluateHover();
 
   void SetZoomPos(wxPoint pos);
   void SetScrollSpeed(int scroll_x, int scroll_y);
@@ -55,8 +58,6 @@ class SubwayMap : public wxPanel {
 
   wxImage map_image_;
   wxImage owl_image_;
-  wxBitmap unchecked_eye_;
-  wxBitmap checked_eye_;
 
   wxBitmap rendered_;
   int render_x_ = 0;
@@ -88,6 +89,8 @@ class SubwayMap : public wxPanel {
   std::optional<int> actual_hover_;
   bool sticky_hover_ = false;
 
+  ReportPopup *report_popup_;
+
   NetworkSet networks_;
   std::set<std::string> checked_paintings_;
 
@@ -16,7 +16,9 @@ void TrackerConfig::Load() {
     asked_to_check_for_updates = file["asked_to_check_for_updates"].as<bool>();
     should_check_for_updates = file["should_check_for_updates"].as<bool>();
     hybrid_areas = file["hybrid_areas"].as<bool>();
-    show_hunt_panels = file["show_hunt_panels"].as<bool>();
+    if (file["show_hunt_panels"] && file["show_hunt_panels"].as<bool>()) {
+      visible_panels = kHUNT_PANELS;
+    }
 
     if (file["connection_history"]) {
       for (const auto& connection : file["connection_history"]) {
@@ -29,6 +31,9 @@ void TrackerConfig::Load() {
     }
 
     ipc_address = file["ipc_address"].as<std::string>();
+    track_position = file["track_position"].as<bool>();
+    visible_panels =
+        static_cast<VisiblePanels>(file["visible_panels"].as<int>());
   } catch (const std::exception&) {
     // It's fine if the file can't be loaded.
   }
@@ -42,7 +47,6 @@ void TrackerConfig::Save() {
   output["asked_to_check_for_updates"] = asked_to_check_for_updates;
   output["should_check_for_updates"] = should_check_for_updates;
   output["hybrid_areas"] = hybrid_areas;
-  output["show_hunt_panels"] = show_hunt_panels;
   
   output.remove("connection_history");
   for (const ConnectionDetails& details : connection_history) {
@@ -55,6 +59,8 @@ void TrackerConfig::Save() {
   }
 
   output["ipc_address"] = ipc_address;
+  output["track_position"] = track_position;
+  output["visible_panels"] = static_cast<int>(visible_panels);
 
   std::ofstream filewriter(filename_);
   filewriter << output;
@@ -23,13 +23,20 @@ class TrackerConfig {
 
   void Save();
 
+  enum VisiblePanels {
+    kLOCATIONS_ONLY,
+    kHUNT_PANELS,
+    kALL_PANELS,
+  };
+
   ConnectionDetails connection_details;
   bool asked_to_check_for_updates = false;
   bool should_check_for_updates = false;
   bool hybrid_areas = false;
-  bool show_hunt_panels = false;
   std::deque<ConnectionDetails> connection_history;
   std::string ipc_address;
+  bool track_position = true;
+  VisiblePanels visible_panels = kLOCATIONS_ONLY;
 
  private:
   std::string filename_;
@@ -5,9 +5,11 @@
 #include <wx/choicebk.h>
 #include <wx/filedlg.h>
 #include <wx/notebook.h>
+#include <wx/splitter.h>
 #include <wx/stdpaths.h>
 #include <wx/webrequest.h>
 
+#include <algorithm>
 #include <nlohmann/json.hpp>
 #include <sstream>
 
@@ -16,6 +18,11 @@
 #include "connection_dialog.h"
 #include "ipc_dialog.h"
 #include "ipc_state.h"
+#include "items_pane.h"
+#include "log_dialog.h"
+#include "logger.h"
+#include "options_pane.h"
+#include "paintings_pane.h"
 #include "settings_dialog.h"
 #include "subway_map.h"
 #include "tracker_config.h"
@@ -44,14 +51,13 @@ enum TrackerFrameIds {
   ID_SETTINGS = 3,
   ID_ZOOM_IN = 4,
   ID_ZOOM_OUT = 5,
-  ID_OPEN_SAVE_FILE = 6,
   ID_IPC_CONNECT = 7,
+  ID_LOG_DIALOG = 8,
 };
 
 wxDEFINE_EVENT(STATE_RESET, wxCommandEvent);
-wxDEFINE_EVENT(STATE_CHANGED, wxCommandEvent);
+wxDEFINE_EVENT(STATE_CHANGED, StateChangedEvent);
 wxDEFINE_EVENT(STATUS_CHANGED, wxCommandEvent);
-wxDEFINE_EVENT(REDRAW_POSITION, wxCommandEvent);
 wxDEFINE_EVENT(CONNECT_TO_AP, ApConnectEvent);
 
 TrackerFrame::TrackerFrame()
@@ -62,16 +68,22 @@ TrackerFrame::TrackerFrame()
   AP_SetTrackerFrame(this);
   IPC_SetTrackerFrame(this);
 
+  SetTheIconCache(&icons_);
+
+  updater_ = std::make_unique<Updater>(this);
+  updater_->Cleanup();
+
   wxMenu *menuFile = new wxMenu();
   menuFile->Append(ID_AP_CONNECT, "&Connect to Archipelago");
   menuFile->Append(ID_IPC_CONNECT, "&Connect to Lingo");
-  menuFile->Append(ID_OPEN_SAVE_FILE, "&Open Save Data\tCtrl-O");
   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--");
+  menuView->AppendSeparator();
+  menuView->Append(ID_LOG_DIALOG, "Show Log Window\tCtrl-L");
 
   zoom_in_menu_item_->Enable(false);
   zoom_out_menu_item_->Enable(false);
@@ -98,30 +110,43 @@ TrackerFrame::TrackerFrame()
        ID_CHECK_FOR_UPDATES);
   Bind(wxEVT_MENU, &TrackerFrame::OnZoomIn, this, ID_ZOOM_IN);
   Bind(wxEVT_MENU, &TrackerFrame::OnZoomOut, this, ID_ZOOM_OUT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnOpenLogWindow, this, ID_LOG_DIALOG);
   Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, &TrackerFrame::OnChangePage, this);
-  Bind(wxEVT_MENU, &TrackerFrame::OnOpenFile, this, ID_OPEN_SAVE_FILE);
+  Bind(wxEVT_SPLITTER_SASH_POS_CHANGED, &TrackerFrame::OnSashPositionChanged,
+       this);
   Bind(STATE_RESET, &TrackerFrame::OnStateReset, this);
   Bind(STATE_CHANGED, &TrackerFrame::OnStateChanged, this);
   Bind(STATUS_CHANGED, &TrackerFrame::OnStatusChanged, this);
-  Bind(REDRAW_POSITION, &TrackerFrame::OnRedrawPosition, this);
   Bind(CONNECT_TO_AP, &TrackerFrame::OnConnectToAp, this);
 
-  wxChoicebook *choicebook = new wxChoicebook(this, wxID_ANY);
+  wxSize logicalSize = FromDIP(wxSize(1280, 728));
+
+  splitter_window_ = new wxSplitterWindow(this, wxID_ANY);
+  splitter_window_->SetMinimumPaneSize(logicalSize.x / 5);
+
+  wxChoicebook *choicebook = new wxChoicebook(splitter_window_, wxID_ANY);
+
   achievements_pane_ = new AchievementsPane(choicebook);
   choicebook->AddPage(achievements_pane_, "Achievements");
 
-  notebook_ = new wxNotebook(this, wxID_ANY);
+  items_pane_ = new ItemsPane(choicebook);
+  choicebook->AddPage(items_pane_, "Items");
+
+  options_pane_ = new OptionsPane(choicebook);
+  choicebook->AddPage(options_pane_, "Options");
+
+  paintings_pane_ = new PaintingsPane(choicebook);
+  choicebook->AddPage(paintings_pane_, "Paintings");
+
+  notebook_ = new wxNotebook(splitter_window_, 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(notebook_, wxSizerFlags().Expand().Proportion(3));
+  splitter_window_->SplitVertically(choicebook, notebook_, logicalSize.x / 4);
 
-  SetSizerAndFit(top_sizer);
-  SetSize(1280, 728);
+  SetSize(logicalSize);
 
   if (!GetTrackerConfig().asked_to_check_for_updates) {
     GetTrackerConfig().asked_to_check_for_updates = true;
@@ -138,7 +163,7 @@ TrackerFrame::TrackerFrame()
   }
 
   if (GetTrackerConfig().should_check_for_updates) {
-    CheckForUpdates(/*manual=*/false);
+    updater_->CheckForUpdates(/*invisible=*/true);
   }
 
   SetStatusText(GetStatusMessage());
@@ -158,15 +183,8 @@ void TrackerFrame::ResetIndicators() {
   QueueEvent(new wxCommandEvent(STATE_RESET));
 }
 
-void TrackerFrame::UpdateIndicators(UpdateIndicatorsMode mode) {
-  auto evt = new wxCommandEvent(STATE_CHANGED);
-  evt->SetInt(static_cast<int>(mode));
-
-  QueueEvent(evt);
-}
-
-void TrackerFrame::RedrawPosition() {
-  QueueEvent(new wxCommandEvent(REDRAW_POSITION));
+void TrackerFrame::UpdateIndicators(StateUpdate state) {
+  QueueEvent(new StateChangedEvent(STATE_CHANGED, GetId(), std::move(state)));
 }
 
 void TrackerFrame::OnAbout(wxCommandEvent &event) {
@@ -231,15 +249,18 @@ void TrackerFrame::OnSettings(wxCommandEvent &event) {
     GetTrackerConfig().should_check_for_updates =
         dlg.GetShouldCheckForUpdates();
     GetTrackerConfig().hybrid_areas = dlg.GetHybridAreas();
-    GetTrackerConfig().show_hunt_panels = dlg.GetShowHuntPanels();
+    GetTrackerConfig().visible_panels = dlg.GetVisiblePanels();
+    GetTrackerConfig().track_position = dlg.GetTrackPosition();
     GetTrackerConfig().Save();
 
-    UpdateIndicators();
+    UpdateIndicators(StateUpdate{.cleared_locations = true,
+                                 .player_position = true,
+                                 .changed_settings = true});
   }
 }
 
 void TrackerFrame::OnCheckForUpdates(wxCommandEvent &event) {
-  CheckForUpdates(/*manual=*/true);
+  updater_->CheckForUpdates(/*invisible=*/false);
 }
 
 void TrackerFrame::OnZoomIn(wxCommandEvent &event) {
@@ -254,132 +275,93 @@ void TrackerFrame::OnZoomOut(wxCommandEvent &event) {
   }
 }
 
-void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
-  zoom_in_menu_item_->Enable(event.GetSelection() == 1);
-  zoom_out_menu_item_->Enable(event.GetSelection() == 1);
-}
+void TrackerFrame::OnOpenLogWindow(wxCommandEvent &event) {
+  if (log_dialog_ == nullptr) {
+    log_dialog_ = new LogDialog(this);
+    log_dialog_->Show();
+    TrackerSetLogDialog(log_dialog_);
 
-void TrackerFrame::OnOpenFile(wxCommandEvent &event) {
-  wxFileDialog open_file_dialog(
-      this, "Open Lingo Save File",
-      fmt::format("{}\\Godot\\app_userdata\\Lingo\\level1_stable",
-                  wxStandardPaths::Get().GetUserConfigDir().ToStdString()),
-      AP_GetSaveName(), "Lingo save file (*.save)|*.save",
-      wxFD_OPEN | wxFD_FILE_MUST_EXIST);
-  if (open_file_dialog.ShowModal() == wxID_CANCEL) {
-    return;
+    log_dialog_->Bind(wxEVT_CLOSE_WINDOW, &TrackerFrame::OnCloseLogWindow,
+                      this);
+  } else {
+    log_dialog_->SetFocus();
   }
+}
 
-  std::string savedata_path = open_file_dialog.GetPath().ToStdString();
+void TrackerFrame::OnCloseLogWindow(wxCloseEvent& event) {
+  TrackerSetLogDialog(nullptr);
+  log_dialog_ = nullptr;
 
-  if (panels_panel_ == nullptr) {
-    panels_panel_ = new TrackerPanel(notebook_);
-    notebook_->AddPage(panels_panel_, "Panels");
-  }
+  event.Skip();
+}
 
-  notebook_->SetSelection(notebook_->FindPage(panels_panel_));
-  panels_panel_->SetSavedataPath(savedata_path);
+void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
+  zoom_in_menu_item_->Enable(event.GetSelection() == 1);
+  zoom_out_menu_item_->Enable(event.GetSelection() == 1);
+}
+
+void TrackerFrame::OnSashPositionChanged(wxSplitterEvent& event) {
+  notebook_->Refresh();
 }
 
 void TrackerFrame::OnStateReset(wxCommandEvent &event) {
-  tracker_panel_->UpdateIndicators();
+  tracker_panel_->UpdateIndicators(/*reset=*/true);
   achievements_pane_->UpdateIndicators();
+  items_pane_->ResetIndicators();
+  options_pane_->OnConnect();
+  paintings_pane_->ResetIndicators();
   subway_map_->OnConnect();
-  if (panels_panel_ != nullptr) {
-    notebook_->DeletePage(notebook_->FindPage(panels_panel_));
-    panels_panel_ = nullptr;
-  }
   Refresh();
 }
 
-void TrackerFrame::OnStateChanged(wxCommandEvent &event) {
-  UpdateIndicatorsMode mode = static_cast<UpdateIndicatorsMode>(event.GetInt());
-
-  if (mode == kUPDATE_ALL_INDICATORS) {
-    tracker_panel_->UpdateIndicators();
-    achievements_pane_->UpdateIndicators();
+void TrackerFrame::OnStateChanged(StateChangedEvent &event) {
+  const StateUpdate &state = event.GetState();
+
+  bool hunt_panels = false;
+  if (GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) {
+    hunt_panels = std::any_of(
+        state.panels.begin(), state.panels.end(), [](int solve_index) {
+          return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index)).hunt;
+        });
+  } else if (GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS) {
+    hunt_panels = true;
+  }
+  
+  if (!state.items.empty() || !state.paintings.empty() ||
+      state.cleared_locations || hunt_panels) {
+    // TODO: The only real reason to reset tracker_panel during an active
+    // connection is if the hunt panels setting changes. If we remove hunt
+    // panels later, we can get rid of this.
+    tracker_panel_->UpdateIndicators(/*reset=*/state.changed_settings);
     subway_map_->UpdateIndicators();
-    if (panels_panel_ != nullptr) {
-      panels_panel_->UpdateIndicators();
-    }
     Refresh();
-  } else if (mode == kUPDATE_ONLY_PANELS) {
-    if (panels_panel_ == nullptr) {
-      panels_panel_ = new TrackerPanel(notebook_);
-      panels_panel_->SetPanelsMode();
-      notebook_->AddPage(panels_panel_, "Panels");
-    }
-    panels_panel_->UpdateIndicators();
-    if (notebook_->GetSelection() == 2) {
-      Refresh();
+  } else if (state.player_position && GetTrackerConfig().track_position) {
+    if (notebook_->GetSelection() == 0) {
+      tracker_panel_->Refresh();
     }
   }
-}
 
-void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
-  SetStatusText(GetStatusMessage());
-}
-
-void TrackerFrame::OnRedrawPosition(wxCommandEvent &event) {
-  if (notebook_->GetSelection() == 0) {
-    tracker_panel_->Refresh();
-  } else if (notebook_->GetSelection() == 2) {
-    panels_panel_->Refresh();
+  if (std::any_of(state.panels.begin(), state.panels.end(),
+                  [](int solve_index) {
+                    return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index))
+                        .achievement;
+                  })) {
+    achievements_pane_->UpdateIndicators();
   }
-}
-
-void TrackerFrame::OnConnectToAp(ApConnectEvent &event) {
-  AP_Connect(event.GetServer(), event.GetUser(), event.GetPass());
-}
-
-void TrackerFrame::CheckForUpdates(bool manual) {
-  wxWebRequest request = wxWebSession::GetDefault().CreateRequest(
-      this, "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION");
 
-  if (!request.IsOk()) {
-    if (manual) {
-      wxMessageBox("Could not check for updates.", "Error",
-                   wxOK | wxICON_ERROR);
-    } else {
-      SetStatusText("Could not check for updates.");
-    }
+  if (!state.items.empty()) {
+    items_pane_->UpdateIndicators(state.items);
+  }
 
-    return;
+  if (!state.paintings.empty()) {
+    paintings_pane_->UpdateIndicators(state.paintings);
   }
+}
 
-  Bind(wxEVT_WEBREQUEST_STATE, [this, manual](wxWebRequestEvent &evt) {
-    if (evt.GetState() == wxWebRequest::State_Completed) {
-      std::string response = evt.GetResponse().AsString().ToStdString();
-
-      Version latest_version(response);
-      if (kTrackerVersion < latest_version) {
-        std::ostringstream message_text;
-        message_text << "There is a newer version of Lingo AP Tracker "
-                        "available. You have "
-                     << 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) {
-          wxLaunchDefaultBrowser(
-              "https://code.fourisland.com/lingo-ap-tracker/about/"
-              "CHANGELOG.md");
-        }
-      } else if (manual) {
-        wxMessageBox("Lingo AP Tracker is up to date!", "Lingo AP Tracker",
-                     wxOK);
-      }
-    } else if (evt.GetState() == wxWebRequest::State_Failed) {
-      if (manual) {
-        wxMessageBox("Could not check for updates.", "Error",
-                     wxOK | wxICON_ERROR);
-      } else {
-        SetStatusText("Could not check for updates.");
-      }
-    }
-  });
+void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
+  SetStatusText(wxString::FromUTF8(GetStatusMessage()));
+}
 
-  request.Start();
+void TrackerFrame::OnConnectToAp(ApConnectEvent &event) {
+  AP_Connect(event.GetServer(), event.GetUser(), event.GetPass());
 }
@@ -7,11 +7,24 @@
 #include <wx/wx.h>
 #endif
 
+#include <memory>
+#include <set>
+
+#include "ap_state.h"
+#include "icons.h"
+#include "updater.h"
+
 class AchievementsPane;
+class ItemsPane;
+class LogDialog;
+class OptionsPane;
+class PaintingsPane;
 class SubwayMap;
 class TrackerPanel;
 class wxBookCtrlEvent;
 class wxNotebook;
+class wxSplitterEvent;
+class wxSplitterWindow;
 
 class ApConnectEvent : public wxEvent {
  public:
@@ -36,17 +49,34 @@ class ApConnectEvent : public wxEvent {
   std::string ap_pass_;
 };
 
+struct StateUpdate {
+  std::vector<ItemState> items;
+  bool progression_items = false;
+  std::vector<std::string> paintings;
+  bool cleared_locations = false;
+  std::set<int> panels;
+  bool player_position = false;
+  bool changed_settings = false;
+};
+
+class StateChangedEvent : public wxEvent {
+ public:
+  StateChangedEvent(wxEventType eventType, int winid, StateUpdate state)
+      : wxEvent(winid, eventType), state_(std::move(state)) {}
+
+  const StateUpdate &GetState() const { return state_; }
+
+  virtual wxEvent *Clone() const { return new StateChangedEvent(*this); }
+
+ private:
+  StateUpdate state_;
+};
+
 wxDECLARE_EVENT(STATE_RESET, wxCommandEvent);
-wxDECLARE_EVENT(STATE_CHANGED, wxCommandEvent);
+wxDECLARE_EVENT(STATE_CHANGED, StateChangedEvent);
 wxDECLARE_EVENT(STATUS_CHANGED, wxCommandEvent);
-wxDECLARE_EVENT(REDRAW_POSITION, wxCommandEvent);
 wxDECLARE_EVENT(CONNECT_TO_AP, ApConnectEvent);
 
-enum UpdateIndicatorsMode {
-  kUPDATE_ALL_INDICATORS = 0,
-  kUPDATE_ONLY_PANELS = 1,
-};
-
 class TrackerFrame : public wxFrame {
  public:
   TrackerFrame();
@@ -55,8 +85,7 @@ class TrackerFrame : public wxFrame {
   void UpdateStatusMessage();
 
   void ResetIndicators();
-  void UpdateIndicators(UpdateIndicatorsMode mode = kUPDATE_ALL_INDICATORS);
-  void RedrawPosition();
+  void UpdateIndicators(StateUpdate state);
 
  private:
   void OnExit(wxCommandEvent &event);
@@ -67,25 +96,32 @@ class TrackerFrame : public wxFrame {
   void OnCheckForUpdates(wxCommandEvent &event);
   void OnZoomIn(wxCommandEvent &event);
   void OnZoomOut(wxCommandEvent &event);
+  void OnOpenLogWindow(wxCommandEvent &event);
+  void OnCloseLogWindow(wxCloseEvent &event);
   void OnChangePage(wxBookCtrlEvent &event);
-  void OnOpenFile(wxCommandEvent &event);
+  void OnSashPositionChanged(wxSplitterEvent &event);
 
   void OnStateReset(wxCommandEvent &event);
-  void OnStateChanged(wxCommandEvent &event);
+  void OnStateChanged(StateChangedEvent &event);
   void OnStatusChanged(wxCommandEvent &event);
-  void OnRedrawPosition(wxCommandEvent &event);
   void OnConnectToAp(ApConnectEvent &event);
+  
+  std::unique_ptr<Updater> updater_;
 
-  void CheckForUpdates(bool manual);
-
+  wxSplitterWindow *splitter_window_;
   wxNotebook *notebook_;
   TrackerPanel *tracker_panel_;
   AchievementsPane *achievements_pane_;
+  ItemsPane *items_pane_;
+  OptionsPane *options_pane_;
+  PaintingsPane *paintings_pane_;
   SubwayMap *subway_map_;
-  TrackerPanel *panels_panel_ = nullptr;
+  LogDialog *log_dialog_ = nullptr;
 
   wxMenuItem *zoom_in_menu_item_;
   wxMenuItem *zoom_out_menu_item_;
+
+  IconCache icons_;
 };
 
 #endif /* end of include guard: TRACKER_FRAME_H_86BD8DFB */
@@ -9,7 +9,6 @@
 #include "area_popup.h"
 #include "game_data.h"
 #include "global.h"
-#include "godot_variant.h"
 #include "ipc_state.h"
 #include "tracker_config.h"
 #include "tracker_state.h"
@@ -44,58 +43,46 @@ TrackerPanel::TrackerPanel(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
     areas_.push_back(area);
   }
 
+  Resize();
   Redraw();
 
   Bind(wxEVT_PAINT, &TrackerPanel::OnPaint, this);
   Bind(wxEVT_MOTION, &TrackerPanel::OnMouseMove, this);
 }
 
-void TrackerPanel::UpdateIndicators() {
-  if (panels_mode_ && !savedata_path_) {
-    solved_panels_ = IPC_GetSolvedPanels();
-  }
-
-  for (AreaIndicator &area : areas_) {
-    area.popup->UpdateIndicators();
-  }
-
-  Redraw();
-}
-
-void TrackerPanel::SetPanelsMode() { panels_mode_ = true; }
-
-void TrackerPanel::SetSavedataPath(std::string savedata_path) {
-  if (!savedata_path_) {
-    wxButton *refresh_button =
-        new wxButton(this, wxID_ANY, "Refresh", {15, 15});
-    refresh_button->Bind(wxEVT_BUTTON, &TrackerPanel::OnRefreshSavedata, this);
-  }
-
-  savedata_path_ = savedata_path;
-  panels_mode_ = true;
-
-  RefreshSavedata();
-}
+void TrackerPanel::UpdateIndicators(bool reset) {
+  if (reset) {
+    for (AreaIndicator &area : areas_) {
+      const MapArea &map_area = GD_GetMapArea(area.area_id);
+
+      if ((!AP_IsLocationVisible(map_area.classification) ||
+           IsAreaPostgame(area.area_id)) &&
+          !(map_area.hunt &&
+            GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) &&
+          !(map_area.has_single_panel &&
+            GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS) &&
+          !(AP_IsPaintingShuffle() && !map_area.paintings.empty())) {
+        area.active = false;
+      } else {
+        area.active = true;
+      }
 
-void TrackerPanel::RefreshSavedata() {
-  solved_panels_.clear();
+      area.popup->ResetIndicators();
+    }
 
-  GodotVariant godot_variant = ParseGodotFile(*savedata_path_);
-  for (const GodotVariant &panel_node : godot_variant.AsArray()) {
-    const std::vector<GodotVariant> &fields = panel_node.AsArray();
-    if (fields[1].AsBool()) {
-      const std::vector<std::string> &nodepath = fields[0].AsNodePath();
-      std::string key = fmt::format("{}/{}", nodepath[3], nodepath[4]);
-      solved_panels_.insert(key);
+    Resize();
+  } else {
+    for (AreaIndicator &area : areas_) {
+      area.popup->UpdateIndicators();
     }
   }
 
-  UpdateIndicators();
-  Refresh();
+  Redraw();
 }
 
 void TrackerPanel::OnPaint(wxPaintEvent &event) {
   if (GetSize() != rendered_.GetSize()) {
+    Resize();
     Redraw();
   }
 
@@ -103,10 +90,13 @@ void TrackerPanel::OnPaint(wxPaintEvent &event) {
   dc.DrawBitmap(rendered_, 0, 0);
 
   std::optional<std::tuple<int, int>> player_position;
-  if (IPC_IsConnected()) {
-    player_position = IPC_GetPlayerPosition();
-  } else {
-    player_position = AP_GetPlayerPosition();
+  if (GetTrackerConfig().track_position)
+  {
+    if (IPC_IsConnected()) {
+      player_position = IPC_GetPlayerPosition();
+    } else {
+      player_position = AP_GetPlayerPosition();
+    }
   }
 
   if (player_position.has_value()) {
@@ -142,12 +132,8 @@ void TrackerPanel::OnMouseMove(wxMouseEvent &event) {
   event.Skip();
 }
 
-void TrackerPanel::OnRefreshSavedata(wxCommandEvent &event) {
-  RefreshSavedata();
-}
-
-void TrackerPanel::Redraw() {
-  wxSize panel_size = GetSize();
+void TrackerPanel::Resize() {
+  wxSize panel_size = GetClientSize();
   wxSize image_size = map_image_.GetSize();
 
   int final_x = 0;
@@ -166,7 +152,7 @@ void TrackerPanel::Redraw() {
     final_x = (panel_size.GetWidth() - final_width) / 2;
   }
 
-  rendered_ = wxBitmap(
+  scaled_map_ = wxBitmap(
       map_image_.Scale(final_width, final_height, wxIMAGE_QUALITY_NORMAL)
           .Size(panel_size, {final_x, final_y}, 0, 0, 0));
 
@@ -181,30 +167,61 @@ void TrackerPanel::Redraw() {
       wxBitmap(player_image_.Scale(player_width > 0 ? player_width : 1,
                                    player_height > 0 ? player_height : 1));
 
+  real_area_size_ = final_width * AREA_EFFECTIVE_SIZE / image_size.GetWidth();
+
+  for (AreaIndicator &area : areas_) {
+    const MapArea &map_area = GD_GetMapArea(area.area_id);
+
+    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)) *
+                                    final_width / image_size.GetWidth();
+
+    area.real_x1 = real_area_x;
+    area.real_x2 = real_area_x + real_area_size_;
+    area.real_y1 = real_area_y;
+    area.real_y2 = real_area_y + real_area_size_;
+
+    int popup_x =
+        final_x + map_area.map_x * final_width / image_size.GetWidth();
+    int popup_y =
+        final_y + map_area.map_y * final_width / image_size.GetWidth();
+
+    area.popup->SetClientSize(
+        area.popup->GetFullWidth(),
+        std::min(panel_size.GetHeight(), area.popup->GetFullHeight()));
+
+    if (area.popup->GetSize().GetHeight() > panel_size.GetHeight()) {
+      area.popup->SetSize(area.popup->GetSize().GetWidth(),
+                          panel_size.GetHeight());
+    } 
+
+    if (popup_x + area.popup->GetSize().GetWidth() > panel_size.GetWidth()) {
+      popup_x = panel_size.GetWidth() - area.popup->GetSize().GetWidth();
+    }
+    if (popup_y + area.popup->GetSize().GetHeight() > panel_size.GetHeight()) {
+      popup_y = panel_size.GetHeight() - area.popup->GetSize().GetHeight();
+    }
+    area.popup->SetPosition({popup_x, popup_y});
+  }
+}
+
+void TrackerPanel::Redraw() {
+  rendered_ = scaled_map_;
+
   wxMemoryDC dc;
   dc.SelectObject(rendered_);
 
-  int real_area_size =
-      final_width * AREA_EFFECTIVE_SIZE / image_size.GetWidth();
   int actual_border_size =
-      real_area_size * AREA_BORDER_SIZE / AREA_EFFECTIVE_SIZE;
+      real_area_size_ * AREA_BORDER_SIZE / AREA_EFFECTIVE_SIZE;
   const wxPoint upper_left_triangle[] = {
-      {0, 0}, {0, real_area_size}, {real_area_size, 0}};
-  const wxPoint lower_right_triangle[] = {{0, real_area_size - 1},
-                                          {real_area_size - 1, 0},
-                                          {real_area_size, real_area_size}};
+      {0, 0}, {0, real_area_size_}, {real_area_size_, 0}};
+  const wxPoint lower_right_triangle[] = {{0, real_area_size_ - 1},
+                                          {real_area_size_ - 1, 0},
+                                          {real_area_size_, real_area_size_}};
 
   for (AreaIndicator &area : areas_) {
     const MapArea &map_area = GD_GetMapArea(area.area_id);
-    if (panels_mode_) {
-      area.active = map_area.has_single_panel;
-    } else if (!AP_IsLocationVisible(map_area.classification) &&
-               !(map_area.hunt && GetTrackerConfig().show_hunt_panels) &&
-               !(AP_IsPaintingShuffle() && !map_area.paintings.empty())) {
-      area.active = false;
-    } else {
-      area.active = true;
-    }
 
     if (!area.active) {
       continue;
@@ -216,19 +233,15 @@ void TrackerPanel::Redraw() {
       bool has_unchecked = false;
       if (IsLocationWinCondition(section)) {
         has_unchecked = !AP_HasReachedGoal();
-      } else if (panels_mode_) {
-        if (section.single_panel) {
-          const Panel &panel = GD_GetPanel(*section.single_panel);
-          if (panel.non_counting) {
-            has_unchecked = !AP_HasCheckedGameLocation(section.ap_location_id);
-          } else {
-            has_unchecked = !GetSolvedPanels().contains(panel.nodepath);
-          }
-        }
-      } else if (AP_IsLocationVisible(section.classification)) {
+      } else if (AP_IsLocationVisible(section.classification) &&
+                 !IsLocationPostgame(section.ap_location_id)) {
         has_unchecked = !AP_HasCheckedGameLocation(section.ap_location_id);
-      } else if (section.hunt && GetTrackerConfig().show_hunt_panels) {
-        has_unchecked = !AP_HasCheckedHuntPanel(section.ap_location_id);
+      } else if ((section.hunt && GetTrackerConfig().visible_panels ==
+                                      TrackerConfig::kHUNT_PANELS) ||
+                 (section.single_panel && GetTrackerConfig().visible_panels ==
+                                              TrackerConfig::kALL_PANELS)) {
+        has_unchecked =
+            !AP_IsPanelSolved(GD_GetPanel(*section.single_panel).solve_index);
       }
 
       if (has_unchecked) {
@@ -240,8 +253,12 @@ void TrackerPanel::Redraw() {
       }
     }
 
-    if (AP_IsPaintingShuffle() && !panels_mode_) {
+    if (AP_IsPaintingShuffle()) {
       for (int painting_id : map_area.paintings) {
+        if (IsPaintingPostgame(painting_id)) {
+          continue;
+        }
+
         const PaintingExit &painting = GD_GetPaintingExit(painting_id);
         bool reachable = IsPaintingReachable(painting_id);
         if (!reachable || !AP_IsPaintingChecked(painting.internal_id)) {
@@ -254,10 +271,8 @@ void TrackerPanel::Redraw() {
       }
     }
 
-    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)) *
-                                    final_width / image_size.GetWidth();
+    int real_area_x = area.real_x1;
+    int real_area_y = area.real_y1;
 
     if (has_reachable_unchecked && has_unreachable_unchecked &&
         GetTrackerConfig().hybrid_areas) {
@@ -271,7 +286,7 @@ void TrackerPanel::Redraw() {
       dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, actual_border_size));
       dc.SetBrush(*wxTRANSPARENT_BRUSH);
       dc.DrawRectangle({real_area_x, real_area_y},
-                       {real_area_size, real_area_size});
+                       {real_area_size_, real_area_size_});
 
     } else {
       const wxBrush *brush_color = wxGREY_BRUSH;
@@ -286,30 +301,7 @@ void TrackerPanel::Redraw() {
       dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, actual_border_size));
       dc.SetBrush(*brush_color);
       dc.DrawRectangle({real_area_x, real_area_y},
-                       {real_area_size, real_area_size});
+                       {real_area_size_, real_area_size_});
     }
-
-    area.real_x1 = real_area_x;
-    area.real_x2 = real_area_x + real_area_size;
-    area.real_y1 = real_area_y;
-    area.real_y2 = real_area_y + real_area_size;
-
-    int popup_x =
-        final_x + map_area.map_x * final_width / image_size.GetWidth();
-    int popup_y =
-        final_y + map_area.map_y * final_width / image_size.GetWidth();
-
-    area.popup->SetClientSize(
-        area.popup->GetVirtualSize().GetWidth(),
-        std::min(panel_size.GetHeight(),
-                 area.popup->GetVirtualSize().GetHeight()));
-
-    if (popup_x + area.popup->GetSize().GetWidth() > panel_size.GetWidth()) {
-      popup_x = panel_size.GetWidth() - area.popup->GetSize().GetWidth();
-    }
-    if (popup_y + area.popup->GetSize().GetHeight() > panel_size.GetHeight()) {
-      popup_y = panel_size.GetHeight() - area.popup->GetSize().GetHeight();
-    }
-    area.popup->SetPosition({popup_x, popup_y});
   }
 }
@@ -17,17 +17,7 @@ class TrackerPanel : public wxPanel {
  public:
   TrackerPanel(wxWindow *parent);
 
-  void UpdateIndicators();
-
-  void SetPanelsMode();
-
-  void SetSavedataPath(std::string savedata_path);
-
-  bool IsPanelsMode() const { return panels_mode_; }
-
-  const std::set<std::string> &GetSolvedPanels() const {
-    return solved_panels_;
-  }
+  void UpdateIndicators(bool reset);
 
  private:
   struct AreaIndicator {
@@ -42,14 +32,13 @@ class TrackerPanel : public wxPanel {
 
   void OnPaint(wxPaintEvent &event);
   void OnMouseMove(wxMouseEvent &event);
-  void OnRefreshSavedata(wxCommandEvent &event);
 
+  void Resize();
   void Redraw();
 
-  void RefreshSavedata();
-
   wxImage map_image_;
   wxImage player_image_;
+  wxBitmap scaled_map_;
   wxBitmap rendered_;
   wxBitmap scaled_player_;
 
@@ -57,12 +46,9 @@ class TrackerPanel : public wxPanel {
   int offset_y_ = 0;
   double scale_x_ = 0;
   double scale_y_ = 0;
+  int real_area_size_ = 0;
 
   std::vector<AreaIndicator> areas_;
-
-  bool panels_mode_ = false;
-  std::optional<std::string> savedata_path_;
-  std::set<std::string> solved_panels_;
 };
 
 #endif /* end of include guard: TRACKER_PANEL_H_D675A54D */
@@ -12,6 +12,7 @@
 
 #include "ap_state.h"
 #include "game_data.h"
+#include "global.h"
 #include "logger.h"
 
 namespace {
@@ -25,6 +26,7 @@ struct Requirements {
   std::set<int> rooms;       // maybe
   bool mastery = false;      // maybe
   bool panel_hunt = false;   // maybe
+  bool postgame = false;
 
   void Merge(const Requirements& rhs) {
     if (rhs.disabled) {
@@ -45,6 +47,7 @@ struct Requirements {
     }
     mastery = mastery || rhs.mastery;
     panel_hunt = panel_hunt || rhs.panel_hunt;
+    postgame = postgame || rhs.postgame;
   }
 };
 
@@ -83,8 +86,6 @@ class RequirementCalculator {
             break;
         }
       } else if (AP_GetDoorShuffleMode() != kDOORS_MODE || 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);
@@ -148,6 +149,10 @@ class RequirementCalculator {
         }
       }
 
+      if (panel_obj.location_name == GetWinCondition()) {
+        requirements.postgame = true;
+      }
+
       panels_[panel_id] = requirements;
     }
 
@@ -162,11 +167,17 @@ class RequirementCalculator {
 struct TrackerState {
   std::map<int, bool> reachability;
   std::set<int> reachable_doors;
+  std::set<int> solveable_panels;
   std::set<int> reachable_paintings;
   std::mutex reachability_mutex;
   RequirementCalculator requirements;
   std::map<int, std::map<std::string, bool>> door_reports;
   bool pilgrimage_doable = false;
+
+  // If these are empty, it actually means everything is non-postgame.
+  std::set<int> non_postgame_areas;
+  std::set<int> non_postgame_locations;
+  std::set<int> non_postgame_paintings;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -181,6 +192,11 @@ class StateCalculator;
 struct StateCalculatorOptions {
   int start;
   bool pilgrimage = false;
+
+  // Treats all items as collected and all paintings as checked, but postgame
+  // areas cannot be reached.
+  bool postgame_detection = false;
+
   StateCalculator* parent = nullptr;
 };
 
@@ -191,6 +207,16 @@ class StateCalculator {
   explicit StateCalculator(StateCalculatorOptions options)
       : options_(options) {}
 
+  void PreloadPanels(const std::set<int>& panels) {
+    solveable_panels_ = panels;
+  }
+
+  void PreloadDoors(const std::set<int>& doors) {
+    for (int door_id : doors) {
+      door_decisions_[door_id] = kYes;
+    }
+  }
+
   void Calculate() {
     painting_mapping_ = AP_GetPaintingMapping();
     checked_paintings_ = AP_GetCheckedPaintings();
@@ -236,7 +262,8 @@ class StateCalculator {
 
           PaintingExit cur_painting = GD_GetPaintingExit(painting_id);
           if (painting_mapping_.count(cur_painting.internal_id) &&
-              checked_paintings_.count(cur_painting.internal_id)) {
+              (checked_paintings_.count(cur_painting.internal_id) ||
+               options_.postgame_detection)) {
             Exit painting_exit;
             PaintingExit target_painting =
                 GD_GetPaintingExit(GD_GetPaintingByName(
@@ -315,7 +342,7 @@ class StateCalculator {
             new_boundary.push_back(
                 {.source_room = room_exit.destination_room,
                  .destination_room = GD_GetRoomByName("Color Hallways"),
-                 .type = EntranceType::kPainting});
+                 .type = EntranceType::kStaticPainting});
           }
 
           if (AP_IsPilgrimageEnabled()) {
@@ -341,7 +368,7 @@ class StateCalculator {
                    .destination_room = GD_GetRoomByName("Pilgrim Antechamber"),
                    .door =
                        GD_GetDoorByName("Pilgrim Antechamber - Sun Painting"),
-                   .type = EntranceType::kPainting});
+                   .type = EntranceType::kStaticPainting});
             }
           }
 
@@ -360,6 +387,10 @@ class StateCalculator {
     // evaluated.
     for (const Door& door : GD_GetDoors()) {
       int discard = IsDoorReachable(door.id);
+
+      door_report_[door.id] = {};
+      discard = AreRequirementsSatisfied(
+          GetState().requirements.GetDoor(door.id), &door_report_[door.id]);
     }
   }
 
@@ -417,43 +448,48 @@ class StateCalculator {
       return kNo;
     }
 
+    if (reqs.postgame && options_.postgame_detection) {
+      return kNo;
+    }
+
     Decision final_decision = kYes;
 
-    for (int door_id : reqs.doors) {
-      const Door& door_obj = GD_GetDoor(door_id);
-      Decision decision = IsNonGroupedDoorReachable(door_obj);
+    if (!options_.postgame_detection) {
+      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 (report) {
+          (*report)[door_obj.item_name] = (decision == kYes);
+        }
 
-      if (decision != kYes) {
-        final_decision = decision;
+        if (decision != kYes) {
+          final_decision = decision;
+        }
       }
-    }
 
-    for (int panel_door_id : reqs.panel_doors) {
-      const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_door_id);
-      Decision decision = IsNonGroupedDoorReachable(panel_door_obj);
+      for (int panel_door_id : reqs.panel_doors) {
+        const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_door_id);
+        Decision decision = IsNonGroupedDoorReachable(panel_door_obj);
 
-      if (report) {
-        (*report)[AP_GetItemName(panel_door_obj.ap_item_id)] =
-            (decision == kYes);
-      }
+        if (report) {
+          (*report)[panel_door_obj.item_name] = (decision == kYes);
+        }
 
-      if (decision != kYes) {
-        final_decision = decision;
+        if (decision != kYes) {
+          final_decision = decision;
+        }
       }
-    }
 
-    for (int item_id : reqs.items) {
-      bool has_item = AP_HasItem(item_id);
-      if (report) {
-        (*report)[AP_GetItemName(item_id)] = has_item;
-      }
+      for (int item_id : reqs.items) {
+        bool has_item = AP_HasItem(item_id);
+        if (report) {
+          (*report)[GD_GetItemName(item_id)] = has_item;
+        }
 
-      if (!has_item) {
-        final_decision = kNo;
+        if (!has_item) {
+          final_decision = kNo;
+        }
       }
     }
 
@@ -522,14 +558,7 @@ class StateCalculator {
   }
 
   Decision IsDoorReachable_Helper(int door_id) {
-    if (door_report_.count(door_id)) {
-      door_report_[door_id].clear();
-    } else {
-      door_report_[door_id] = {};
-    }
-
-    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id),
-                                    &door_report_[door_id]);
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id));
   }
 
   Decision IsDoorReachable(int door_id) {
@@ -621,7 +650,8 @@ class StateCalculator {
           !AP_DoesPilgrimageAllowRoofAccess()) {
         return kNo;
       }
-      if (room_exit.type == EntranceType::kPainting &&
+      if ((room_exit.type == EntranceType::kPainting ||
+           room_exit.type == EntranceType::kStaticPainting) &&
           !AP_DoesPilgrimageAllowPaintings()) {
         return kNo;
       }
@@ -661,18 +691,85 @@ class StateCalculator {
 }  // namespace
 
 void ResetReachabilityRequirements() {
+  TrackerLog("Resetting tracker state...");
+
   std::lock_guard reachability_guard(GetState().reachability_mutex);
   GetState().requirements.Reset();
+  GetState().reachable_doors.clear();
+  GetState().solveable_panels.clear();
+
+  if (AP_IsPostgameShuffle()) {
+    GetState().non_postgame_areas.clear();
+    GetState().non_postgame_locations.clear();
+    GetState().non_postgame_paintings.clear();
+  } else {
+    StateCalculator postgame_calculator(
+        {.start = GD_GetRoomByName("Menu"), .postgame_detection = true});
+    postgame_calculator.Calculate();
+
+    std::set<int>& non_postgame_areas = GetState().non_postgame_areas;
+    non_postgame_areas.clear();
+
+    std::set<int>& non_postgame_locations = GetState().non_postgame_locations;
+    non_postgame_locations.clear();
+
+    const std::set<int>& reachable_rooms =
+        postgame_calculator.GetReachableRooms();
+    const std::set<int>& solveable_panels =
+        postgame_calculator.GetSolveablePanels();
+
+    for (const MapArea& map_area : GD_GetMapAreas()) {
+      bool area_reachable = false;
+
+      for (const Location& location_section : map_area.locations) {
+        bool reachable = reachable_rooms.count(location_section.room);
+        if (reachable) {
+          for (int panel_id : location_section.panels) {
+            reachable &= (solveable_panels.count(panel_id) == 1);
+          }
+        }
+
+        if (!reachable && IsLocationWinCondition(location_section)) {
+          reachable = true;
+        }
+
+        if (reachable) {
+          non_postgame_locations.insert(location_section.ap_location_id);
+          area_reachable = true;
+        }
+      }
+
+      for (int painting_id : map_area.paintings) {
+        if (postgame_calculator.GetReachablePaintings().count(painting_id)) {
+          area_reachable = true;
+        }
+      }
+
+      if (area_reachable) {
+        non_postgame_areas.insert(map_area.id);
+      }
+    }
+
+    GetState().non_postgame_paintings =
+        postgame_calculator.GetReachablePaintings();
+  }
 }
 
 void RecalculateReachability() {
+  TrackerLog("Calculating reachability...");
+
   std::lock_guard reachability_guard(GetState().reachability_mutex);
 
+  // Receiving items and checking paintings should never remove access to doors
+  // or panels, so we can preload any doors and panels we already know are
+  // accessible from previous runs, in order to reduce the work.
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
+  state_calculator.PreloadDoors(GetState().reachable_doors);
+  state_calculator.PreloadPanels(GetState().solveable_panels);
   state_calculator.Calculate();
 
   const std::set<int>& reachable_rooms = state_calculator.GetReachableRooms();
-  const std::set<int>& solveable_panels = state_calculator.GetSolveablePanels();
+  std::set<int> solveable_panels = state_calculator.GetSolveablePanels();
 
   std::map<int, bool> new_reachability;
   for (const MapArea& map_area : GD_GetMapAreas()) {
@@ -703,6 +800,7 @@ void RecalculateReachability() {
   
   std::swap(GetState().reachability, new_reachability);
   std::swap(GetState().reachable_doors, new_reachable_doors);
+  std::swap(GetState().solveable_panels, solveable_panels);
   std::swap(GetState().reachable_paintings, reachable_paintings);
   std::swap(GetState().door_reports, door_reports);
   GetState().pilgrimage_doable = state_calculator.IsPilgrimageDoable();
@@ -741,3 +839,33 @@ bool IsPilgrimageDoable() {
 
   return GetState().pilgrimage_doable;
 }
+
+bool IsAreaPostgame(int area_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_areas.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_areas.count(area_id);
+  }
+}
+
+bool IsLocationPostgame(int location_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_locations.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_locations.count(location_id);
+  }
+}
+
+bool IsPaintingPostgame(int painting_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_paintings.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_paintings.count(painting_id);
+  }
+}
@@ -18,4 +18,10 @@ const std::map<std::string, bool>& GetDoorRequirements(int door_id);
 
 bool IsPilgrimageDoable();
 
+bool IsAreaPostgame(int area_id);
+
+bool IsLocationPostgame(int location_id);
+
+bool IsPaintingPostgame(int painting_id);
+
 #endif /* end of include guard: TRACKER_STATE_H_8639BC90 */
@@ -0,0 +1,309 @@
+#include "updater.h"
+
+#include <fmt/core.h>
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+#include <wx/evtloop.h>
+#include <wx/progdlg.h>
+#include <wx/webrequest.h>
+#include <wx/wfstream.h>
+#include <wx/zipstrm.h>
+#include <yaml-cpp/yaml.h>
+
+#include <cstdio>
+#include <deque>
+#include <filesystem>
+#include <fstream>
+
+#include "global.h"
+#include "logger.h"
+#include "version.h"
+
+constexpr const char* kVersionFileUrl =
+    "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION.yaml";
+constexpr const char* kChangelogUrl =
+    "https://code.fourisland.com/lingo-ap-tracker/about/CHANGELOG.md";
+
+namespace {
+
+std::string CalculateStringSha256(const wxString& data) {
+  unsigned char hash[SHA256_DIGEST_LENGTH];
+  EVP_MD_CTX* sha256 = EVP_MD_CTX_new();
+  EVP_DigestInit(sha256, EVP_sha256());
+  EVP_DigestUpdate(sha256, data.c_str(), data.length());
+  EVP_DigestFinal_ex(sha256, hash, nullptr);
+  EVP_MD_CTX_free(sha256);
+
+  char output[65] = {0};
+  for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+    snprintf(output + (i * 2), 3, "%02x", hash[i]);
+  }
+
+  return std::string(output);
+}
+
+}  // namespace
+
+Updater::Updater(wxFrame* parent) : parent_(parent) {
+  Bind(wxEVT_WEBREQUEST_STATE, &Updater::OnWebRequestState, this);
+}
+
+void Updater::Cleanup() {
+  std::filesystem::path oldDir = GetExecutableDirectory() / "old";
+  if (std::filesystem::is_directory(oldDir)) {
+    std::filesystem::remove_all(oldDir);
+  }
+}
+
+void Updater::CheckForUpdates(bool invisible) {
+  wxWebRequest versionRequest =
+      wxWebSession::GetDefault().CreateRequest(this, kVersionFileUrl);
+
+  if (invisible) {
+    update_state_ = UpdateState::GetVersionInvisible;
+
+    versionRequest.Start();
+  } else {
+    update_state_ = UpdateState::GetVersionManual;
+
+    if (DownloadWithProgress(versionRequest)) {
+      if (versionRequest.GetState() == wxWebRequest::State_Failed) {
+        wxMessageBox("Could not check for updates.", "Error",
+                     wxOK | wxICON_ERROR);
+      } else if (versionRequest.GetState() == wxWebRequest::State_Completed) {
+        ProcessVersionFile(
+            versionRequest.GetResponse().AsString().utf8_string());
+      }
+    }
+  }
+}
+
+void Updater::OnWebRequestState(wxWebRequestEvent& evt) {
+  if (update_state_ == UpdateState::GetVersionInvisible) {
+    if (evt.GetState() == wxWebRequest::State_Completed) {
+      ProcessVersionFile(evt.GetResponse().AsString().utf8_string());
+    } else if (evt.GetState() == wxWebRequest::State_Failed) {
+      parent_->SetStatusText("Could not check for updates.");
+    }
+  }
+}
+
+void Updater::ProcessVersionFile(std::string data) {
+  try {
+    YAML::Node versionInfo = YAML::Load(data);
+    Version latestVersion(versionInfo["version"].as<std::string>());
+
+    if (kTrackerVersion < latestVersion) {
+      if (versionInfo["packages"]) {
+        std::string platformIdentifier;
+
+        if (wxPlatformInfo::Get().GetOperatingSystemId() == wxOS_WINDOWS_NT) {
+          platformIdentifier = "win64";
+        }
+
+        if (!platformIdentifier.empty() &&
+            versionInfo["packages"][platformIdentifier]) {
+          wxMessageDialog dialog(
+              nullptr,
+              fmt::format("There is a newer version of Lingo AP Tracker "
+                          "available. You have {}, and the latest version is "
+                          "{}. Would you like to update?",
+                          kTrackerVersion.ToString(), latestVersion.ToString()),
+              "Update available", wxYES_NO | wxCANCEL);
+          dialog.SetYesNoLabels("Install update", "Open changelog");
+
+          int dlgResult = dialog.ShowModal();
+          if (dlgResult == wxID_YES) {
+            const YAML::Node& packageInfo =
+                versionInfo["packages"][platformIdentifier];
+            std::string packageUrl = packageInfo["url"].as<std::string>();
+            std::string packageChecksum =
+                packageInfo["checksum"].as<std::string>();
+
+            std::vector<std::filesystem::path> packageFiles;
+            if (packageInfo["files"]) {
+              for (const YAML::Node& filename : packageInfo["files"]) {
+                packageFiles.push_back(filename.as<std::string>());
+              }
+            }
+
+            std::vector<std::filesystem::path> deletedFiles;
+            if (packageInfo["deleted_files"]) {
+              for (const YAML::Node& filename : packageInfo["deleted_files"]) {
+                deletedFiles.push_back(filename.as<std::string>());
+              }
+            }
+
+            InstallUpdate(packageUrl, packageChecksum, packageFiles,
+                          deletedFiles);
+          } else if (dlgResult == wxID_NO) {
+            wxLaunchDefaultBrowser(kChangelogUrl);
+          }
+
+          return;
+        }
+      }
+
+      if (wxMessageBox(
+              fmt::format("There is a newer version of Lingo AP Tracker "
+                          "available. You have {}, and the latest version is "
+                          "{}. Would you like to update?",
+                          kTrackerVersion.ToString(), latestVersion.ToString()),
+              "Update available", wxYES_NO) == wxYES) {
+        wxLaunchDefaultBrowser(kChangelogUrl);
+      }
+    } else if (update_state_ == UpdateState::GetVersionManual) {
+      wxMessageBox("Lingo AP Tracker is up to date!", "Lingo AP Tracker", wxOK);
+    }
+  } catch (const std::exception& ex) {
+    wxMessageBox("Could not check for updates.", "Error", wxOK | wxICON_ERROR);
+  }
+}
+
+void Updater::InstallUpdate(std::string url, std::string checksum,
+                            std::vector<std::filesystem::path> files,
+                            std::vector<std::filesystem::path> deletedFiles) {
+  update_state_ = UpdateState::GetPackage;
+
+  wxWebRequest packageRequest =
+      wxWebSession::GetDefault().CreateRequest(this, url);
+
+  if (!DownloadWithProgress(packageRequest)) {
+    return;
+  }
+
+  bool download_issue = false;
+
+  wxFileName package_path;
+  package_path.AssignTempFileName("");
+
+  if (!package_path.IsOk()) {
+    download_issue = true;
+  } else {
+    wxFileOutputStream writeOut(package_path.GetFullPath());
+    wxString fileData = packageRequest.GetResponse().AsString();
+    writeOut.WriteAll(fileData.c_str(), fileData.length());
+
+    std::string downloadedChecksum = CalculateStringSha256(fileData);
+    if (downloadedChecksum != checksum) {
+      download_issue = true;
+    }
+  }
+
+  if (download_issue) {
+    if (wxMessageBox("There was an issue downloading the update. Would you "
+                     "like to manually download it instead?",
+                     "Error", wxYES_NO | wxICON_ERROR) == wxID_YES) {
+      wxLaunchDefaultBrowser(kChangelogUrl);
+    }
+    return;
+  }
+
+  std::filesystem::path newArea = GetExecutableDirectory();
+  std::filesystem::path oldArea = newArea / "old";
+  std::set<std::filesystem::path> folders;
+  std::set<std::filesystem::path> filesToMove;
+  for (const std::filesystem::path& existingFile : files) {
+    std::filesystem::path movedPath = oldArea / existingFile;
+    std::filesystem::path movedDir = movedPath;
+    movedDir.remove_filename();
+    folders.insert(movedDir);
+    filesToMove.insert(existingFile);
+  }
+  for (const std::filesystem::path& existingFile : deletedFiles) {
+    std::filesystem::path movedPath = oldArea / existingFile;
+    std::filesystem::path movedDir = movedPath;
+    movedDir.remove_filename();
+    folders.insert(movedDir);
+  }
+
+  for (const std::filesystem::path& newFolder : folders) {
+    TrackerLog(fmt::format("Creating directory {}", newFolder.string()));
+
+    std::filesystem::create_directories(newFolder);
+  }
+
+  for (const std::filesystem::path& existingFile : files) {
+    std::filesystem::path existingPath = newArea / existingFile;
+
+    if (std::filesystem::is_regular_file(existingPath)) {
+      std::filesystem::path movedPath = oldArea / existingFile;
+
+      TrackerLog(fmt::format("Moving {} -> {}", existingPath.string(),
+                             movedPath.string()));
+
+      std::filesystem::rename(existingPath, movedPath);
+    }
+  }
+  for (const std::filesystem::path& existingFile : deletedFiles) {
+    std::filesystem::path existingPath = newArea / existingFile;
+
+    if (std::filesystem::is_regular_file(existingPath)) {
+      std::filesystem::path movedPath = oldArea / existingFile;
+
+      TrackerLog(fmt::format("Moving {} -> {}", existingPath.string(),
+                             movedPath.string()));
+
+      std::filesystem::rename(existingPath, movedPath);
+    }
+  }
+
+  wxFileInputStream fileInputStream(package_path.GetFullPath());
+  wxZipInputStream zipStream(fileInputStream);
+  std::unique_ptr<wxZipEntry> zipEntry;
+  while ((zipEntry = std::unique_ptr<wxZipEntry>(zipStream.GetNextEntry())) !=
+         nullptr) {
+    if (zipEntry->IsDir()) {
+      continue;
+    }
+
+    std::filesystem::path archivePath = zipEntry->GetName().utf8_string();
+
+    TrackerLog(fmt::format("Found {} in archive", archivePath.string()));
+
+    // Cut off the root folder name
+    std::filesystem::path subPath;
+    for (auto it = std::next(archivePath.begin()); it != archivePath.end();
+         it++) {
+      subPath /= *it;
+    }
+
+    std::filesystem::path pastePath = newArea / subPath;
+
+    wxFileOutputStream fileOutput(pastePath.string());
+    zipStream.Read(fileOutput);
+  }
+
+  if (wxMessageBox(
+      "Update installed! The tracker must be restarted for the changes to take "
+      "effect. Do you want to close the tracker?",
+                   "Update installed", wxYES_NO) == wxYES) {
+    wxExit();
+  }
+}
+
+bool Updater::DownloadWithProgress(wxWebRequest& request) {
+  request.Start();
+
+  wxProgressDialog dialog("Checking for updates...", "Checking for updates...",
+                          100, nullptr,
+                          wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_CAN_ABORT |
+                              wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME);
+  while (request.GetState() != wxWebRequest::State_Completed &&
+         request.GetState() != wxWebRequest::State_Failed) {
+    if (request.GetBytesExpectedToReceive() == -1) {
+      if (!dialog.Pulse()) {
+        request.Cancel();
+        return false;
+      }
+    } else {
+      dialog.SetRange(request.GetBytesExpectedToReceive());
+      if (!dialog.Update(request.GetBytesReceived())) {
+        request.Cancel();
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
@@ -0,0 +1,46 @@
+#ifndef UPDATER_H_809E7381
+#define UPDATER_H_809E7381
+
+#include <filesystem>
+#include <set>
+#include <string>
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+class wxWebRequest;
+class wxWebRequestEvent;
+
+class Updater : public wxEvtHandler {
+ public:
+  explicit Updater(wxFrame* parent);
+
+  void Cleanup();
+
+  void CheckForUpdates(bool invisible);
+
+ private:
+  enum class UpdateState {
+    GetVersionInvisible,
+    GetVersionManual,
+    GetPackage,
+  };
+
+  void OnWebRequestState(wxWebRequestEvent& event);
+
+  void ProcessVersionFile(std::string data);
+
+  void InstallUpdate(std::string url, std::string checksum,
+                     std::vector<std::filesystem::path> files,
+                     std::vector<std::filesystem::path> deletedFiles);
+
+  bool DownloadWithProgress(wxWebRequest& request);
+
+  wxFrame* parent_;
+  UpdateState update_state_ = UpdateState::GetVersionInvisible;
+};
+
+#endif /* end of include guard: UPDATER_H_809E7381 */
@@ -36,6 +36,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 12, 0);
+constexpr const Version kTrackerVersion = Version(2, 0, 2);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file
@@ -0,0 +1,3 @@
+#define wxUSE_RC_MANIFEST 1
+#define wxUSE_DPI_AWARE_MANIFEST 2
+#include "wx/msw/wx.rc"