Support panels mode door shuffle

7 files changed, 166 insertions, 21 deletions

@@ -57,6 +57,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;
@@ -128,6 +129,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();
@@ -212,6 +214,17 @@ struct APState {
       data_storage_prefix =
           "Lingo_" + std::to_string(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>();
@@ -346,7 +359,7 @@ struct APState {
       } else {
         data_storage.erase(key);
       }
-      
+
       TrackerLog("Data storage " + key + " retrieved as null");
     }
   }
@@ -426,6 +439,8 @@ bool AP_HasItem(int item_id, int quantity) {
 
 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; }
@@ -10,7 +10,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, kTHE_MASTER = 1, kLEVEL_2 = 2 };
 
@@ -28,6 +28,8 @@ bool AP_HasItem(int item_id, int quantity = 1);
 
 DoorShuffleMode AP_GetDoorShuffleMode();
 
+bool AP_AreDoorsGrouped();
+
 bool AP_IsColorShuffle();
 
 bool AP_IsPaintingShuffle();
@@ -43,11 +43,13 @@ 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::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::vector<int> door_definition_order_;
@@ -408,6 +410,59 @@ 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 {
+            std::ostringstream errmsg;
+            errmsg << "Missing AP item ID for panel door "
+                   << rooms_[room_id].name << " - " << panel_door_name;
+            TrackerLog(errmsg.str());
+          }
+
+          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 {
+              std::ostringstream errmsg;
+              errmsg << "Missing AP item ID for panel door group "
+                     << panel_group;
+              TrackerLog(errmsg.str());
+            }
+          }
+        }
+      }
+
       if (room_it.second["paintings"]) {
         for (const auto &painting : room_it.second["paintings"]) {
           std::string painting_id = painting["id"].as<std::string>();
@@ -449,23 +504,47 @@ struct GameData {
             TrackerLog(errmsg.str());
           }
 
-          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++;
             }
+          }
+
+          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>());
+              }
 
-            doors_[door_id].progressives.push_back(
-                {.item_name = progressive_item_name,
-                 .ap_item_id = progressive_item_id,
-                 .quantity = index});
-            index++;
+              panel_doors_[panel_door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
+            }
           }
         }
       }
@@ -643,6 +722,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_) {
@@ -679,6 +770,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);
+}
+
 const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
@@ -38,6 +38,7 @@ struct Panel {
   bool non_counting = false;
   int ap_location_id = -1;
   bool hunt = false;
+  int panel_door = -1;
 };
 
 struct ProgressiveRequirement {
@@ -63,6 +64,12 @@ struct Door {
   int ap_location_id = -1;
 };
 
+struct PanelDoor {
+  int ap_item_id = -1;
+  int group_ap_item_id = -1;
+  std::vector<ProgressiveRequirement> progressives;
+};
+
 struct Exit {
   int destination_room;
   std::optional<int> door;
@@ -108,6 +115,7 @@ const Room& GD_GetRoom(int room_id);
 const std::vector<Door>& GD_GetDoors();
 const Door& GD_GetDoor(int door_id);
 const Panel& GD_GetPanel(int panel_id);
+const PanelDoor& GD_GetPanelDoor(int panel_door_id);
 int GD_GetRoomForPainting(const std::string& painting_id);
 const std::vector<int>& GD_GetAchievementPanels();
 int GD_GetItemIdForColor(LingoColor color);
@@ -29,7 +29,7 @@ Decision IsDoorReachable_Helper(int door_id,
                                 const std::set<int>& solveable_panels) {
   const Door& door_obj = GD_GetDoor(door_id);
 
-  if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
+  if (AP_GetDoorShuffleMode() != kDOORS_MODE || door_obj.skip_item) {
     if (!reachable_rooms.count(door_obj.room)) {
       return kMaybe;
     }
@@ -41,7 +41,7 @@ Decision IsDoorReachable_Helper(int door_id,
     }
 
     return kYes;
-  } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
+  } else if (AP_GetDoorShuffleMode() == kDOORS_MODE && AP_AreDoorsGrouped() &&
              !door_obj.group_name.empty()) {
     return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
   } else {
@@ -136,6 +136,28 @@ Decision IsPanelReachable_Helper(int panel_id,
     }
   }
 
+  if (panel_obj.panel_door != -1 && AP_GetDoorShuffleMode() == kPANELS_MODE) {
+    const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_obj.panel_door);
+
+    if (AP_AreDoorsGrouped() && panel_door_obj.group_ap_item_id != -1) {
+      return AP_HasItem(panel_door_obj.group_ap_item_id) ? kYes : kNo;
+    } else {
+      bool has_item = AP_HasItem(panel_door_obj.ap_item_id);
+
+      if (!has_item) {
+        for (const ProgressiveRequirement& prog_req :
+             panel_door_obj.progressives) {
+          if (AP_HasItem(prog_req.ap_item_id, prog_req.quantity)) {
+            has_item = true;
+            break;
+          }
+        }
+      }
+
+      return has_item ? kYes : kNo;
+    }
+  }
+
   return kYes;
 }
 
@@ -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;
+}
@@ -31,9 +31,7 @@ struct Version {
   }
 };
 
-std::ostream& operator<<(std::ostream& out, const Version& ver) {
-  return out << "v" << ver.major << "." << ver.minor << "." << ver.revision;
-}
+std::ostream& operator<<(std::ostream& out, const Version& ver);
 
 constexpr const Version kTrackerVersion = Version(0, 8, 0);