35 files changed, 411 insertions, 487 deletions

@@ -16,3 +16,6 @@
 [submodule "vendor/vcpkg"]
         path = vendor/vcpkg
         url = https://github.com/Microsoft/vcpkg.git
+[submodule "vendor/websocketpp"]
+        path = vendor/websocketpp
+        url = https://github.com/zaphoyd/websocketpp
@@ -1,5 +1,61 @@
 # lingo-ap-tracker Releases
 
+## v2.0.2 - 2025-05-24
+
+- Fixed issue connecting to the Archipelago 0.6.2 RC server.
+
+Download:
+[lingo-ap-tracker-v2.0.2-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.2-win64.zip)<br/>
+Source: [v2.0.2](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v2.0.2)
+
+## v2.0.1 - 2025-04-06
+
+- The tracker now assumes postgame shuffle is enabled when the flag is not
+  present in slot data (as is the case with Archipelago 0.6.1 and earlier).
+  Players who have postgame shuffle disabled will unfortunately see locations
+  that are not in their world, until this problem can be fixed.
+
+Download:
+[lingo-ap-tracker-v2.0.1-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.1-win64.zip)<br/>
+Source: [v2.0.1](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v2.0.1)
+
+## v2.0.0 - 2025-04-01
+
+- Compatibility update for Archipelago 0.6.0.
+
+Download:
+[lingo-ap-tracker-v2.0.0-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.0-win64.zip)<br/>
+Source: [v2.0.0](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v2.0.0)
+
+## v1.0.0 - 2025-03-21
+
+After almost two years of development, we have finally hit version 1!
+
+- The subway map now uses Kinrah's updated map image, including fully separated
+  paintings for places like The Wondrous and Orange Tower Sixth Floor, as well
+  as indicators for the color items.
+- Paintings have friendly names now instead of the internal game IDs. They are
+  also distinguished from regular checks by using an owl icon instead of an eye.
+- The tracker is now able to read your solved panel state from the multiworld
+  (requires v5.3.0 of the client). This obsoletes save file parsing and
+  receiving panel solves by connecting to the game.
+- Numerous optimizations to reachability detection and rendering.
+- Added a pane that shows all items received, similar to the web tracker.
+- Added a pane that shows your currently revealed painting mapping, as well as a
+  button that reveals it all immediately.
+- Added a pane that shows your slot options.
+- Postgame shuffle being disabled is handled properly now, and removed locations
+  are no longer shown.
+- Improved support for high-DPI screens. The tracker should no longer appear
+  "blurry" on a high-DPI screen, and should also be able to react properly to
+  being moved between screens with different DPIs.
+- The update checker is now able to download and install tracker updates in
+  place.
+
+Download:
+[lingo-ap-tracker-v1.0.0-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v1.0.0-win64.zip)<br/>
+Source: [v1.0.0](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v1.0.0)
+
 ## v0.12.3 - 2025-03-03
 
 - Fixed issue with non-ASCII connection details.
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.1)
+cmake_minimum_required (VERSION 3.20)
 project (lingo_ap_tracker)
 
 if (MSVC)
@@ -10,7 +10,6 @@ endif(MSVC)
 find_package(wxWidgets CONFIG REQUIRED)
 find_package(OpenSSL REQUIRED)
 find_package(yaml-cpp REQUIRED)
