1 files changed, 118 insertions, 45 deletions

@@ -21,7 +21,6 @@
 #include <tuple>
 
 #include "game_data.h"
-#include "logger.h"
 #include "tracker_frame.h"
 #include "tracker_state.h"
 
@@ -72,11 +71,12 @@ struct APState {
   bool sunwarp_shuffle = false;
 
   std::map<std::string, std::string> painting_mapping;
+  std::set<std::string> painting_codomain;
   std::map<int, SunwarpMapping> sunwarp_mapping;
 
   void Connect(std::string server, std::string player, std::string password) {
     if (!initialized) {
-      TrackerLog("Initializing APState...");
+      wxLogVerbose("Initializing APState...");
 
       std::thread([this]() {
         for (;;) {
@@ -104,15 +104,16 @@ struct APState {
       }
 
       tracked_data_storage_keys.push_back("PlayerPos");
+      tracked_data_storage_keys.push_back("Paintings");
 
       initialized = true;
     }
 
     tracker_frame->SetStatusMessage("Connecting to Archipelago server....");
-    TrackerLog("Connecting to Archipelago server (" + server + ")...");
+    wxLogStatus("Connecting to Archipelago server (%s)...", server);
 
     {
-      TrackerLog("Destroying old AP client...");
+      wxLogVerbose("Destroying old AP client...");
 
       std::lock_guard client_guard(client_mutex);
 
@@ -139,6 +140,7 @@ struct APState {
     color_shuffle = false;
     painting_shuffle = false;
     painting_mapping.clear();
+    painting_codomain.clear();
     mastery_requirement = 21;
     level_2_requirement = 223;
     location_checks = kNORMAL_LOCATIONS;
@@ -151,16 +153,17 @@ struct APState {
     sunwarp_shuffle = false;
     sunwarp_mapping.clear();
 
+    std::mutex connection_mutex;
     connected = false;
     has_connection_result = false;
 
     apclient->set_room_info_handler([this, player, password]() {
       inventory.clear();
 
-      TrackerLog("Connected to Archipelago server. Authenticating as " +
-                 player +
-                 (password.empty() ? " without password"
-                                   : " with password " + password));
+      wxLogStatus("Connected to Archipelago server. Authenticating as %s %s",
+                  player,
+                  (password.empty() ? "without password"
+                                    : "with password " + password));
       tracker_frame->SetStatusMessage(
           "Connected to Archipelago server. Authenticating...");
 
@@ -172,23 +175,23 @@ struct APState {
         [this](const std::list<int64_t>& locations) {
           for (const int64_t location_id : locations) {
             checked_locations.insert(location_id);
-            TrackerLog("Location: " + std::to_string(location_id));
+            wxLogVerbose("Location: %lld", location_id);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_slot_disconnected_handler([this]() {
       tracker_frame->SetStatusMessage(
           "Disconnected from Archipelago. Attempting to reconnect...");
-      TrackerLog(
+      wxLogStatus(
           "Slot disconnected from Archipelago. Attempting to reconnect...");
     });
 
     apclient->set_socket_disconnected_handler([this]() {
       tracker_frame->SetStatusMessage(
           "Disconnected from Archipelago. Attempting to reconnect...");
-      TrackerLog(
+      wxLogStatus(
           "Socket disconnected from Archipelago. Attempting to reconnect...");
     });
 
@@ -196,10 +199,10 @@ struct APState {
         [this](const std::list<APClient::NetworkItem>& items) {
           for (const APClient::NetworkItem& item : items) {
             inventory[item.item]++;
-            TrackerLog("Item: " + std::to_string(item.item));
+            wxLogVerbose("Item: %lld", item.item);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_retrieved_handler(
@@ -208,20 +211,20 @@ struct APState {
             HandleDataStorage(key, value);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_set_reply_handler([this](const std::string& key,
                                            const nlohmann::json& value,
                                            const nlohmann::json&) {
       HandleDataStorage(key, value);
-      RefreshTracker();
+      RefreshTracker(false);
     });
 
-    apclient->set_slot_connected_handler([this](
+    apclient->set_slot_connected_handler([this, &connection_mutex](
                                              const nlohmann::json& slot_data) {
       tracker_frame->SetStatusMessage("Connected to Archipelago!");
-      TrackerLog("Connected to Archipelago!");
+      wxLogStatus("Connected to Archipelago!");
 
       data_storage_prefix =
           "Lingo_" + std::to_string(apclient->get_player_number()) + "_";
@@ -266,6 +269,7 @@ struct APState {
         for (const auto& mapping_it :
              slot_data["painting_entrance_to_exit"].items()) {
           painting_mapping[mapping_it.key()] = mapping_it.value();
+          painting_codomain.insert(mapping_it.value());
         }
       }
 
@@ -281,11 +285,6 @@ struct APState {
         }
       }
 
-      connected = true;
-      has_connection_result = true;
-
-      RefreshTracker();
-
       std::list<std::string> corrected_keys;
       for (const std::string& key : tracked_data_storage_keys) {
         corrected_keys.push_back(data_storage_prefix + key);
@@ -302,12 +301,23 @@ struct APState {
 
       apclient->Get(corrected_keys);
       apclient->SetNotify(corrected_keys);
+
+      {
+        std::lock_guard connection_lock(connection_mutex);
+        if (!has_connection_result) {
+          connected = true;
+          has_connection_result = true;
+        }
+      }
     });
 
     apclient->set_slot_refused_handler(
-        [this](const std::list<std::string>& errors) {
-          connected = false;
-          has_connection_result = true;
+        [this, &connection_mutex](const std::list<std::string>& errors) {
+          {
+            std::lock_guard connection_lock(connection_mutex);
+            connected = false;
+            has_connection_result = true;
+          }
 
           tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
 
@@ -336,7 +346,7 @@ struct APState {
           }
 
           std::string full_message = hatkirby::implode(error_messages, " ");
-          TrackerLog(full_message);
+          wxLogError(wxString(full_message));
 
           wxMessageBox(full_message, "Connection failed", wxOK | wxICON_ERROR);
         });
@@ -346,18 +356,29 @@ struct APState {
     int timeout = 5000;  // 5 seconds
     int interval = 100;
     int remaining_loops = timeout / interval;
-    while (!has_connection_result) {
-      if (interval == 0) {
-        connected = false;
-        has_connection_result = true;
+    while (true) {
+      {
+        std::lock_guard connection_lock(connection_mutex);
+        if (has_connection_result) {
+          break;
+        }
+      }
 
+      if (interval == 0) {
         DestroyClient();
 
         tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
-
-        TrackerLog("Timeout while connecting to Archipelago server.");
+        wxLogStatus("Timeout while connecting to Archipelago server.");
         wxMessageBox("Timeout while connecting to Archipelago server.",
                      "Connection failed", wxOK | wxICON_ERROR);
+
+        {
+          std::lock_guard connection_lock(connection_mutex);
+          connected = false;
+          has_connection_result = true;
+        }
+
+        break;
       }
 
       std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -366,7 +387,8 @@ struct APState {
     }
 
     if (connected) {
-      RefreshTracker();
+      ResetReachabilityRequirements();
+      RefreshTracker(true);
     } else {
       client_active = false;
     }
@@ -375,12 +397,11 @@ struct APState {
   void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
-      TrackerLog("Data storage " + key + " retrieved as " +
-                 (value.get<bool>() ? "true" : "false"));
+      wxLogVerbose("Data storage %s retrieved as %s", key,
+                   (value.get<bool>() ? "true" : "false"));
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
-      TrackerLog("Data storage " + key + " retrieved as " +
-                 std::to_string(value.get<int>()));
+      wxLogVerbose("Data storage %s retrieved as %d", key, value.get<int>());
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
@@ -389,7 +410,7 @@ struct APState {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
 
-      TrackerLog("Data storage " + key + " retrieved as dictionary");
+      wxLogVerbose("Data storage %s retrieved as dictionary", key);
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
@@ -397,7 +418,19 @@ struct APState {
         data_storage.erase(key);
       }
 
-      TrackerLog("Data storage " + key + " retrieved as null");
+      wxLogVerbose("Data storage %s retrieved as null", key);
+    } else if (value.is_array()) {
+      auto list_value = value.get<std::vector<std::string>>();
+
+      if (key.ends_with("Paintings")) {
+        data_storage[key] =
+            std::set<std::string>(list_value.begin(), list_value.end());
+      } else {
+        data_storage[key] = list_value;
+      }
+
+      wxLogVerbose("Data storage %s retrieved as list: [%s]", key,
+                   hatkirby::implode(list_value, ", "));
     }
   }
 
@@ -420,22 +453,46 @@ struct APState {
     return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
   }
 
-  void RefreshTracker() {
-    TrackerLog("Refreshing display...");
+  const std::set<std::string>& GetCheckedPaintings() {
+    std::string key = data_storage_prefix + "Paintings";
+    if (!data_storage.count(key)) {
+      data_storage[key] = std::set<std::string>();
+    }
+
+    return std::any_cast<const std::set<std::string>&>(data_storage.at(key));
+  }
+
+  bool IsPaintingChecked(const std::string& painting_id) {
+    const auto& checked_paintings = GetCheckedPaintings();
+
+    return checked_paintings.count(painting_id) ||
+           (painting_mapping.count(painting_id) &&
+            checked_paintings.count(painting_mapping.at(painting_id)));
+  }
+
+  void RefreshTracker(bool reset) {
+    wxLogVerbose("Refreshing display...");
 
     RecalculateReachability();
-    tracker_frame->UpdateIndicators();
+
+    if (reset) {
+      tracker_frame->ResetIndicators();
+    } else {
+      tracker_frame->UpdateIndicators();
+    }
   }
 
   int64_t GetItemId(const std::string& item_name) {
     int64_t ap_id = apclient->get_item_id(item_name);
     if (ap_id == APClient::INVALID_NAME_ID) {
-      TrackerLog("Could not find AP item ID for " + item_name);
+      wxLogError("Could not find AP item ID for %s", item_name);
     }
 
     return ap_id;
   }
 
+  std::string GetItemName(int id) { return apclient->get_item_name(id); }
+
   bool HasReachedGoal() {
     return data_storage.count(victory_data_storage_key) &&
            std::any_cast<int>(data_storage.at(victory_data_storage_key)) ==
@@ -474,6 +531,10 @@ bool AP_HasItem(int item_id, int quantity) {
   return GetState().HasItem(item_id, quantity);
 }
 
+std::string AP_GetItemName(int item_id) {
+  return GetState().GetItemName(item_id);
+}
+
 DoorShuffleMode AP_GetDoorShuffleMode() { return GetState().door_shuffle_mode; }
 
 bool AP_AreDoorsGrouped() { return GetState().group_doors; }
@@ -482,10 +543,22 @@ bool AP_IsColorShuffle() { return GetState().color_shuffle; }
 
 bool AP_IsPaintingShuffle() { return GetState().painting_shuffle; }
 
-const std::map<std::string, std::string> AP_GetPaintingMapping() {
+const std::map<std::string, std::string>& AP_GetPaintingMapping() {
   return GetState().painting_mapping;
 }
 
+bool AP_IsPaintingMappedTo(const std::string& painting_id) {
+  return GetState().painting_codomain.count(painting_id);
+}
+
+const std::set<std::string>& AP_GetCheckedPaintings() {
+  return GetState().GetCheckedPaintings();
+}
+
+bool AP_IsPaintingChecked(const std::string& painting_id) {
+  return GetState().IsPaintingChecked(painting_id);
+}
+
 int AP_GetMasteryRequirement() { return GetState().mastery_requirement; }
 
 int AP_GetLevel2Requirement() { return GetState().level_2_requirement; }