10 files changed, 271 insertions, 36 deletions

@@ -1,5 +1,19 @@
 # lingo-ap-tracker Releases
 
+## v0.10.6 - 2024-07-16
+
+- The status bar now shows the name and server for the connected slot.
+- Fixed an issue with pilgrimage detection when paintings are shuffled and
+  paintings are not allowed for pilgrimage.
+- Fixed an issue with pilgrimage starting from the wrong place when sunwarps are
+  shuffled.
+- Fixed incorrect doors showing for sunwarps on subway map when sunwarps are
+  shuffled.
+
+Download:
+[lingo-ap-tracker-v0.10.6-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.10.6-win64.zip)<br/>
+Source: [v0.10.6](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.10.6)
+
 ## v0.10.5 - 2024-07-12
 
 - Increased length of connection history to 10.
@@ -1 +1 @@
-v0.10.5
\ No newline at end of file
+v0.10.6
\ No newline at end of file
@@ -58,6 +58,7 @@ struct APState {
   std::optional<std::tuple<int, int>> player_pos;
 
   DoorShuffleMode door_shuffle_mode = kNO_DOORS;
+  bool group_doors = false;
   bool color_shuffle = false;
   bool painting_shuffle = false;
   int mastery_requirement = 21;
@@ -137,6 +138,7 @@ struct APState {
     player_pos = std::nullopt;
     victory_data_storage_key.clear();
     door_shuffle_mode = kNO_DOORS;
+    group_doors = false;
     color_shuffle = false;
     painting_shuffle = false;
     painting_mapping.clear();
@@ -221,14 +223,27 @@ 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!");
+      tracker_frame->SetStatusMessage(
+          fmt::format("Connected to Archipelago! ({}@{})", player, server));
       TrackerLog("Connected to Archipelago!");
 
       data_storage_prefix =
           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") &&
+                      slot_data["group_doors"].get<int>() == 1;
+      } else {
+        // If group_doors doesn't exist yet, that means kPANELS_MODE is actually
+        // kSIMPLE_DOORS.
+        if (door_shuffle_mode == kPANELS_MODE) {
+          door_shuffle_mode = kDOORS_MODE;
+          group_doors = true;
+        }
+      }
       color_shuffle = slot_data["shuffle_colors"].get<int>() == 1;
       painting_shuffle = slot_data["shuffle_paintings"].get<int>() == 1;
       mastery_requirement = slot_data["mastery_achievements"].get<int>();
@@ -525,6 +540,8 @@ std::string AP_GetItemName(int item_id) {
 
 DoorShuffleMode AP_GetDoorShuffleMode() { return GetState().door_shuffle_mode; }
 
+bool AP_AreDoorsGrouped() { return GetState().group_doors; }
+
 bool AP_IsColorShuffle() { return GetState().color_shuffle; }
 
 bool AP_IsPaintingShuffle() { return GetState().painting_shuffle; }
@@ -11,7 +11,7 @@
 
 class TrackerFrame;
 
-enum DoorShuffleMode { kNO_DOORS = 0, kSIMPLE_DOORS = 1, kCOMPLEX_DOORS = 2 };
+enum DoorShuffleMode { kNO_DOORS = 0, kPANELS_MODE = 1, kDOORS_MODE = 2 };
 
 enum VictoryCondition {
   kTHE_END = 0,
@@ -53,6 +53,8 @@ std::string AP_GetItemName(int item_id);
 
 DoorShuffleMode AP_GetDoorShuffleMode();
 
+bool AP_AreDoorsGrouped();
+
 bool AP_IsColorShuffle();
 
 bool AP_IsPaintingShuffle();
@@ -42,6 +42,7 @@ struct GameData {
   std::vector<Room> rooms_;
   std::vector<Door> doors_;
   std::vector<Panel> panels_;
+  std::vector<PanelDoor> panel_doors_;
   std::vector<MapArea> map_areas_;
   std::vector<SubwayItem> subway_items_;
   std::vector<PaintingExit> paintings_;
@@ -49,6 +50,7 @@ struct GameData {
   std::map<std::string, int> room_by_id_;
   std::map<std::string, int> door_by_id_;
   std::map<std::string, int> panel_by_id_;
+  std::map<std::string, int> panel_doors_by_id_;
   std::map<std::string, int> area_by_id_;
   std::map<std::string, int> painting_by_id_;
 
@@ -109,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"]) {
@@ -143,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: {
@@ -424,6 +427,55 @@ struct GameData {
         }
       }
 
+      if (room_it.second["panel_doors"]) {
+        for (const auto &panel_door_it : room_it.second["panel_doors"]) {
+          std::string panel_door_name = panel_door_it.first.as<std::string>();
+          int panel_door_id =
+              AddOrGetPanelDoor(rooms_[room_id].name, panel_door_name);
+
+          for (const auto &panel_node : panel_door_it.second["panels"]) {
+            int panel_id = -1;
+
+            if (panel_node.IsScalar()) {
+              panel_id = AddOrGetPanel(rooms_[room_id].name,
+                                       panel_node.as<std::string>());
+            } else {
+              panel_id = AddOrGetPanel(panel_node["room"].as<std::string>(),
+                                       panel_node["panel"].as<std::string>());
+            }
+
+            Panel &panel = panels_[panel_id];
+            panel.panel_door = panel_door_id;
+          }
+
+          if (ids_config["panel_doors"] &&
+              ids_config["panel_doors"][rooms_[room_id].name] &&
+              ids_config["panel_doors"][rooms_[room_id].name]
+                        [panel_door_name]) {
+            panel_doors_[panel_door_id].ap_item_id =
+                ids_config["panel_doors"][rooms_[room_id].name][panel_door_name]
+                    .as<int>();
+          } else {
+            wxLogError("Missing AP item ID for panel door %s - %s",
+                       rooms_[room_id].name, panel_door_name);
+          }
+
+          if (panel_door_it.second["panel_group"]) {
+            std::string panel_group =
+                panel_door_it.second["panel_group"].as<std::string>();
+
+            if (ids_config["panel_groups"] &&
+                ids_config["panel_groups"][panel_group]) {
+              panel_doors_[panel_door_id].group_ap_item_id =
+                  ids_config["panel_groups"][panel_group].as<int>();
+            } else {
+              wxLogError("Missing AP item ID for panel door group %s",
+                         panel_group);
+            }
+          }
+        }
+      }
+
       if (room_it.second["paintings"]) {
         for (const auto &painting : room_it.second["paintings"]) {
           std::string internal_id = painting["id"].as<std::string>();
@@ -477,23 +529,47 @@ struct GameData {
                                    progressive_item_name));
           }
 
-          int index = 1;
-          for (const auto &stage : progression_it.second) {
-            int door_id = -1;
+          if (progression_it.second["doors"]) {
+            int index = 1;
+            for (const auto &stage : progression_it.second["doors"]) {
+              int door_id = -1;
 
-            if (stage.IsScalar()) {
-              door_id =
-                  AddOrGetDoor(rooms_[room_id].name, stage.as<std::string>());
-            } else {
-              door_id = AddOrGetDoor(stage["room"].as<std::string>(),
-                                     stage["door"].as<std::string>());
+              if (stage.IsScalar()) {
+                door_id =
+                    AddOrGetDoor(rooms_[room_id].name, stage.as<std::string>());
+              } else {
+                door_id = AddOrGetDoor(stage["room"].as<std::string>(),
+                                       stage["door"].as<std::string>());
+              }
+
+              doors_[door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
             }
+          }
 
-            doors_[door_id].progressives.push_back(
-                {.item_name = progressive_item_name,
-                 .ap_item_id = progressive_item_id,
-                 .quantity = index});
-            index++;
+          if (progression_it.second["panel_doors"]) {
+            int index = 1;
+            for (const auto &stage : progression_it.second["panel_doors"]) {
+              int panel_door_id = -1;
+
+              if (stage.IsScalar()) {
+                panel_door_id = AddOrGetPanelDoor(rooms_[room_id].name,
+                                                  stage.as<std::string>());
+              } else {
+                panel_door_id =
+                    AddOrGetPanelDoor(stage["room"].as<std::string>(),
+                                      stage["panel_door"].as<std::string>());
+              }
+
+              panel_doors_[panel_door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
+            }
           }
         }
       }
@@ -752,6 +828,18 @@ struct GameData {
     return panel_by_id_[full_name];
   }
 
+  int AddOrGetPanelDoor(std::string room, std::string panel) {
+    std::string full_name = room + " - " + panel;
+
+    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({});
+    }
+
+    return panel_doors_by_id_[full_name];
+  }
+
   int AddOrGetArea(std::string area) {
     if (!area_by_id_.count(area)) {
       if (loaded_area_data_) {
@@ -802,6 +890,10 @@ const std::vector<Door> &GD_GetDoors() { return GetState().doors_; }
 
 const Door &GD_GetDoor(int door_id) { return GetState().doors_.at(door_id); }
 
+const PanelDoor &GD_GetPanelDoor(int panel_door_id) {
+  return GetState().panel_doors_.at(panel_door_id);
+}
+
 int GD_GetDoorByName(const std::string &name) {
   return GetState().door_by_id_.at(name);
 }
@@ -55,6 +55,7 @@ struct Panel {
   bool non_counting = false;
   int ap_location_id = -1;
   bool hunt = false;
+  int panel_door = -1;
 };
 
 struct ProgressiveRequirement {
@@ -82,7 +83,14 @@ struct Door {
   DoorType type = DoorType::kNormal;
 };
 
+struct PanelDoor {
+  int ap_item_id = -1;
+  int group_ap_item_id = -1;
+  std::vector<ProgressiveRequirement> progressives;
+};
+
 struct Exit {
+  int source_room;
   int destination_room;
   std::optional<int> door;
   EntranceType type = EntranceType::kNormal;
@@ -157,6 +165,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);
+const PanelDoor& GD_GetPanelDoor(int panel_door_id);
 const PaintingExit& GD_GetPaintingExit(int painting_id);
 int GD_GetPaintingByName(const std::string& name);
 const std::vector<int>& GD_GetAchievementPanels();
@@ -16,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);
 
@@ -267,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;
@@ -450,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_;
@@ -1,5 +1,8 @@
 #include "tracker_state.h"
 
+#include <fmt/core.h>
+#include <hkutil/string.h>
+
 #include <list>
 #include <map>
 #include <mutex>
@@ -9,17 +12,19 @@
 
 #include "ap_state.h"
 #include "game_data.h"
+#include "logger.h"
 
 namespace {
 
 struct Requirements {
   bool disabled = false;
 
-  std::set<int> doors;      // non-grouped, handles progressive
-  std::set<int> items;      // all other items
-  std::set<int> rooms;      // maybe
-  bool mastery = false;     // maybe
-  bool panel_hunt = false;  // maybe
+  std::set<int> doors;       // non-grouped, handles progressive
+  std::set<int> panel_doors; // non-grouped, handles progressive
+  std::set<int> items;       // all other items
+  std::set<int> rooms;       // maybe
+  bool mastery = false;      // maybe
+  bool panel_hunt = false;   // maybe
 
   void Merge(const Requirements& rhs) {
     if (rhs.disabled) {
@@ -29,6 +34,9 @@ struct Requirements {
     for (int id : rhs.doors) {
       doors.insert(id);
     }
+    for (int id : rhs.panel_doors) {
+      panel_doors.insert(id);
+    }
     for (int id : rhs.items) {
       items.insert(id);
     }
@@ -74,15 +82,14 @@ class RequirementCalculator {
             requirements.doors.insert(door_obj.id);
             break;
         }
-      } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
+      } else if (AP_GetDoorShuffleMode() != kDOORS_MODE || door_obj.skip_item) {
         requirements.rooms.insert(door_obj.room);
 
         for (int panel_id : door_obj.panels) {
           const Requirements& panel_reqs = GetPanel(panel_id);
           requirements.Merge(panel_reqs);
         }
-      } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
-                 !door_obj.group_name.empty()) {
+      } else if (AP_AreDoorsGrouped() && !door_obj.group_name.empty()) {
         requirements.items.insert(door_obj.group_ap_item_id);
       } else {
         requirements.doors.insert(door_obj.id);
@@ -129,6 +136,17 @@ class RequirementCalculator {
           requirements.items.insert(GD_GetItemIdForColor(color));
         }
       }
+      
+      if (panel_obj.panel_door != -1 &&
+          AP_GetDoorShuffleMode() == kPANELS_MODE) {
+        const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_obj.panel_door);
+
+        if (panel_door_obj.group_ap_item_id != -1 && AP_AreDoorsGrouped()) {
+          requirements.items.insert(panel_door_obj.group_ap_item_id);
+        } else {
+          requirements.panel_doors.insert(panel_obj.panel_door);
+        }
+      }
 
       panels_[panel_id] = requirements;
     }
@@ -217,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);
           }
@@ -244,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 &&
@@ -282,20 +308,33 @@ class StateCalculator {
 
           if (AP_HasEarlyColorHallways() && room_obj.name == "Starting Room") {
             new_boundary.push_back(
-                {.destination_room = GD_GetRoomByName("Color Hallways"),
+                {.source_room = room_exit.destination_room,
+                 .destination_room = GD_GetRoomByName("Color Hallways"),
                  .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});
@@ -336,8 +375,22 @@ 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:
-  Decision IsNonGroupedDoorReachable(const Door& door_obj) {
+  template <typename T>
+  Decision IsNonGroupedDoorReachable(const T& door_obj) {
     bool has_item = AP_HasItem(door_obj.ap_item_id);
 
     if (!has_item) {
@@ -373,6 +426,20 @@ class StateCalculator {
       }
     }
 
+    for (int panel_door_id : reqs.panel_doors) {
+      const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_door_id);
+      Decision decision = IsNonGroupedDoorReachable(panel_door_obj);
+
+      if (report) {
+        (*report)[AP_GetItemName(panel_door_obj.ap_item_id)] =
+            (decision == kYes);
+      }
+
+      if (decision != kYes) {
+        final_decision = decision;
+      }
+    }
+
     for (int item_id : reqs.items) {
       bool has_item = AP_HasItem(item_id);
       if (report) {
@@ -574,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
@@ -0,0 +1,5 @@
+#include "version.h"
+
+std::ostream& operator<<(std::ostream& out, const Version& ver) {
+  return out << "v" << ver.major << "." << ver.minor << "." << ver.revision;
+}
@@ -36,6 +36,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 10, 5);
+constexpr const Version kTrackerVersion = Version(0, 10, 6);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file