-find_package(websocketpp REQUIRED)
 find_package(fmt REQUIRED)
 
 include_directories(
@@ -19,7 +18,7 @@ include_directories(
   vendor/asio/asio/include
   vendor/nlohmann
   vendor/valijson/include
-  ${websocketpp_INCLUDE_DIRS}
+  vendor/websocketpp
   vendor/wswrap/include
   ${yaml-cpp_INCLUDE_DIRS}
   ${OpenSSL_INCLUDE_DIRS}
@@ -49,7 +48,6 @@ set(SOURCE_FILES
   "src/subway_map.cpp"
   "src/network_set.cpp"
   "src/logger.cpp"
-  "src/godot_variant.cpp"
   "src/ipc_state.cpp"
   "src/ipc_dialog.cpp"
   "src/report_popup.cpp"
@@ -69,7 +67,7 @@ endif(MSVC)
 add_executable(lingo_ap_tracker ${SOURCE_FILES})
 set_property(TARGET lingo_ap_tracker PROPERTY CXX_STANDARD 20)
 set_property(TARGET lingo_ap_tracker PROPERTY CXX_STANDARD_REQUIRED ON)
-target_link_libraries(lingo_ap_tracker PRIVATE fmt::fmt OpenSSL::SSL OpenSSL::Crypto websocketpp::websocketpp wx::core wx::base wx::net yaml-cpp::yaml-cpp)
+target_link_libraries(lingo_ap_tracker PRIVATE fmt::fmt OpenSSL::SSL OpenSSL::Crypto wx::core wx::base wx::net yaml-cpp::yaml-cpp)
 
 set(SRC_DIR "${CMAKE_SOURCE_DIR}/assets")
 set(DST_DIR "${CMAKE_BINARY_DIR}/$<CONFIG>/assets")
@@ -1 +1 @@
-v0.12.3
\ No newline at end of file
+v2.0.2
\ No newline at end of file
@@ -1,8 +1,8 @@
-version: v0.12.3
+version: v2.0.2
 packages:
   win64:
-    url: "https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.12.3-win64.zip"
-    checksum: "0c0d8310d1ecae4f1b8de933661ba14f63aac011cd2b22947aff7085d997f0db"
+    url: "https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.2-win64.zip"
+    checksum: "dfb2fce2f5b14c09f4af7e7fcf6478e420a070db9fb23f9f9ad196f2db4b7518"
     files:
       - fmt.dll
       - jpeg62.dll
@@ -20,7 +20,7 @@ packages:
       - zlib1.dll
       - assets/areas.yaml
       - assets/checked.png
-      # TODO: next release will contain the checked owl
+      - assets/checked_owl.png
       - assets/ids.yaml
       - assets/lingo_map.png
       - assets/LL1.yaml
@@ -279,6 +279,8 @@
     map: [1368, 2103]

   Art Gallery:

     map: [2474, 1366]

+  Art Gallery (First Floor):

+    fold_into: Art Gallery

   Art Gallery (Second Floor):

     fold_into: Art Gallery

   Art Gallery (Third Floor):

@@ -1042,3 +1042,21 @@
 - pos: [815, 1002]
   room: Challenge Room
   door: Welcome Door
+- pos: [104, 1208]
+  special: color_black
+- pos: [104, 1249]
+  special: color_red
+- pos: [104, 1290]
+  special: color_yellow
+- pos: [104, 1330]
+  special: color_blue
+- pos: [104, 1371]
+  special: color_purple
+- pos: [104, 1411]
+  special: color_orange
+- pos: [104, 1451]
+  special: color_green
+- pos: [104, 1491]
+  special: color_brown
+- pos: [104, 1531]
+  special: color_gray
@@ -8,13 +8,14 @@ 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_USEHEADER);
@@ -23,8 +24,8 @@ AchievementsPane::AchievementsPane(wxWindow* parent)
 }
 
 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,6 +38,10 @@ 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 = {
@@ -79,6 +84,7 @@ 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;
@@ -142,6 +148,7 @@ 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;
@@ -216,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() {
@@ -257,8 +253,6 @@ struct APState {
             checked_paintings.count(painting_mapping.at(painting_id)));
   }
 
-  std::string GetItemName(int id) { return apclient->get_item_name(id, "Lingo"); }
-
   void RevealPaintings() {
     std::lock_guard state_guard(state_mutex);
 
@@ -283,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) {
@@ -290,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");
@@ -425,7 +417,7 @@ struct APState {
       }
 
       for (const auto& [item_id, item_index] : index_by_item) {
-        item_states.push_back(ItemState{.name = GetItemName(item_id),
+        item_states.push_back(ItemState{.name = GD_GetItemName(item_id),
                                         .amount = inventory[item_id],
                                         .index = item_index});
       }
@@ -511,8 +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;
+      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();
@@ -603,11 +596,6 @@ struct APState {
       TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
                              (value.get<bool>() ? "true" : "false")));
 
-      if (key.find("Achievement|") != std::string::npos) {
-        state_update.achievements = true;
-      } else if (key.find("Hunt|") != std::string::npos) {
-        state_update.hunt_panels = true;
-      }
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
       TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
@@ -615,6 +603,21 @@ struct APState {
 
       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")) {
@@ -715,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() {
@@ -830,10 +829,6 @@ VictoryCondition AP_GetVictoryCondition() {
   return GetState().victory_condition;
 }
 
-bool AP_HasAchievement(const std::string& achievement_name) {
-  return GetState().HasAchievement(achievement_name);
-}
-
 bool AP_HasEarlyColorHallways() {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -883,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);
+}
@@ -57,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();
 
@@ -98,8 +93,6 @@ PanelShuffleMode AP_GetPanelShuffleMode();
 
 VictoryCondition AP_GetVictoryCondition();
 
-bool AP_HasAchievement(const std::string& achievement_name);
-
 bool AP_HasEarlyColorHallways();
 
 bool AP_IsPilgrimageEnabled();
@@ -120,4 +113,6 @@ 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 */
@@ -50,21 +50,15 @@ void AreaPopup::ResetIndicators() {
   for (int section_id = 0; section_id < map_area.locations.size();
        section_id++) {
     const Location& location = map_area.locations.at(section_id);
-    if (IsLocationPostgame(location.ap_location_id)) {
+    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;
     }
 
-    if (tracker_panel->IsPanelsMode()) {
-      if (!location.single_panel) {
-        continue;
-      }
-    } else {
-      if (!AP_IsLocationVisible(location.classification) &&
-          !(location.hunt && GetTrackerConfig().show_hunt_panels)) {
-        continue;
-      }
-    }
-
     indicators_.emplace_back(section_id, kLOCATION, acc_height);
 
     wxSize item_extent = mem_dc.GetTextExtent(location.name);
@@ -77,7 +71,7 @@ void AreaPopup::ResetIndicators() {
     }
   }
 
-  if (AP_IsPaintingShuffle() && !tracker_panel->IsPanelsMode()) {
+  if (AP_IsPaintingShuffle()) {
     for (int painting_id : map_area.paintings) {
       if (IsPaintingPostgame(painting_id)) {
         continue;
@@ -135,17 +129,11 @@ void AreaPopup::UpdateIndicators() {
         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));
+                    (location.single_panel &&
+                     AP_IsPanelSolved(
+                         GD_GetPanel(*location.single_panel).solve_index));
         }
 
         const wxBitmap* eye_ptr = checked ? checked_eye_ : unchecked_eye_;
@@ -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));
@@ -538,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));
@@ -589,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;
@@ -734,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));
@@ -891,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];
@@ -964,6 +987,10 @@ 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_;
 }
