Use sync fields for hunt panels

8 files changed, 81 insertions, 30 deletions

@@ -10,6 +10,7 @@
 #include <any>
 #include <apclient.hpp>
 #include <apuuid.hpp>
+#include <bitset>
 #include <chrono>
 #include <exception>
 #include <filesystem>
@@ -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,14 +223,6 @@ 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;
   }
@@ -288,6 +287,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) {
@@ -300,11 +305,8 @@ struct APState {
             "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");
@@ -610,8 +612,6 @@ struct APState {
 
       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>();
@@ -620,6 +620,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")) {
@@ -720,10 +735,6 @@ 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);
 }
@@ -892,3 +903,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,8 +57,6 @@ 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);
@@ -122,4 +120,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 */
@@ -145,7 +145,8 @@ void AreaPopup::UpdateIndicators() {
         } else {
           checked = AP_HasCheckedGameLocation(location.ap_location_id) ||
                     (location.hunt &&
-                     AP_HasCheckedHuntPanel(location.ap_location_id));
+                     AP_IsPanelSolved(
+                         GD_GetPanel(*location.single_panel).solve_index));
         }
 
         const wxBitmap* eye_ptr = checked ? checked_eye_ : unchecked_eye_;
@@ -33,6 +33,7 @@ struct GameData {
 
   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_;
 
@@ -77,6 +78,8 @@ struct GameData {
 
     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);
@@ -266,10 +269,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,
@@ -563,6 +567,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;
@@ -938,6 +957,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_;
 }
@@ -57,6 +57,7 @@ struct Panel {
   int ap_location_id = -1;
   bool hunt = false;
   int panel_door = -1;
+  int solve_index = -1;
 };
 
 struct ProgressiveRequirement {
@@ -176,6 +177,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);
@@ -9,6 +9,7 @@
 #include <wx/stdpaths.h>
 #include <wx/webrequest.h>
 
+#include <algorithm>
 #include <nlohmann/json.hpp>
 #include <sstream>
 
@@ -358,10 +359,17 @@ void TrackerFrame::OnStateChanged(StateChangedEvent &event) {
 
     return;
   }
+
+  bool hunt_panels = false;
+  if (GetTrackerConfig().show_hunt_panels) {
+    hunt_panels = std::any_of(
+        state.panels.begin(), state.panels.end(), [](int solve_index) {
+          return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index)).hunt;
+        });
+  }
   
   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.
@@ -8,6 +8,7 @@
 #endif
 
 #include <memory>
+#include <set>
 
 #include "ap_state.h"
 #include "icons.h"
@@ -55,7 +56,7 @@ struct StateUpdate {
   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;
 };
@@ -293,7 +293,8 @@ void TrackerPanel::Redraw() {
       } else if (AP_IsLocationVisible(section.classification)) {
         has_unchecked = !AP_HasCheckedGameLocation(section.ap_location_id);
       } else if (section.hunt && GetTrackerConfig().show_hunt_panels) {
-        has_unchecked = !AP_HasCheckedHuntPanel(section.ap_location_id);
+        has_unchecked =
+            !AP_IsPanelSolved(GD_GetPanel(*section.single_panel).solve_index);
       }
 
       if (has_unchecked) {