10 files changed, 241 insertions, 133 deletions

@@ -4,6 +4,7 @@
 #define _WEBSOCKETPP_CPP11_STRICT_
 #pragma comment(lib, "crypt32")
 
+#include <fmt/core.h>
 #include <hkutil/string.h>
 
 #include <any>
@@ -21,6 +22,7 @@
 #include <tuple>
 
 #include "game_data.h"
+#include "logger.h"
 #include "tracker_frame.h"
 #include "tracker_state.h"
 
@@ -76,7 +78,7 @@ struct APState {
 
   void Connect(std::string server, std::string player, std::string password) {
     if (!initialized) {
-      wxLogVerbose("Initializing APState...");
+      TrackerLog("Initializing APState...");
 
       std::thread([this]() {
         for (;;) {
@@ -92,14 +94,14 @@ struct APState {
       }).detach();
 
       for (int panel_id : GD_GetAchievementPanels()) {
-        tracked_data_storage_keys.push_back(
-            "Achievement|" + GD_GetPanel(panel_id).achievement_name);
+        tracked_data_storage_keys.push_back(fmt::format(
+            "Achievement|{}", GD_GetPanel(panel_id).achievement_name));
       }
 
       for (const MapArea& map_area : GD_GetMapAreas()) {
         for (const Location& location : map_area.locations) {
           tracked_data_storage_keys.push_back(
-              "Hunt|" + std::to_string(location.ap_location_id));
+              fmt::format("Hunt|{}", location.ap_location_id));
         }
       }
 
@@ -110,10 +112,10 @@ struct APState {
     }
 
     tracker_frame->SetStatusMessage("Connecting to Archipelago server....");
-    wxLogStatus("Connecting to Archipelago server (%s)...", server);
+    TrackerLog(fmt::format("Connecting to Archipelago server ({})...", server));
 
     {
-      wxLogVerbose("Destroying old AP client...");
+      TrackerLog("Destroying old AP client...");
 
       std::lock_guard client_guard(client_mutex);
 
@@ -160,10 +162,10 @@ struct APState {
     apclient->set_room_info_handler([this, player, password]() {
       inventory.clear();
 
-      wxLogStatus("Connected to Archipelago server. Authenticating as %s %s",
-                  player,
-                  (password.empty() ? "without password"
-                                    : "with password " + password));
+      TrackerLog(fmt::format(
+          "Connected to Archipelago server. Authenticating as {} {}", player,
+          (password.empty() ? "without password"
+                            : "with password " + password)));
       tracker_frame->SetStatusMessage(
           "Connected to Archipelago server. Authenticating...");
 
@@ -175,7 +177,7 @@ struct APState {
         [this](const std::list<int64_t>& locations) {
           for (const int64_t location_id : locations) {
             checked_locations.insert(location_id);
-            wxLogVerbose("Location: %lld", location_id);
+            TrackerLog(fmt::format("Location: {}", location_id));
           }
 
           RefreshTracker(false);
@@ -184,14 +186,14 @@ struct APState {
     apclient->set_slot_disconnected_handler([this]() {
       tracker_frame->SetStatusMessage(
           "Disconnected from Archipelago. Attempting to reconnect...");
-      wxLogStatus(
+      TrackerLog(
           "Slot disconnected from Archipelago. Attempting to reconnect...");
     });
 
     apclient->set_socket_disconnected_handler([this]() {
       tracker_frame->SetStatusMessage(
           "Disconnected from Archipelago. Attempting to reconnect...");
-      wxLogStatus(
+      TrackerLog(
           "Socket disconnected from Archipelago. Attempting to reconnect...");
     });
 
@@ -199,7 +201,7 @@ struct APState {
         [this](const std::list<APClient::NetworkItem>& items) {
           for (const APClient::NetworkItem& item : items) {
             inventory[item.item]++;
-            wxLogVerbose("Item: %lld", item.item);
+            TrackerLog(fmt::format("Item: {}", item.item));
           }
 
           RefreshTracker(false);
@@ -221,13 +223,15 @@ struct APState {
       RefreshTracker(false);
     });
 
-    apclient->set_slot_connected_handler([this, &connection_mutex](
+    apclient->set_slot_connected_handler([this, player, server,
+                                          &connection_mutex](
                                              const nlohmann::json& slot_data) {
-      tracker_frame->SetStatusMessage("Connected to Archipelago!");
-      wxLogStatus("Connected to Archipelago!");
+      tracker_frame->SetStatusMessage(
+          fmt::format("Connected to Archipelago! ({}@{})", player, server));
+      TrackerLog("Connected to Archipelago!");
 
       data_storage_prefix =
-          "Lingo_" + std::to_string(apclient->get_player_number()) + "_";
+          fmt::format("Lingo_{}_", apclient->get_player_number());
       door_shuffle_mode = slot_data["shuffle_doors"].get<DoorShuffleMode>();
       if (slot_data.contains("group_doors")) {
         group_doors = slot_data.contains("group_doors") &&
@@ -290,18 +294,18 @@ struct APState {
         corrected_keys.push_back(data_storage_prefix + key);
       }
 
-      {
-        std::ostringstream vdsks;
-        vdsks << "_read_client_status_" << apclient->get_team_number() << "_"
-              << apclient->get_player_number();
-        victory_data_storage_key = vdsks.str();
-      }
+      victory_data_storage_key =
+          fmt::format("_read_client_status_{}_{}", apclient->get_team_number(),
+                      apclient->get_player_number());
 
       corrected_keys.push_back(victory_data_storage_key);
 
       apclient->Get(corrected_keys);
       apclient->SetNotify(corrected_keys);
 
+      ResetReachabilityRequirements();
+      RefreshTracker(true);
+
       {
         std::lock_guard connection_lock(connection_mutex);
         if (!has_connection_result) {
@@ -346,7 +350,7 @@ struct APState {
           }
 
           std::string full_message = hatkirby::implode(error_messages, " ");
-          wxLogError(wxString(full_message));
+          TrackerLog(full_message);
 
           wxMessageBox(full_message, "Connection failed", wxOK | wxICON_ERROR);
         });
@@ -368,7 +372,7 @@ struct APState {
         DestroyClient();
 
         tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
-        wxLogStatus("Timeout while connecting to Archipelago server.");
+        TrackerLog("Timeout while connecting to Archipelago server.");
         wxMessageBox("Timeout while connecting to Archipelago server.",
                      "Connection failed", wxOK | wxICON_ERROR);
 
@@ -387,9 +391,6 @@ struct APState {
     }
 
     if (connected) {
-      ResetReachabilityRequirements();
-      RefreshTracker(true);
-    } else {
       client_active = false;
     }
   }
@@ -397,11 +398,12 @@ struct APState {
   void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
-      wxLogVerbose("Data storage %s retrieved as %s", key,
-                   (value.get<bool>() ? "true" : "false"));
+      TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
+                             (value.get<bool>() ? "true" : "false")));
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
-      wxLogVerbose("Data storage %s retrieved as %d", key, value.get<int>());
+      TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
+                             value.get<int>()));
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
@@ -410,7 +412,7 @@ struct APState {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
 
-      wxLogVerbose("Data storage %s retrieved as dictionary", key);
+      TrackerLog(fmt::format("Data storage {} retrieved as dictionary", key));
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
@@ -418,7 +420,7 @@ struct APState {
         data_storage.erase(key);
       }
 
-      wxLogVerbose("Data storage %s retrieved as null", key);
+      TrackerLog(fmt::format("Data storage {} retrieved as null", key));
     } else if (value.is_array()) {
       auto list_value = value.get<std::vector<std::string>>();
 
@@ -429,8 +431,8 @@ struct APState {
         data_storage[key] = list_value;
       }
 
-      wxLogVerbose("Data storage %s retrieved as list: [%s]", key,
-                   hatkirby::implode(list_value, ", "));
+      TrackerLog(fmt::format("Data storage {} retrieved as list: [{}]", key,
+                             hatkirby::implode(list_value, ", ")));
     }
   }
 
@@ -440,7 +442,7 @@ struct APState {
 
   bool HasCheckedHuntPanel(int location_id) {
     std::string key =
-        data_storage_prefix + "Hunt|" + std::to_string(location_id);
+        fmt::format("{}Hunt|{}", data_storage_prefix, location_id);
     return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
   }
 
@@ -449,12 +451,13 @@ struct APState {
   }
 
   bool HasAchievement(const std::string& name) {
-    std::string key = data_storage_prefix + "Achievement|" + name;
+    std::string key =
+        fmt::format("{}Achievement|{}", data_storage_prefix, name);
     return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
   }
 
   const std::set<std::string>& GetCheckedPaintings() {
-    std::string key = data_storage_prefix + "Paintings";
+    std::string key = fmt::format("{}Paintings", data_storage_prefix);
     if (!data_storage.count(key)) {
       data_storage[key] = std::set<std::string>();
     }
@@ -471,7 +474,7 @@ struct APState {
   }
 
   void RefreshTracker(bool reset) {
-    wxLogVerbose("Refreshing display...");
+    TrackerLog("Refreshing display...");
 
     RecalculateReachability();
 
@@ -485,7 +488,7 @@ struct APState {
   int64_t GetItemId(const std::string& item_name) {
     int64_t ap_id = apclient->get_item_id(item_name);
     if (ap_id == APClient::INVALID_NAME_ID) {
-      wxLogError("Could not find AP item ID for %s", item_name);
+      TrackerLog(fmt::format("Could not find AP item ID for {}", item_name));
     }
 
     return ap_id;
@@ -564,16 +567,27 @@ int AP_GetMasteryRequirement() { return GetState().mastery_requirement; }
 int AP_GetLevel2Requirement() { return GetState().level_2_requirement; }
 
 bool AP_IsLocationVisible(int classification) {
+  int world_state = 0;
+
   switch (GetState().location_checks) {
     case kNORMAL_LOCATIONS:
-      return classification & kLOCATION_NORMAL;
+      world_state = kLOCATION_NORMAL;
+      break;
     case kREDUCED_LOCATIONS:
-      return classification & kLOCATION_REDUCED;
+      world_state = kLOCATION_REDUCED;
+      break;
     case kPANELSANITY:
-      return classification & kLOCATION_INSANITY;
+      world_state = kLOCATION_INSANITY;
+      break;
     default:
       return false;
   }
+
+  if (GetState().door_shuffle_mode && !GetState().early_color_hallways) {
+    world_state |= kLOCATION_SMALL_SPHERE_ONE;
+  }
+
+  return (world_state & classification);
 }
 
 VictoryCondition AP_GetVictoryCondition() {
@@ -1,11 +1,6 @@
 #include "game_data.h"
 
-#include <wx/wxprec.h>
-
-#ifndef WX_PRECOMP
-#include <wx/wx.h>
-#endif
-
+#include <fmt/core.h>
 #include <hkutil/string.h>
 #include <yaml-cpp/yaml.h>
 
@@ -13,6 +8,7 @@
 #include <sstream>
 
 #include "global.h"
+#include "logger.h"
 
 namespace {
 
@@ -36,7 +32,7 @@ LingoColor GetColorForString(const std::string &str) {
   } else if (str == "purple") {
     return LingoColor::kPurple;
   } else {
-    wxLogError("Invalid color: %s", str);
+    TrackerLog(fmt::format("Invalid color: {}", str));
 
     return LingoColor::kNone;
   }
@@ -90,7 +86,7 @@ struct GameData {
         ap_id_by_color_[GetColorForString(input_name)] =
             ids_config["special_items"][color_name].as<int>();
       } else {
-        wxLogError("Missing AP item ID for color %s", color_name);
+        TrackerLog(fmt::format("Missing AP item ID for color {}", color_name));
       }
     };
 
@@ -115,6 +111,7 @@ struct GameData {
         auto process_single_entrance =
             [this, room_id, from_room_id](const YAML::Node &option) {
               Exit exit_obj;
+              exit_obj.source_room = from_room_id; 
               exit_obj.destination_room = room_id;
 
               if (option["door"]) {
@@ -149,7 +146,7 @@ struct GameData {
         switch (entrance_it.second.Type()) {
           case YAML::NodeType::Scalar: {
             // This is just "true".
-            rooms_[from_room_id].exits.push_back({.destination_room = room_id});
+            rooms_[from_room_id].exits.push_back({.source_room = from_room_id, .destination_room = room_id});
             break;
           }
           case YAML::NodeType::Map: {
@@ -167,7 +164,8 @@ struct GameData {
             // This shouldn't happen.
             std::ostringstream formatted;
             formatted << entrance_it;
-            wxLogError("Error reading game data: %s", formatted.str());
+            TrackerLog(
+                fmt::format("Error reading game data: {}", formatted.str()));
             break;
           }
         }
@@ -292,8 +290,9 @@ struct GameData {
                           [panels_[panel_id].name]
                               .as<int>();
           } else {
-            wxLogError("Missing AP location ID for panel %s - %s",
-                       rooms_[room_id].name, panels_[panel_id].name);
+            TrackerLog(fmt::format("Missing AP location ID for panel {} - {}",
+                                   rooms_[room_id].name,
+                                   panels_[panel_id].name));
           }
         }
       }
@@ -356,8 +355,9 @@ struct GameData {
                             [doors_[door_id].name]["item"]
                                 .as<int>();
             } else {
-              wxLogError("Missing AP item ID for door %s - %s",
-                         rooms_[room_id].name, doors_[door_id].name);
+              TrackerLog(fmt::format("Missing AP item ID for door {} - {}",
+                                     rooms_[room_id].name,
+                                     doors_[door_id].name));
             }
           }
 
@@ -371,8 +371,8 @@ struct GameData {
                   ids_config["door_groups"][doors_[door_id].group_name]
                       .as<int>();
             } else {
-              wxLogError("Missing AP item ID for door group %s",
-                         doors_[door_id].group_name);
+              TrackerLog(fmt::format("Missing AP item ID for door group {}",
+                                     doors_[door_id].group_name));
             }
           }
 
@@ -382,11 +382,11 @@ struct GameData {
           } else if (!door_it.second["skip_location"] &&
                      !door_it.second["event"]) {
             if (has_external_panels) {
-              wxLogError(
-                  "%s - %s has panels from other rooms but does not have an "
+              TrackerLog(fmt::format(
+                  "{} - {} has panels from other rooms but does not have an "
                   "explicit location name and is not marked skip_location or "
                   "event",
-                  rooms_[room_id].name, doors_[door_id].name);
+                  rooms_[room_id].name, doors_[door_id].name));
             }
 
             doors_[door_id].location_name =
@@ -406,8 +406,9 @@ struct GameData {
                             [doors_[door_id].name]["location"]
                                 .as<int>();
             } else {
-              wxLogError("Missing AP location ID for door %s - %s",
-                         rooms_[room_id].name, doors_[door_id].name);
+              TrackerLog(fmt::format("Missing AP location ID for door {} - {}",
+                                     rooms_[room_id].name,
+                                     doors_[door_id].name));
             }
           }
 
@@ -524,8 +525,8 @@ struct GameData {
             progressive_item_id =
                 ids_config["progression"][progressive_item_name].as<int>();
           } else {
-            wxLogError("Missing AP item ID for progressive item %s",
-                       progressive_item_name);
+            TrackerLog(fmt::format("Missing AP item ID for progressive item {}",
+                                   progressive_item_name));
           }
 
           if (progression_it.second["doors"]) {
@@ -625,17 +626,20 @@ struct GameData {
         }
       }
 
+      if (room_name == "Starting Room") {
+        classification |= kLOCATION_SMALL_SPHERE_ONE;
+      }
+
       int area_id = AddOrGetArea(area_name);
       MapArea &map_area = map_areas_[area_id];
       // room field should be the original room ID
-      map_area.locations.push_back(
-          {.name = section_name,
-           .ap_location_name = location_name,
-           .ap_location_id = panel.ap_location_id,
-           .room = panel.room,
-           .panels = {panel.id},
-           .classification = classification,
-           .hunt = panel.hunt});
+      map_area.locations.push_back({.name = section_name,
+                                    .ap_location_name = location_name,
+                                    .ap_location_id = panel.ap_location_id,
+                                    .room = panel.room,
+                                    .panels = {panel.id},
+                                    .classification = classification,
+                                    .hunt = panel.hunt});
       locations_by_name[location_name] = {area_id,
                                           map_area.locations.size() - 1};
     }
@@ -713,7 +717,7 @@ struct GameData {
 
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
-      wxLogError("Area data not found for: %s", area);
+      TrackerLog(fmt::format("Area data not found for: {}", area));
     }
 
     // Read in subway items.
@@ -784,7 +788,7 @@ struct GameData {
 
     for (const auto &[tag, items] : subway_tags) {
       if (items.size() == 1) {
-        wxLogWarning("Singleton subway item tag: %s", tag);
+        TrackerLog(fmt::format("Singleton subway item tag: {}", tag));
       }
     }
   }
@@ -930,13 +934,11 @@ const SubwayItem &GD_GetSubwayItem(int id) {
   return GetState().subway_items_.at(id);
 }
 
-int GD_GetSubwayItemForPainting(const std::string &painting_id) {
-#ifndef NDEBUG
-  if (!GetState().subway_item_by_painting_.count(painting_id)) {
-    wxLogError("No subway item for painting %s", painting_id);
+std::optional<int> GD_GetSubwayItemForPainting(const std::string &painting_id) {
+  if (GetState().subway_item_by_painting_.count(painting_id)) {
+    return GetState().subway_item_by_painting_.at(painting_id);
   }
-#endif
-  return GetState().subway_item_by_painting_.at(painting_id);
+  return std::nullopt;
 }
 
 int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
@@ -22,6 +22,7 @@ enum class LingoColor {
 constexpr int kLOCATION_NORMAL = 1;
 constexpr int kLOCATION_REDUCED = 2;
 constexpr int kLOCATION_INSANITY = 4;
+constexpr int kLOCATION_SMALL_SPHERE_ONE = 8;
 
 enum class EntranceType {
   kNormal,
@@ -89,6 +90,7 @@ struct PanelDoor {
 };
 
 struct Exit {
+  int source_room;
   int destination_room;
   std::optional<int> door;
   EntranceType type = EntranceType::kNormal;
@@ -172,7 +174,7 @@ const std::vector<int>& GD_GetSunwarpDoors();
 int GD_GetRoomForSunwarp(int index);
 const std::vector<SubwayItem>& GD_GetSubwayItems();
 const SubwayItem& GD_GetSubwayItem(int id);
-int GD_GetSubwayItemForPainting(const std::string& painting_id);
+std::optional<int> GD_GetSubwayItemForPainting(const std::string& painting_id);
 int GD_GetSubwayItemForSunwarp(const SubwaySunwarp& sunwarp);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -0,0 +1,32 @@
+#include "logger.h"
+
+#include <chrono>
+#include <fstream>
+#include <mutex>
+
+#include "global.h"
+
+namespace {
+
+class Logger {
+ public:
+  Logger() : logfile_(GetAbsolutePath("debug.log")) {}
+
+  void LogLine(const std::string& text) {
+    std::lock_guard guard(file_mutex_);
+    logfile_ << "[" << std::chrono::system_clock::now() << "] " << text
+             << std::endl;
+    logfile_.flush();
+  }
+
+ private:
+  std::ofstream logfile_;
+  std::mutex file_mutex_;
+};
+
+}  // namespace
+
+void TrackerLog(std::string text) {
+  static Logger* instance = new Logger();
+  instance->LogLine(text);
+}
@@ -0,0 +1,8 @@
+#ifndef LOGGER_H_9BDD07EA
+#define LOGGER_H_9BDD07EA
+
+#include <string>
+
+void TrackerLog(std::string message);
+
+#endif /* end of include guard: LOGGER_H_9BDD07EA */
@@ -4,25 +4,13 @@
 #include <wx/wx.h>
 #endif
 
-#include <fstream>
-
 #include "global.h"
 #include "tracker_config.h"
 #include "tracker_frame.h"
 
-static std::ofstream* logfile;
-
 class TrackerApp : public wxApp {
  public:
   virtual bool OnInit() {
-    logfile = new std::ofstream(GetAbsolutePath("debug.log"));
-    wxLog::SetActiveTarget(new wxLogStream(logfile));
-    wxLog::SetVerbose(true);
-
-#ifndef NDEBUG
-    wxLog::SetActiveTarget(new wxLogWindow(nullptr, "Debug Log"));
-#endif
-
     GetTrackerConfig().Load();
 
     TrackerFrame *frame = new TrackerFrame();
@@ -1,5 +1,6 @@
 #include "subway_map.h"
 
+#include <fmt/core.h>
 #include <wx/dcbuffer.h>
 #include <wx/dcgraph.h>
 
@@ -15,6 +16,29 @@ constexpr int OWL_ACTUAL_SIZE = 32;
 
 enum class ItemDrawType { kNone, kBox, kOwl };
 
+namespace {
+
+std::optional<int> GetRealSubwayDoor(const SubwayItem subway_item) {
+  std::optional<int> subway_door = subway_item.door;
+  if (AP_IsSunwarpShuffle() && subway_item.sunwarp &&
+      subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
+    int sunwarp_index = subway_item.sunwarp->dots - 1;
+    if (subway_item.sunwarp->type == SubwaySunwarpType::kExit) {
+      sunwarp_index += 6;
+    }
+
+    for (const auto &[start_index, mapping] : AP_GetSunwarpMapping()) {
+      if (start_index == sunwarp_index || mapping.exit_index == sunwarp_index) {
+        subway_door = GD_GetSunwarpDoors().at(mapping.dots - 1);
+      }
+    }
+
+    return subway_door;
+  }
+}
+
+}  // namespace
+
 SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
   SetBackgroundStyle(wxBG_STYLE_PAINT);
 
@@ -70,9 +94,8 @@ void SubwayMap::OnConnect() {
   std::map<std::string, std::vector<int>> tagged;
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     if (AP_HasEarlyColorHallways() &&
-        (subway_item.special == "starting_room_paintings" ||
-         subway_item.special == "early_color_hallways")) {
-      tagged["early_color_hallways"].push_back(subway_item.id);
+        subway_item.special == "starting_room_paintings") {
+      tagged["early_ch"].push_back(subway_item.id);
     }
 
     if (AP_IsPaintingShuffle() && !subway_item.paintings.empty()) {
@@ -85,10 +108,8 @@ void SubwayMap::OnConnect() {
 
     if (!AP_IsSunwarpShuffle() && subway_item.sunwarp &&
         subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
-      std::ostringstream tag;
-      tag << "sunwarp" << subway_item.sunwarp->dots;
-
-      tagged[tag.str()].push_back(subway_item.id);
+      std::string tag = fmt::format("subway{}", subway_item.sunwarp->dots);
+      tagged[tag].push_back(subway_item.id);
     }
 
     if (!AP_IsPilgrimageEnabled() &&
@@ -100,8 +121,7 @@ void SubwayMap::OnConnect() {
 
   if (AP_IsSunwarpShuffle()) {
     for (const auto &[index, mapping] : AP_GetSunwarpMapping()) {
-      std::ostringstream tag;
-      tag << "sunwarp" << mapping.dots;
+      std::string tag = fmt::format("sunwarp{}", mapping.dots);
 
       SubwaySunwarp fromWarp;
       if (index < 6) {
@@ -121,8 +141,8 @@ void SubwayMap::OnConnect() {
         toWarp.type = SubwaySunwarpType::kExit;
       }
 
-      tagged[tag.str()].push_back(GD_GetSubwayItemForSunwarp(fromWarp));
-      tagged[tag.str()].push_back(GD_GetSubwayItemForSunwarp(toWarp));
+      tagged[tag].push_back(GD_GetSubwayItemForSunwarp(fromWarp));
+      tagged[tag].push_back(GD_GetSubwayItemForSunwarp(toWarp));
     }
   }
 
@@ -147,9 +167,13 @@ void SubwayMap::UpdateIndicators() {
         checked_paintings_.insert(painting_id);
 
         if (AP_GetPaintingMapping().count(painting_id)) {
-          networks_.AddLink(GD_GetSubwayItemForPainting(painting_id),
-                            GD_GetSubwayItemForPainting(
-                                AP_GetPaintingMapping().at(painting_id)));
+          std::optional<int> from_id = GD_GetSubwayItemForPainting(painting_id);
+          std::optional<int> to_id = GD_GetSubwayItemForPainting(
+              AP_GetPaintingMapping().at(painting_id));
+
+          if (from_id && to_id) {
+            networks_.AddLink(*from_id, *to_id);
+          }
         }
       }
     }
@@ -266,9 +290,11 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
     // Note that these requirements are duplicated on OnMouseClick so that it
     // knows when an item has a hover effect.
     const SubwayItem &subway_item = GD_GetSubwayItem(*hovered_item_);
-    if (subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) {
+    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
+
+    if (subway_door && !GetDoorRequirements(*subway_door).empty()) {
       const std::map<std::string, bool> &report =
-          GetDoorRequirements(*subway_item.door);
+          GetDoorRequirements(*subway_door);
 
       int acc_height = 10;
       int col_width = 0;
@@ -404,7 +430,7 @@ void SubwayMap::OnMouseMove(wxMouseEvent &event) {
   std::vector<int> hovered = tree_->query(
       {static_cast<float>(mouse_pos.x), static_cast<float>(mouse_pos.y), 2, 2});
   if (!hovered.empty()) {
-    actual_hover_= hovered[0];
+    actual_hover_ = hovered[0];
   } else {
     actual_hover_ = std::nullopt;
   }
@@ -449,7 +475,9 @@ void SubwayMap::OnMouseClick(wxMouseEvent &event) {
 
   if (actual_hover_) {
     const SubwayItem &subway_item = GD_GetSubwayItem(*actual_hover_);
-    if ((subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) ||
+    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
+
+    if ((subway_door && !GetDoorRequirements(*subway_door).empty()) ||
         networks_.IsItemInNetwork(*hovered_item_)) {
       if (actual_hover_ != hovered_item_) {
         hovered_item_ = actual_hover_;
@@ -530,15 +558,9 @@ void SubwayMap::Redraw() {
     std::optional<wxColour> shade_color;
 
     if (AP_HasEarlyColorHallways() &&
-        (subway_item.special == "starting_room_paintings" ||
-         subway_item.special == "early_color_hallways")) {
+        subway_item.special == "starting_room_paintings") {
       draw_type = ItemDrawType::kOwl;
-
-      if (subway_item.special == "starting_room_paintings") {
-        shade_color = wxColour(0, 255, 0, 128);
-      } else {
-        shade_color = wxColour(255, 0, 0, 128);
-      }
+      shade_color = wxColour(0, 255, 0, 128);
     } else if (subway_item.special == "sun_painting") {
       if (!AP_IsPilgrimageEnabled()) {
         if (IsDoorOpen(*subway_item.door)) {
@@ -570,7 +592,8 @@ void SubwayMap::Redraw() {
           }
         }
 
-        if (has_unchecked_painting || has_mapped_painting || has_codomain_painting) {
+        if (has_unchecked_painting || has_mapped_painting ||
+            has_codomain_painting) {
           draw_type = ItemDrawType::kOwl;
 
           if (has_checked_painting) {
@@ -157,7 +157,7 @@ void TrackerFrame::OnConnect(wxCommandEvent &event) {
       }
     }
 
-    while (new_history.size() > 5) {
+    while (new_history.size() > 10) {
       new_history.pop_back();
     }
 
@@ -1,5 +1,8 @@
 #include "tracker_state.h"
 
+#include <fmt/core.h>
+#include <hkutil/string.h>
+
 #include <list>
 #include <map>
 #include <mutex>
@@ -9,6 +12,7 @@
 
 #include "ap_state.h"
 #include "game_data.h"
+#include "logger.h"
 
 namespace {
 
@@ -231,7 +235,9 @@ class StateCalculator {
             PaintingExit target_painting =
                 GD_GetPaintingExit(GD_GetPaintingByName(
                     AP_GetPaintingMapping().at(cur_painting.internal_id)));
+            painting_exit.source_room = cur_painting.room;
             painting_exit.destination_room = target_painting.room;
+            painting_exit.type = EntranceType::kPainting;
 
             new_boundary.push_back(painting_exit);
           }
@@ -258,6 +264,12 @@ class StateCalculator {
           reachable_rooms_.insert(room_exit.destination_room);
           reachable_changed = true;
 
+#ifndef NDEBUG
+          std::list<int> room_path = paths_[room_exit.source_room];
+          room_path.push_back(room_exit.destination_room);
+          paths_[room_exit.destination_room] = room_path;
+#endif
+
           const Room& room_obj = GD_GetRoom(room_exit.destination_room);
           for (const Exit& out_edge : room_obj.exits) {
             if (out_edge.type == EntranceType::kPainting &&
@@ -296,20 +308,33 @@ class StateCalculator {
 
           if (AP_HasEarlyColorHallways() && room_obj.name == "Starting Room") {
             new_boundary.push_back(
-                {.destination_room = GD_GetRoomByName("Outside The Undeterred"),
+                {.source_room = room_exit.destination_room,
+                 .destination_room = GD_GetRoomByName("Outside The Undeterred"),
                  .type = EntranceType::kPainting});
           }
 
           if (AP_IsPilgrimageEnabled()) {
-            if (room_obj.name == "Hub Room") {
+            int pilgrimage_start_id = GD_GetRoomByName("Hub Room");
+            if (AP_IsSunwarpShuffle()) {
+              for (const auto& [start_index, mapping] :
+                   AP_GetSunwarpMapping()) {
+                if (mapping.dots == 1) {
+                  pilgrimage_start_id = GD_GetRoomForSunwarp(start_index);
+                }
+              }
+            }
+
+            if (room_exit.destination_room == pilgrimage_start_id) {
               new_boundary.push_back(
-                  {.destination_room = GD_GetRoomByName("Pilgrim Antechamber"),
+                  {.source_room = room_exit.destination_room,
+                   .destination_room = GD_GetRoomByName("Pilgrim Antechamber"),
                    .type = EntranceType::kPilgrimage});
             }
           } else {
             if (room_obj.name == "Starting Room") {
               new_boundary.push_back(
-                  {.destination_room = GD_GetRoomByName("Pilgrim Antechamber"),
+                  {.source_room = room_exit.destination_room,
+                   .destination_room = GD_GetRoomByName("Pilgrim Antechamber"),
                    .door =
                        GD_GetDoorByName("Pilgrim Antechamber - Sun Painting"),
                    .type = EntranceType::kPainting});
@@ -350,6 +375,19 @@ class StateCalculator {
     return door_report_;
   }
 
+  std::string GetPathToRoom(int room_id) const {
+    if (!paths_.count(room_id)) {
+      return "";
+    }
+
+    const std::list<int>& path = paths_.at(room_id);
+    std::vector<std::string> room_names;
+    for (int room_id : path) {
+      room_names.push_back(GD_GetRoom(room_id).name);
+    }
+    return hatkirby::implode(room_names, " -> ");
+  }
+
  private:
   template <typename T>
   Decision IsNonGroupedDoorReachable(const T& door_obj) {
@@ -603,6 +641,8 @@ class StateCalculator {
   std::set<int> solveable_panels_;
   std::set<int> reachable_paintings_;
   std::map<int, std::map<std::string, bool>> door_report_;
+
+  std::map<int, std::list<int>> paths_;
 };
 
 }  // namespace
@@ -1,9 +1,10 @@
 #ifndef VERSION_H_C757E53C
 #define VERSION_H_C757E53C
 
-#include <sstream>
 #include <regex>
 
+#include <fmt/core.h>
+
 struct Version {
   int major = 0;
   int minor = 0;
@@ -24,9 +25,7 @@ struct Version {
   }
 
   std::string ToString() const {
-    std::ostringstream output;
-    output << "v" << major << "." << minor << "." << revision;
-    return output.str();
+    return fmt::format("v{}.{}.{}", major, minor, revision);
   }
 
   bool operator<(const Version& rhs) const {
@@ -37,6 +36,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 10, 2);
+constexpr const Version kTrackerVersion = Version(0, 10, 6);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file