@@ -1010,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 {
@@ -176,6 +178,7 @@ 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);
@@ -188,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 */
@@ -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 */
@@ -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();
     }
   }
 
@@ -314,14 +305,6 @@ struct IPCState {
           std::make_tuple<int, int>(msg["position"]["x"], msg["position"]["z"]);
 
       tracker_frame->UpdateIndicators(StateUpdate{.player_position = true});
-    } 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(StateUpdate{.open_panels_tab = 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 */
@@ -10,7 +10,7 @@
 
 class TrackerApp : public wxApp {
  public:
-  virtual bool OnInit() {
+  virtual bool OnInit() override {
     GetTrackerConfig().Load();
 
     TrackerFrame *frame = new TrackerFrame();
@@ -3,35 +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(this, wxID_ANY, "Track player position");
+  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);
 
-  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);
+  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));
 
-  form_sizer->Add(show_hunt_panels_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(track_position_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), wxSizerFlags().Center());
+  wxBoxSizer* form_sizer = new wxBoxSizer(wxVERTICAL);
+  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,13 +19,16 @@ 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_;
 };
 
@@ -551,6 +551,18 @@ void SubwayMap::Redraw() {
       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;
@@ -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"]) {
@@ -30,6 +32,8 @@ 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.
   }
@@ -43,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) {
@@ -57,6 +60,7 @@ 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,14 +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_;
@@ -9,6 +9,7 @@
 #include <wx/stdpaths.h>
 #include <wx/webrequest.h>
 
+#include <algorithm>
 #include <nlohmann/json.hpp>
 #include <sstream>
 
@@ -50,7 +51,6 @@ 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,
 };
