1 files changed, 207 insertions, 44 deletions

@@ -12,6 +12,7 @@
 
 #include "ap_state.h"
 #include "game_data.h"
+#include "global.h"
 #include "logger.h"
 
 namespace {
@@ -19,11 +20,13 @@ 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
+  bool postgame = false;
 
   void Merge(const Requirements& rhs) {
     if (rhs.disabled) {
@@ -33,6 +36,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);
     }
@@ -41,6 +47,7 @@ struct Requirements {
     }
     mastery = mastery || rhs.mastery;
     panel_hunt = panel_hunt || rhs.panel_hunt;
+    postgame = postgame || rhs.postgame;
   }
 };
 
@@ -78,15 +85,12 @@ class RequirementCalculator {
             requirements.doors.insert(door_obj.id);
             break;
         }
-      } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
-        requirements.rooms.insert(door_obj.room);
-
+      } else if (AP_GetDoorShuffleMode() != kDOORS_MODE || door_obj.skip_item) {
         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);
@@ -133,6 +137,21 @@ 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);
+        }
+      }
+
+      if (panel_obj.location_name == GetWinCondition()) {
+        requirements.postgame = true;
+      }
 
       panels_[panel_id] = requirements;
     }
@@ -148,11 +167,17 @@ class RequirementCalculator {
 struct TrackerState {
   std::map<int, bool> reachability;
   std::set<int> reachable_doors;
+  std::set<int> solveable_panels;
   std::set<int> reachable_paintings;
   std::mutex reachability_mutex;
   RequirementCalculator requirements;
   std::map<int, std::map<std::string, bool>> door_reports;
   bool pilgrimage_doable = false;
+
+  // If these are empty, it actually means everything is non-postgame.
+  std::set<int> non_postgame_areas;
+  std::set<int> non_postgame_locations;
+  std::set<int> non_postgame_paintings;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -167,6 +192,11 @@ class StateCalculator;
 struct StateCalculatorOptions {
   int start;
   bool pilgrimage = false;
+
+  // Treats all items as collected and all paintings as checked, but postgame
+  // areas cannot be reached.
+  bool postgame_detection = false;
+
   StateCalculator* parent = nullptr;
 };
 
@@ -177,7 +207,21 @@ class StateCalculator {
   explicit StateCalculator(StateCalculatorOptions options)
       : options_(options) {}
 
+  void PreloadPanels(const std::set<int>& panels) {
+    solveable_panels_ = panels;
+  }
+
+  void PreloadDoors(const std::set<int>& doors) {
+    for (int door_id : doors) {
+      door_decisions_[door_id] = kYes;
+    }
+  }
+
   void Calculate() {
+    painting_mapping_ = AP_GetPaintingMapping();
+    checked_paintings_ = AP_GetCheckedPaintings();
+    sunwarp_mapping_ = AP_GetSunwarpMapping();
+
     std::list<int> panel_boundary;
     std::list<int> painting_boundary;
     std::list<Exit> flood_boundary;
@@ -217,12 +261,13 @@ class StateCalculator {
           reachable_changed = true;
 
           PaintingExit cur_painting = GD_GetPaintingExit(painting_id);
-          if (AP_GetPaintingMapping().count(cur_painting.internal_id) &&
-              AP_GetCheckedPaintings().count(cur_painting.internal_id)) {
+          if (painting_mapping_.count(cur_painting.internal_id) &&
+              (checked_paintings_.count(cur_painting.internal_id) ||
+               options_.postgame_detection)) {
             Exit painting_exit;
             PaintingExit target_painting =
                 GD_GetPaintingExit(GD_GetPaintingByName(
-                    AP_GetPaintingMapping().at(cur_painting.internal_id)));
+                    painting_mapping_.at(cur_painting.internal_id)));
             painting_exit.source_room = cur_painting.room;
             painting_exit.destination_room = target_painting.room;
             painting_exit.type = EntranceType::kPainting;
@@ -281,8 +326,8 @@ class StateCalculator {
 
           if (AP_IsSunwarpShuffle()) {
             for (int index : room_obj.sunwarps) {
-              if (AP_GetSunwarpMapping().count(index)) {
-                const SunwarpMapping& sm = AP_GetSunwarpMapping().at(index);
+              if (sunwarp_mapping_.count(index)) {
+                const SunwarpMapping& sm = sunwarp_mapping_.at(index);
 
                 new_boundary.push_back(
                     {.source_room = room_exit.destination_room,
@@ -296,15 +341,14 @@ class StateCalculator {
           if (AP_HasEarlyColorHallways() && room_obj.name == "Starting Room") {
             new_boundary.push_back(
                 {.source_room = room_exit.destination_room,
-                 .destination_room = GD_GetRoomByName("Outside The Undeterred"),
+                 .destination_room = GD_GetRoomByName("Color Hallways"),
                  .type = EntranceType::kPainting});
           }
 
           if (AP_IsPilgrimageEnabled()) {
             int pilgrimage_start_id = GD_GetRoomByName("Hub Room");
             if (AP_IsSunwarpShuffle()) {
-              for (const auto& [start_index, mapping] :
-                   AP_GetSunwarpMapping()) {
+              for (const auto& [start_index, mapping] : sunwarp_mapping_) {
                 if (mapping.dots == 1) {
                   pilgrimage_start_id = GD_GetRoomForSunwarp(start_index);
                 }
@@ -343,6 +387,10 @@ class StateCalculator {
     // evaluated.
     for (const Door& door : GD_GetDoors()) {
       int discard = IsDoorReachable(door.id);
+
+      door_report_[door.id] = {};
+      discard = AreRequirementsSatisfied(
+          GetState().requirements.GetDoor(door.id), &door_report_[door.id]);
     }
   }
 
@@ -378,7 +426,8 @@ class StateCalculator {
   }
 
  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) {
@@ -399,29 +448,48 @@ class StateCalculator {
       return kNo;
     }
 
+    if (reqs.postgame && options_.postgame_detection) {
+      return kNo;
+    }
+
     Decision final_decision = kYes;
 
-    for (int door_id : reqs.doors) {
-      const Door& door_obj = GD_GetDoor(door_id);
-      Decision decision = IsNonGroupedDoorReachable(door_obj);
+    if (!options_.postgame_detection) {
+      for (int door_id : reqs.doors) {
+        const Door& door_obj = GD_GetDoor(door_id);
+        Decision decision = IsNonGroupedDoorReachable(door_obj);
 
-      if (report) {
-        (*report)[door_obj.item_name] = (decision == kYes);
-      }
+        if (report) {
+          (*report)[door_obj.item_name] = (decision == kYes);
+        }
 
-      if (decision != kYes) {
-        final_decision = decision;
+        if (decision != kYes) {
+          final_decision = decision;
+        }
       }
-    }
 
-    for (int item_id : reqs.items) {
-      bool has_item = AP_HasItem(item_id);
-      if (report) {
-        (*report)[AP_GetItemName(item_id)] = has_item;
+      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)[panel_door_obj.item_name] = (decision == kYes);
+        }
+
+        if (decision != kYes) {
+          final_decision = decision;
+        }
       }
 
-      if (!has_item) {
-        final_decision = kNo;
+      for (int item_id : reqs.items) {
+        bool has_item = AP_HasItem(item_id);
+        if (report) {
+          (*report)[GD_GetItemName(item_id)] = has_item;
+        }
+
+        if (!has_item) {
+          final_decision = kNo;
+        }
       }
     }
 
@@ -490,14 +558,7 @@ class StateCalculator {
   }
 
   Decision IsDoorReachable_Helper(int door_id) {
-    if (door_report_.count(door_id)) {
-      door_report_[door_id].clear();
-    } else {
-      door_report_[door_id] = {};
-    }
-
-    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id),
-                                    &door_report_[door_id]);
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id));
   }
 
   Decision IsDoorReachable(int door_id) {
@@ -549,7 +610,7 @@ class StateCalculator {
       if (AP_IsSunwarpShuffle()) {
         pilgrimage_pairs = std::vector<std::tuple<int, int>>(5);
 
-        for (const auto& [start_index, mapping] : AP_GetSunwarpMapping()) {
+        for (const auto& [start_index, mapping] : sunwarp_mapping_) {
           if (mapping.dots > 1) {
             std::get<1>(pilgrimage_pairs[mapping.dots - 2]) = start_index;
           }
@@ -620,23 +681,94 @@ class StateCalculator {
   bool pilgrimage_doable_ = false;
 
   std::map<int, std::list<int>> paths_;
+
+  std::map<std::string, std::string> painting_mapping_;
+  std::set<std::string> checked_paintings_;
+  std::map<int, SunwarpMapping> sunwarp_mapping_;
 };
 
 }  // namespace
 
 void ResetReachabilityRequirements() {
+  TrackerLog("Resetting tracker state...");
+
   std::lock_guard reachability_guard(GetState().reachability_mutex);
   GetState().requirements.Reset();
+  GetState().reachable_doors.clear();
+  GetState().solveable_panels.clear();
+
+  if (AP_IsPostgameShuffle()) {
+    GetState().non_postgame_areas.clear();
+    GetState().non_postgame_locations.clear();
+    GetState().non_postgame_paintings.clear();
+  } else {
+    StateCalculator postgame_calculator(
+        {.start = GD_GetRoomByName("Menu"), .postgame_detection = true});
+    postgame_calculator.Calculate();
+
+    std::set<int>& non_postgame_areas = GetState().non_postgame_areas;
+    non_postgame_areas.clear();
+
+    std::set<int>& non_postgame_locations = GetState().non_postgame_locations;
+    non_postgame_locations.clear();
+
+    const std::set<int>& reachable_rooms =
+        postgame_calculator.GetReachableRooms();
+    const std::set<int>& solveable_panels =
+        postgame_calculator.GetSolveablePanels();
+
+    for (const MapArea& map_area : GD_GetMapAreas()) {
+      bool area_reachable = false;
+
+      for (const Location& location_section : map_area.locations) {
+        bool reachable = reachable_rooms.count(location_section.room);
+        if (reachable) {
+          for (int panel_id : location_section.panels) {
+            reachable &= (solveable_panels.count(panel_id) == 1);
+          }
+        }
+
+        if (!reachable && IsLocationWinCondition(location_section)) {
+          reachable = true;
+        }
+
+        if (reachable) {
+          non_postgame_locations.insert(location_section.ap_location_id);
+          area_reachable = true;
+        }
+      }
+
+      for (int painting_id : map_area.paintings) {
+        if (postgame_calculator.GetReachablePaintings().count(painting_id)) {
+          area_reachable = true;
+        }
+      }
+
+      if (area_reachable) {
+        non_postgame_areas.insert(map_area.id);
+      }
+    }
+
+    GetState().non_postgame_paintings =
+        postgame_calculator.GetReachablePaintings();
+  }
 }
 
 void RecalculateReachability() {
+  TrackerLog("Calculating reachability...");
+
   std::lock_guard reachability_guard(GetState().reachability_mutex);
 
+  // Receiving items and checking paintings should never remove access to doors
+  // or panels, so we can preload any doors and panels we already know are
+  // accessible from previous runs, in order to reduce the work.
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
+  state_calculator.PreloadDoors(GetState().reachable_doors);
+  state_calculator.PreloadPanels(GetState().solveable_panels);
   state_calculator.Calculate();
 
   const std::set<int>& reachable_rooms = state_calculator.GetReachableRooms();
-  const std::set<int>& solveable_panels = state_calculator.GetSolveablePanels();
+  std::set<int> solveable_panels = state_calculator.GetSolveablePanels();
 
   std::map<int, bool> new_reachability;
   for (const MapArea& map_area : GD_GetMapAreas()) {
@@ -667,6 +799,7 @@ void RecalculateReachability() {
   
   std::swap(GetState().reachability, new_reachability);
   std::swap(GetState().reachable_doors, new_reachable_doors);
+  std::swap(GetState().solveable_panels, solveable_panels);
   std::swap(GetState().reachable_paintings, reachable_paintings);
   std::swap(GetState().door_reports, door_reports);
   GetState().pilgrimage_doable = state_calculator.IsPilgrimageDoable();
@@ -705,3 +838,33 @@ bool IsPilgrimageDoable() {
 
   return GetState().pilgrimage_doable;
 }
+
+bool IsAreaPostgame(int area_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_areas.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_areas.count(area_id);
+  }
+}
+
+bool IsLocationPostgame(int location_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_locations.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_locations.count(location_id);
+  }
+}
+
+bool IsPaintingPostgame(int painting_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_paintings.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_paintings.count(painting_id);
+  }
+}