1 files changed, 151 insertions, 60 deletions

@@ -10,6 +10,7 @@
 #include <any>
 #include <apclient.hpp>
 #include <apuuid.hpp>
+#include <bitset>
 #include <chrono>
 #include <exception>
 #include <filesystem>
@@ -28,8 +29,8 @@
 #include "tracker_state.h"
 
 constexpr int AP_MAJOR = 0;
-constexpr int AP_MINOR = 4;
-constexpr int AP_REVISION = 5;
+constexpr int AP_MINOR = 6;
+constexpr int AP_REVISION = 1;
 
 constexpr const char* CERT_STORE_PATH = "cacert.pem";
 constexpr int ITEM_HANDLING = 7;  // <- all
@@ -37,8 +38,24 @@ constexpr int ITEM_HANDLING = 7;  // <- all
 constexpr int CONNECTION_TIMEOUT = 50000;  // 50 seconds
 constexpr int CONNECTION_BACKOFF_INTERVAL = 100;
 
+constexpr int PANEL_COUNT = 803;
+constexpr int PANEL_BITFIELD_LENGTH = 48;
+constexpr int PANEL_BITFIELDS = 17;
+
 namespace {
 
+const std::set<long> kNonProgressionItems = {
+    444409,  // :)
+    444575,  // The Feeling of Being Lost
+    444576,  // Wanderlust
+    444577,  // Empty White Hallways
+    444410,  // Slowness Trap
+    444411,  // Iceland Trap
+    444412,  // Atbash Trap
+    444413,  // Puzzle Skip
+    444680,  // Speed Boost
+};
+
 struct APState {
   // Initialized on main thread
   bool initialized = false;
@@ -67,10 +84,12 @@ struct APState {
   std::set<int64_t> checked_locations;
   std::map<std::string, std::any> data_storage;
   std::optional<std::tuple<int, int>> player_pos;
+  std::bitset<PANEL_COUNT> solved_panels;
 
   DoorShuffleMode door_shuffle_mode = kNO_DOORS;
   bool group_doors = false;
   bool color_shuffle = false;
+  PanelShuffleMode panel_shuffle_mode = kNO_PANELS;
   bool painting_shuffle = false;
   int mastery_requirement = 21;
   int level_2_requirement = 223;
@@ -82,6 +101,7 @@ struct APState {
   bool pilgrimage_allows_paintings = false;
   SunwarpAccess sunwarp_access = kSUNWARP_ACCESS_NORMAL;
   bool sunwarp_shuffle = false;
+  bool postgame_shuffle = true;
 
   std::map<std::string, std::string> painting_mapping;
   std::set<std::string> painting_codomain;
@@ -128,10 +148,12 @@ struct APState {
         checked_locations.clear();
         data_storage.clear();
         player_pos = std::nullopt;
+        solved_panels.reset();
         victory_data_storage_key.clear();
         door_shuffle_mode = kNO_DOORS;
         group_doors = false;
         color_shuffle = false;
+        panel_shuffle_mode = kNO_PANELS;
         painting_shuffle = false;
         painting_mapping.clear();
         painting_codomain.clear();
@@ -146,6 +168,7 @@ struct APState {
         sunwarp_access = kSUNWARP_ACCESS_NORMAL;
         sunwarp_shuffle = false;
         sunwarp_mapping.clear();
+        postgame_shuffle = true;
       }
 
       apclient->set_room_info_handler(
@@ -200,24 +223,13 @@ struct APState {
     return checked_locations.count(location_id);
   }
 
-  bool HasCheckedHuntPanel(int location_id) {
-    std::lock_guard state_guard(state_mutex);
-
-    std::string key =
-        fmt::format("{}Hunt|{}", data_storage_prefix, location_id);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
-  }
-
   bool HasItem(int item_id, int quantity) {
     return inventory.count(item_id) && inventory.at(item_id) >= quantity;
   }
 
-  bool HasAchievement(const std::string& name) {
+  bool HasItemSafe(int item_id, int quantity) {
     std::lock_guard state_guard(state_mutex);
-
-    std::string key =
-        fmt::format("{}Achievement|{}", data_storage_prefix, name);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
+    return HasItem(item_id, quantity);
   }
 
   const std::set<std::string>& GetCheckedPaintings() {
@@ -241,7 +253,21 @@ struct APState {
             checked_paintings.count(painting_mapping.at(painting_id)));
   }
 
-  std::string GetItemName(int id) { return apclient->get_item_name(id); }
+  void RevealPaintings() {
+    std::lock_guard state_guard(state_mutex);
+
+    std::vector<std::string> paintings;
+    for (const PaintingExit& painting : GD_GetPaintings()) {
+      paintings.push_back(painting.internal_id);
+    }
+
+    APClient::DataStorageOperation operation;
+    operation.operation = "replace";
+    operation.value = paintings;
+
+    apclient->Set(fmt::format("{}Paintings", data_storage_prefix), "", true,
+                  {operation});
+  }
 
   bool HasReachedGoal() {
     std::lock_guard state_guard(state_mutex);
@@ -251,6 +277,12 @@ struct APState {
                30;  // CLIENT_GOAL
   }
 
+  bool IsPanelSolved(int solve_index) {
+    std::lock_guard state_guard(state_mutex);
+
+    return solved_panels.test(solve_index);
+  }
+
  private:
   void Initialize() {
     if (!initialized) {
@@ -258,16 +290,8 @@ struct APState {
 
       std::thread([this]() { Thread(); }).detach();
 
-      for (int panel_id : GD_GetAchievementPanels()) {
-        tracked_data_storage_keys.push_back(fmt::format(
-            "Achievement|{}", GD_GetPanel(panel_id).achievement_name));
-      }
-
-      for (const MapArea& map_area : GD_GetMapAreas()) {
-        for (const Location& location : map_area.locations) {
-          tracked_data_storage_keys.push_back(
-              fmt::format("Hunt|{}", location.ap_location_id));
-        }
+      for (int i = 0; i < PANEL_BITFIELDS; i++) {
+        tracked_data_storage_keys.push_back(fmt::format("Panels_{}", i));
       }
 
       tracked_data_storage_keys.push_back("PlayerPos");
@@ -351,7 +375,7 @@ struct APState {
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(StateUpdate{.cleared_locations = true});
   }
 
   void OnSlotDisconnected() {
@@ -373,37 +397,59 @@ struct APState {
   }
 
   void OnItemsReceived(const std::list<APClient::NetworkItem>& items) {
+    std::vector<ItemState> item_states;
+    bool progression_items = false;
+
     {
       std::lock_guard state_guard(state_mutex);
 
+      std::map<int64_t, int> index_by_item;
+
       for (const APClient::NetworkItem& item : items) {
         inventory[item.item]++;
         TrackerLog(fmt::format("Item: {}", item.item));
+
+        index_by_item[item.item] = item.index;
+
+        if (!kNonProgressionItems.count(item.item)) {
+          progression_items = true;
+        }
+      }
+
+      for (const auto& [item_id, item_index] : index_by_item) {
+        item_states.push_back(ItemState{.name = GD_GetItemName(item_id),
+                                        .amount = inventory[item_id],
+                                        .index = item_index});
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(StateUpdate{.items = item_states,
+                               .progression_items = progression_items});
   }
 
   void OnRetrieved(const std::map<std::string, nlohmann::json>& data) {
+    StateUpdate state_update;
+
     {
       std::lock_guard state_guard(state_mutex);
 
       for (const auto& [key, value] : data) {
-        HandleDataStorage(key, value);
+        HandleDataStorage(key, value, state_update);
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(state_update);
   }
 
   void OnSetReply(const std::string& key, const nlohmann::json& value) {
+    StateUpdate state_update;
+
     {
       std::lock_guard state_guard(state_mutex);
-      HandleDataStorage(key, value);
+      HandleDataStorage(key, value, state_update);
     }
 
-    RefreshTracker(false);
+    RefreshTracker(state_update);
   }
 
   void OnSlotConnected(std::string player, std::string server,
@@ -435,6 +481,7 @@ struct APState {
         }
       }
       color_shuffle = slot_data["shuffle_colors"].get<int>() == 1;
+      panel_shuffle_mode = slot_data["shuffle_panels"].get<PanelShuffleMode>();
       painting_shuffle = slot_data["shuffle_paintings"].get<int>() == 1;
       mastery_requirement = slot_data["mastery_achievements"].get<int>();
       level_2_requirement = slot_data["level_2_requirement"].get<int>();
@@ -456,6 +503,9 @@ struct APState {
                            : kSUNWARP_ACCESS_NORMAL;
       sunwarp_shuffle = slot_data.contains("shuffle_sunwarps") &&
                         slot_data["shuffle_sunwarps"].get<int>() == 1;
+      postgame_shuffle = slot_data.contains("shuffle_postgame")
+                             ? (slot_data["shuffle_postgame"].get<int>() == 1)
+                             : true;
 
       if (painting_shuffle && slot_data.contains("painting_entrance_to_exit")) {
         painting_mapping.clear();
@@ -497,7 +547,7 @@ struct APState {
     }
 
     ResetReachabilityRequirements();
-    RefreshTracker(true);
+    RefreshTracker(std::nullopt);
   }
 
   void OnSlotRefused(const std::list<std::string>& errors) {
@@ -540,19 +590,40 @@ struct APState {
   }
 
   // Assumes state mutex is locked.
-  void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
+  void HandleDataStorage(const std::string& key, const nlohmann::json& value, StateUpdate& state_update) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
       TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
                              (value.get<bool>() ? "true" : "false")));
+
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
       TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
                              value.get<int>()));
+
+      if (key == victory_data_storage_key) {
+        state_update.cleared_locations = true;
+      } else if (key.find("Panels_") != std::string::npos) {
+        int bitfield_num =
+            std::stoi(key.substr(data_storage_prefix.size() + 7));
+        uint64_t bitfield_value = value.get<uint64_t>();
+        for (int i = 0; i < PANEL_BITFIELD_LENGTH; i++) {
+          if ((bitfield_value & (1LL << i)) != 0) {
+            int solve_index = bitfield_num * PANEL_BITFIELD_LENGTH + i;
+            
+            if (!solved_panels.test(solve_index)) {
+              state_update.panels.insert(solve_index);
+            }
+            
+            solved_panels.set(solve_index);
+          }
+        }
+      }
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
         player_pos = std::tuple<int, int>(map_value["x"], map_value["z"]);
+        state_update.player_position = true;
       } else {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
@@ -561,6 +632,7 @@ struct APState {
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
+        state_update.player_position = true;
       } else {
         data_storage.erase(key);
       }
@@ -572,6 +644,8 @@ struct APState {
       if (key.ends_with("Paintings")) {
         data_storage[key] =
             std::set<std::string>(list_value.begin(), list_value.end());
+        state_update.paintings =
+            std::vector<std::string>(list_value.begin(), list_value.end());
       } else {
         data_storage[key] = list_value;
       }
@@ -582,29 +656,34 @@ struct APState {
   }
 
   // State mutex should NOT be locked.
-  void RefreshTracker(bool reset) {
+  // nullopt state_update indicates a reset.
+  void RefreshTracker(std::optional<StateUpdate> state_update) {
     TrackerLog("Refreshing display...");
 
-    std::string prev_msg;
-    {
-      std::lock_guard state_guard(state_mutex);
+    if (!state_update || state_update->progression_items ||
+        !state_update->paintings.empty()) {
+      std::string prev_msg;
+      {
+        std::lock_guard state_guard(state_mutex);
 
-      prev_msg = status_message;
-      SetStatusMessage(fmt::format("{} Recalculating...", status_message));
-    }
+        prev_msg = status_message;
+        SetStatusMessage(fmt::format("{} Recalculating...", status_message));
+      }
 
-    RecalculateReachability();
+      RecalculateReachability();
 
-    if (reset) {
-      tracker_frame->ResetIndicators();
-    } else {
-      tracker_frame->UpdateIndicators();
-    }
+      {
+        std::lock_guard state_guard(state_mutex);
 
-    {
-      std::lock_guard state_guard(state_mutex);
+        SetStatusMessage(prev_msg);
+      }
+    }
+    
 
-      SetStatusMessage(prev_msg);
+    if (!state_update) {
+      tracker_frame->ResetIndicators();
+    } else {
+      tracker_frame->UpdateIndicators(*state_update);
     }
   }
 
@@ -639,16 +718,12 @@ bool AP_HasCheckedGameLocation(int location_id) {
   return GetState().HasCheckedGameLocation(location_id);
 }
 
-bool AP_HasCheckedHuntPanel(int location_id) {
-  return GetState().HasCheckedHuntPanel(location_id);
-}
-
 bool AP_HasItem(int item_id, int quantity) {
   return GetState().HasItem(item_id, quantity);
 }
 
-std::string AP_GetItemName(int item_id) {
-  return GetState().GetItemName(item_id);
+bool AP_HasItemSafe(int item_id, int quantity) {
+  return GetState().HasItemSafe(item_id, quantity);
 }
 
 DoorShuffleMode AP_GetDoorShuffleMode() {
@@ -695,6 +770,8 @@ bool AP_IsPaintingChecked(const std::string& painting_id) {
   return GetState().IsPaintingChecked(painting_id);
 }
 
+void AP_RevealPaintings() { GetState().RevealPaintings(); }
+
 int AP_GetMasteryRequirement() {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -707,6 +784,12 @@ int AP_GetLevel2Requirement() {
   return GetState().level_2_requirement;
 }
 
+LocationChecks AP_GetLocationsChecks() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().location_checks;
+}
+
 bool AP_IsLocationVisible(int classification) {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -734,14 +817,16 @@ bool AP_IsLocationVisible(int classification) {
   return (world_state & classification);
 }
 
-VictoryCondition AP_GetVictoryCondition() {
+PanelShuffleMode AP_GetPanelShuffleMode() {
   std::lock_guard state_guard(GetState().state_mutex);
 
-  return GetState().victory_condition;
+  return GetState().panel_shuffle_mode;
 }
 
-bool AP_HasAchievement(const std::string& achievement_name) {
-  return GetState().HasAchievement(achievement_name);
+VictoryCondition AP_GetVictoryCondition() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().victory_condition;
 }
 
 bool AP_HasEarlyColorHallways() {
@@ -784,6 +869,8 @@ std::map<int, SunwarpMapping> AP_GetSunwarpMapping() {
   return GetState().sunwarp_mapping;
 }
 
+bool AP_IsPostgameShuffle() { return GetState().postgame_shuffle; }
+
 bool AP_HasReachedGoal() { return GetState().HasReachedGoal(); }
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
@@ -791,3 +878,7 @@ std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
 
   return GetState().player_pos;
 }
+
+bool AP_IsPanelSolved(int solve_index) {
+  return GetState().IsPanelSolved(solve_index);
+}