@@ -76,7 +76,6 @@ TrackerFrame::TrackerFrame()
   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);
 
@@ -113,7 +112,6 @@ TrackerFrame::TrackerFrame()
   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);
@@ -251,7 +249,7 @@ 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();
 
@@ -302,28 +300,6 @@ void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
   zoom_out_menu_item_->Enable(event.GetSelection() == 1);
 }
 
-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;
-  }
-
-  std::string savedata_path = open_file_dialog.GetPath().ToStdString();
-
-  if (panels_panel_ == nullptr) {
-    panels_panel_ = new TrackerPanel(notebook_);
-    notebook_->AddPage(panels_panel_, "Panels");
-  }
-
-  notebook_->SetSelection(notebook_->FindPage(panels_panel_));
-  panels_panel_->SetSavedataPath(savedata_path);
-}
-
 void TrackerFrame::OnSashPositionChanged(wxSplitterEvent& event) {
   notebook_->Refresh();
 }
@@ -335,51 +311,41 @@ void TrackerFrame::OnStateReset(wxCommandEvent &event) {
   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(StateChangedEvent &event) {
   const StateUpdate &state = event.GetState();
 
-  if (state.open_panels_tab) {
-    if (panels_panel_ == nullptr) {
-      panels_panel_ = new TrackerPanel(notebook_);
-      panels_panel_->SetPanelsMode();
-      notebook_->AddPage(panels_panel_, "Panels");
-    }
-    panels_panel_->UpdateIndicators(/*reset=*/false);
-    if (notebook_->GetSelection() == 2) {
-      Refresh();
-    }
-
-    return;
+  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 ||
-      (state.hunt_panels && GetTrackerConfig().show_hunt_panels)) {
+      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(/*reset=*/false);
-    }
     Refresh();
   } else if (state.player_position && GetTrackerConfig().track_position) {
     if (notebook_->GetSelection() == 0) {
       tracker_panel_->Refresh();
-    } else if (notebook_->GetSelection() == 2) {
-      panels_panel_->Refresh();
     }
   }
 
-  if (state.achievements) {
+  if (std::any_of(state.panels.begin(), state.panels.end(),
+                  [](int solve_index) {
+                    return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index))
+                        .achievement;
+                  })) {
     achievements_pane_->UpdateIndicators();
   }
 
@@ -8,6 +8,7 @@
 #endif
 
 #include <memory>
+#include <set>
 
 #include "ap_state.h"
 #include "icons.h"
@@ -52,10 +53,8 @@ struct StateUpdate {
   std::vector<ItemState> items;
   bool progression_items = false;
   std::vector<std::string> paintings;
-  bool achievements = false;
-  bool open_panels_tab = false;
   bool cleared_locations = false;
-  bool hunt_panels = false;
+  std::set<int> panels;
   bool player_position = false;
   bool changed_settings = false;
 };
@@ -100,7 +99,6 @@ class TrackerFrame : public wxFrame {
   void OnOpenLogWindow(wxCommandEvent &event);
   void OnCloseLogWindow(wxCloseEvent &event);
   void OnChangePage(wxBookCtrlEvent &event);
-  void OnOpenFile(wxCommandEvent &event);
   void OnSashPositionChanged(wxSplitterEvent &event);
 
   void OnStateReset(wxCommandEvent &event);
@@ -118,7 +116,6 @@ class TrackerFrame : public wxFrame {
   OptionsPane *options_pane_;
   PaintingsPane *paintings_pane_;
   SubwayMap *subway_map_;
-  TrackerPanel *panels_panel_ = nullptr;
   LogDialog *log_dialog_ = nullptr;
 
   wxMenuItem *zoom_in_menu_item_;
@@ -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"
@@ -52,21 +51,17 @@ TrackerPanel::TrackerPanel(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
 }
 
 void TrackerPanel::UpdateIndicators(bool reset) {
-  if (panels_mode_ && !savedata_path_) {
-    solved_panels_ = IPC_GetSolvedPanels();
-  }
-
   if (reset) {
     for (AreaIndicator &area : areas_) {
       const MapArea &map_area = GD_GetMapArea(area.area_id);
 
-      if (IsAreaPostgame(area.area_id)) {
-        area.active = false;
-      } else 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())) {
+      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;
@@ -85,47 +80,10 @@ void TrackerPanel::UpdateIndicators(bool reset) {
   Redraw();
 }
 
-void TrackerPanel::SetPanelsMode() { panels_mode_ = true; }
-
-void TrackerPanel::SetSavedataPath(std::string savedata_path) {
-  if (!savedata_path_) {
-    refresh_button_ = new wxButton(this, wxID_ANY, "Refresh");
-    refresh_button_->Bind(wxEVT_BUTTON, &TrackerPanel::OnRefreshSavedata, this);
-    SetUpRefreshButton();
-  }
-
-  savedata_path_ = savedata_path;
-  panels_mode_ = true;
-
-  UpdateIndicators(/*reset=*/true);
-  RefreshSavedata();
-}
-
-void TrackerPanel::RefreshSavedata() {
-  solved_panels_.clear();
-
-  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);
-    }
-  }
-
-  UpdateIndicators(/*reset=*/false);
-  Refresh();
-}
-
 void TrackerPanel::OnPaint(wxPaintEvent &event) {
   if (GetSize() != rendered_.GetSize()) {
     Resize();
     Redraw();
-
-    if (refresh_button_ != nullptr) {
-      SetUpRefreshButton();
-    }
   }
 
   wxBufferedPaintDC dc(this);
@@ -174,10 +132,6 @@ void TrackerPanel::OnMouseMove(wxMouseEvent &event) {
   event.Skip();
 }
 
-void TrackerPanel::OnRefreshSavedata(wxCommandEvent &event) {
-  RefreshSavedata();
-}
-
 void TrackerPanel::Resize() {
   wxSize panel_size = GetClientSize();
   wxSize image_size = map_image_.GetSize();
@@ -277,23 +231,17 @@ void TrackerPanel::Redraw() {
     bool has_unreachable_unchecked = false;
     for (const Location &section : map_area.locations) {
       bool has_unchecked = false;
-      if (IsLocationPostgame(section.ap_location_id)) {
-        // Nope.
-      } else if (IsLocationWinCondition(section)) {
+      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) {
@@ -305,7 +253,7 @@ void TrackerPanel::Redraw() {
       }
     }
 
-    if (AP_IsPaintingShuffle() && !panels_mode_) {
+    if (AP_IsPaintingShuffle()) {
       for (int painting_id : map_area.paintings) {
         if (IsPaintingPostgame(painting_id)) {
           continue;
@@ -357,8 +305,3 @@ void TrackerPanel::Redraw() {
     }
   }
 }
-
-void TrackerPanel::SetUpRefreshButton() {
-  refresh_button_->SetSize(FromDIP(15), FromDIP(15), wxDefaultCoord,
-                           wxDefaultCoord, wxSIZE_AUTO);
-}
@@ -19,16 +19,6 @@ class TrackerPanel : public wxPanel {
 
   void UpdateIndicators(bool reset);
 
-  void SetPanelsMode();
-
-  void SetSavedataPath(std::string savedata_path);
-
-  bool IsPanelsMode() const { return panels_mode_; }
-
-  const std::set<std::string> &GetSolvedPanels() const {
-    return solved_panels_;
-  }
-
  private:
   struct AreaIndicator {
     int area_id = -1;
@@ -42,23 +32,16 @@ class TrackerPanel : public wxPanel {
 
   void OnPaint(wxPaintEvent &event);
   void OnMouseMove(wxMouseEvent &event);
-  void OnRefreshSavedata(wxCommandEvent &event);
 
   void Resize();
   void Redraw();
 
-  void RefreshSavedata();
-
-  void SetUpRefreshButton();
-
   wxImage map_image_;
   wxImage player_image_;
   wxBitmap scaled_map_;
   wxBitmap rendered_;
   wxBitmap scaled_player_;
 
-  wxButton *refresh_button_ = nullptr;
-
   int offset_x_ = 0;
   int offset_y_ = 0;
   double scale_x_ = 0;
@@ -66,10 +49,6 @@ class TrackerPanel : public wxPanel {
   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 */
@@ -342,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()) {
@@ -368,7 +368,7 @@ class StateCalculator {
                    .destination_room = GD_GetRoomByName("Pilgrim Antechamber"),
                    .door =
                        GD_GetDoorByName("Pilgrim Antechamber - Sun Painting"),
-                   .type = EntranceType::kPainting});
+                   .type = EntranceType::kStaticPainting});
             }
           }
 
@@ -473,8 +473,7 @@ class StateCalculator {
         Decision decision = IsNonGroupedDoorReachable(panel_door_obj);
 
         if (report) {
-          (*report)[AP_GetItemName(panel_door_obj.ap_item_id)] =
-              (decision == kYes);
+          (*report)[panel_door_obj.item_name] = (decision == kYes);
         }
 
         if (decision != kYes) {
@@ -485,7 +484,7 @@ class StateCalculator {
       for (int item_id : reqs.items) {
         bool has_item = AP_HasItem(item_id);
         if (report) {
-          (*report)[AP_GetItemName(item_id)] = has_item;
+          (*report)[GD_GetItemName(item_id)] = has_item;
         }
 
         if (!has_item) {
@@ -651,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;
       }
@@ -36,7 +36,7 @@ std::string CalculateStringSha256(const wxString& data) {
 
   char output[65] = {0};
   for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
-    sprintf(output + (i * 2), "%02x", hash[i]);
+    snprintf(output + (i * 2), 3, "%02x", hash[i]);
   }
 
   return std::string(output);
@@ -172,26 +172,33 @@ void Updater::InstallUpdate(std::string url, std::string checksum,
     return;
   }
 
-  package_path_.clear();
-  package_path_.resize(L_tmpnam + 1);
-  tmpnam_s(package_path_.data(), L_tmpnam);
+  bool download_issue = false;
 
-  {
-    wxFileOutputStream writeOut(package_path_);
+  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) {
-      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;
+      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;
@@ -241,7 +248,7 @@ void Updater::InstallUpdate(std::string url, std::string checksum,
     }
   }
 
-  wxFileInputStream fileInputStream(package_path_);
+  wxFileInputStream fileInputStream(package_path.GetFullPath());
   wxZipInputStream zipStream(fileInputStream);
   std::unique_ptr<wxZipEntry> zipEntry;
   while ((zipEntry = std::unique_ptr<wxZipEntry>(zipStream.GetNextEntry())) !=
@@ -41,7 +41,6 @@ class Updater : public wxEvtHandler {
 
   wxFrame* parent_;
   UpdateState update_state_ = UpdateState::GetVersionInvisible;
-  std::string package_path_;
 };
 
 #endif /* end of include guard: UPDATER_H_809E7381 */
@@ -36,6 +36,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 12, 3);
+constexpr const Version kTrackerVersion = Version(2, 0, 2);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file
@@ -1,6 +1,5 @@
 {
   "dependencies": [
-    "websocketpp",
     "wxwidgets",
     "openssl",
     "yaml-cpp",
-Subproject 3dd44b931481d7a8e9ba412621fa810232b6628
+Subproject df8bfe519564ae001903e5cdd32af0999531ef7
+Subproject 1b11fd301531e6df35a6107c1e8665b1e77a2d8