1 files changed, 310 insertions, 95 deletions

@@ -12,9 +12,142 @@
 
 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
+
+  void Merge(const Requirements& rhs) {
+    if (rhs.disabled) {
+      return;
+    }
+
+    for (int id : rhs.doors) {
+      doors.insert(id);
+    }
+    for (int id : rhs.items) {
+      items.insert(id);
+    }
+    for (int id : rhs.rooms) {
+      rooms.insert(id);
+    }
+    mastery = mastery || rhs.mastery;
+    panel_hunt = panel_hunt || rhs.panel_hunt;
+  }
+};
+
+class RequirementCalculator {
+ public:
+  void Reset() {
+    doors_.clear();
+    panels_.clear();
+  }
+
+  const Requirements& GetDoor(int door_id) {
+    if (!doors_.count(door_id)) {
+      Requirements requirements;
+      const Door& door_obj = GD_GetDoor(door_id);
+
+      if (door_obj.type == DoorType::kSunPainting) {
+        if (!AP_IsPilgrimageEnabled()) {
+          requirements.items.insert(door_obj.ap_item_id);
+        } else {
+          requirements.disabled = true;
+        }
+      } else if (door_obj.type == DoorType::kSunwarp) {
+        switch (AP_GetSunwarpAccess()) {
+          case kSUNWARP_ACCESS_NORMAL:
+            // Do nothing.
+            break;
+          case kSUNWARP_ACCESS_DISABLED:
+            requirements.disabled = true;
+            break;
+          case kSUNWARP_ACCESS_UNLOCK:
+            requirements.items.insert(door_obj.group_ap_item_id);
+            break;
+          case kSUNWARP_ACCESS_INDIVIDUAL:
+          case kSUNWARP_ACCESS_PROGRESSIVE:
+            requirements.doors.insert(door_obj.id);
+            break;
+        }
+      } else if (AP_GetDoorShuffleMode() == kNO_DOORS || 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()) {
+        requirements.items.insert(door_obj.group_ap_item_id);
+      } else {
+        requirements.doors.insert(door_obj.id);
+      }
+
+      doors_[door_id] = requirements;
+    }
+
+    return doors_[door_id];
+  }
+
+  const Requirements& GetPanel(int panel_id) {
+    if (!panels_.count(panel_id)) {
+      Requirements requirements;
+      const Panel& panel_obj = GD_GetPanel(panel_id);
+
+      requirements.rooms.insert(panel_obj.room);
+
+      if (panel_obj.name == "THE MASTER") {
+        requirements.mastery = true;
+      }
+
+      if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
+          AP_GetLevel2Requirement() > 1) {
+        requirements.panel_hunt = true;
+      }
+
+      for (int room_id : panel_obj.required_rooms) {
+        requirements.rooms.insert(room_id);
+      }
+
+      for (int door_id : panel_obj.required_doors) {
+        const Requirements& door_reqs = GetDoor(door_id);
+        requirements.Merge(door_reqs);
+      }
+
+      for (int panel_id : panel_obj.required_panels) {
+        const Requirements& panel_reqs = GetPanel(panel_id);
+        requirements.Merge(panel_reqs);
+      }
+
+      if (AP_IsColorShuffle()) {
+        for (LingoColor color : panel_obj.colors) {
+          requirements.items.insert(GD_GetItemIdForColor(color));
+        }
+      }
+
+      panels_[panel_id] = requirements;
+    }
+
+    return panels_[panel_id];
+  }
+
+ private:
+  std::map<int, Requirements> doors_;
+  std::map<int, Requirements> panels_;
+};
+
 struct TrackerState {
   std::map<int, bool> reachability;
+  std::set<int> reachable_doors;
+  std::set<int> reachable_paintings;
   std::mutex reachability_mutex;
+  RequirementCalculator requirements;
+  std::map<int, std::map<std::string, bool>> door_reports;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -41,6 +174,7 @@ class StateCalculator {
 
   void Calculate() {
     std::list<int> panel_boundary;
+    std::list<int> painting_boundary;
     std::list<Exit> flood_boundary;
     flood_boundary.push_back({.destination_room = options_.start});
 
@@ -48,6 +182,8 @@ class StateCalculator {
     while (reachable_changed) {
       reachable_changed = false;
 
+      std::list<Exit> new_boundary;
+
       std::list<int> new_panel_boundary;
       for (int panel_id : panel_boundary) {
         if (solveable_panels_.count(panel_id)) {
@@ -63,7 +199,33 @@ class StateCalculator {
         }
       }
 
-      std::list<Exit> new_boundary;
+      std::list<int> new_painting_boundary;
+      for (int painting_id : painting_boundary) {
+        if (reachable_paintings_.count(painting_id)) {
+          continue;
+        }
+
+        Decision painting_reachable = IsPaintingReachable(painting_id);
+        if (painting_reachable == kYes) {
+          reachable_paintings_.insert(painting_id);
+          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)) {
+            Exit painting_exit;
+            PaintingExit target_painting =
+                GD_GetPaintingExit(GD_GetPaintingByName(
+                    AP_GetPaintingMapping().at(cur_painting.internal_id)));
+            painting_exit.destination_room = target_painting.room;
+
+            new_boundary.push_back(painting_exit);
+          }
+        } else if (painting_reachable == kMaybe) {
+          new_painting_boundary.push_back(painting_id);
+        }
+      }
+
       for (const Exit& room_exit : flood_boundary) {
         if (reachable_rooms_.count(room_exit.destination_room)) {
           continue;
@@ -98,15 +260,8 @@ class StateCalculator {
           }
 
           if (AP_IsPaintingShuffle()) {
-            for (const PaintingExit& out_edge : room_obj.paintings) {
-              if (AP_GetPaintingMapping().count(out_edge.id)) {
-                Exit painting_exit;
-                painting_exit.destination_room = GD_GetRoomForPainting(
-                    AP_GetPaintingMapping().at(out_edge.id));
-                painting_exit.door = out_edge.door;
-
-                new_boundary.push_back(painting_exit);
-              }
+            for (int out_edge : room_obj.paintings) {
+              new_painting_boundary.push_back(out_edge);
             }
           }
 
@@ -155,6 +310,13 @@ class StateCalculator {
 
       flood_boundary = new_boundary;
       panel_boundary = new_panel_boundary;
+      painting_boundary = new_painting_boundary;
+    }
+
+    // Now that we know the full reachable area, let's make sure all doors are
+    // evaluated.
+    for (const Door& door : GD_GetDoors()) {
+      int discard = IsDoorReachable(door.id);
     }
   }
 
@@ -166,6 +328,14 @@ class StateCalculator {
 
   const std::set<int>& GetSolveablePanels() const { return solveable_panels_; }
 
+  const std::set<int>& GetReachablePaintings() const {
+    return reachable_paintings_;
+  }
+
+  const std::map<int, std::map<std::string, bool>>& GetDoorReports() const {
+    return door_report_;
+  }
+
  private:
   Decision IsNonGroupedDoorReachable(const Door& door_obj) {
     bool has_item = AP_HasItem(door_obj.ap_item_id);
@@ -182,68 +352,52 @@ class StateCalculator {
     return has_item ? kYes : kNo;
   }
 
-  Decision IsDoorReachable_Helper(int door_id) {
-    const Door& door_obj = GD_GetDoor(door_id);
-
-    if (!AP_IsPilgrimageEnabled() && door_obj.type == DoorType::kSunPainting) {
-      return AP_HasItem(door_obj.ap_item_id) ? kYes : kNo;
-    } else if (door_obj.type == DoorType::kSunwarp) {
-      switch (AP_GetSunwarpAccess()) {
-        case kSUNWARP_ACCESS_NORMAL:
-          return kYes;
-        case kSUNWARP_ACCESS_DISABLED:
-          return kNo;
-        case kSUNWARP_ACCESS_UNLOCK:
-          return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
-        case kSUNWARP_ACCESS_INDIVIDUAL:
-        case kSUNWARP_ACCESS_PROGRESSIVE:
-          return IsNonGroupedDoorReachable(door_obj);
-      }
-    } else if (AP_GetDoorShuffleMode() != kDOORS_MODE || door_obj.skip_item) {
-      if (!reachable_rooms_.count(door_obj.room)) {
-        return kMaybe;
-      }
-
-      for (int panel_id : door_obj.panels) {
-        if (!solveable_panels_.count(panel_id)) {
-          return kMaybe;
-        }
-      }
-
-      return kYes;
-    } 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 {
-      return IsNonGroupedDoorReachable(door_obj);
+  Decision AreRequirementsSatisfied(
+      const Requirements& reqs, std::map<std::string, bool>* report = nullptr) {
+    if (reqs.disabled) {
+      return kNo;
     }
-  }
 
-  Decision IsDoorReachable(int door_id) {
-    if (options_.parent) {
-      return options_.parent->IsDoorReachable(door_id);
-    }
+    Decision final_decision = kYes;
 
-    if (door_decisions_.count(door_id)) {
-      return door_decisions_.at(door_id);
+    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 (decision != kYes) {
+        final_decision = decision;
+      }
     }
 
-    Decision result = IsDoorReachable_Helper(door_id);
-    if (result != kMaybe) {
-      door_decisions_[door_id] = result;
+    for (int item_id : reqs.items) {
+      bool has_item = AP_HasItem(item_id);
+      if (report) {
+        (*report)[AP_GetItemName(item_id)] = has_item;
+      }
+
+      if (!has_item) {
+        final_decision = kNo;
+      }
     }
 
-    return result;
-  }
+    for (int room_id : reqs.rooms) {
+      bool reachable = reachable_rooms_.count(room_id);
 
-  Decision IsPanelReachable(int panel_id) {
-    const Panel& panel_obj = GD_GetPanel(panel_id);
+      if (report) {
+        std::string report_name = "Reach \"" + GD_GetRoom(room_id).name + "\"";
+        (*report)[report_name] = reachable;
+      }
 
-    if (!reachable_rooms_.count(panel_obj.room)) {
-      return kMaybe;
+      if (!reachable && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    if (panel_obj.name == "THE MASTER") {
+    if (reqs.mastery) {
       int achievements_accessible = 0;
 
       for (int achieve_id : GD_GetAchievementPanels()) {
@@ -256,12 +410,18 @@ class StateCalculator {
         }
       }
 
-      return (achievements_accessible >= AP_GetMasteryRequirement()) ? kYes
-                                                                     : kMaybe;
+      bool can_mastery =
+          (achievements_accessible >= AP_GetMasteryRequirement());
+      if (report) {
+        (*report)["Mastery"] = can_mastery;
+      }
+
+      if (!can_mastery && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
-        AP_GetLevel2Requirement() > 1) {
+    if (reqs.panel_hunt) {
       int counting_panels_accessible = 0;
 
       for (int solved_panel_id : solveable_panels_) {
@@ -272,41 +432,58 @@ class StateCalculator {
         }
       }
 
-      return (counting_panels_accessible >= AP_GetLevel2Requirement() - 1)
-                 ? kYes
-                 : kMaybe;
-    }
+      bool can_level2 =
+          (counting_panels_accessible >= AP_GetLevel2Requirement() - 1);
+      if (report) {
+        std::string report_name =
+            std::to_string(AP_GetLevel2Requirement()) + " Panels";
+        (*report)[report_name] = can_level2;
+      }
 
-    for (int room_id : panel_obj.required_rooms) {
-      if (!reachable_rooms_.count(room_id)) {
-        return kMaybe;
+      if (!can_level2 && final_decision != kNo) {
+        final_decision = kMaybe;
       }
     }
 
-    for (int door_id : panel_obj.required_doors) {
-      Decision door_reachable = IsDoorReachable(door_id);
-      if (door_reachable == kNo) {
-        const Door& door_obj = GD_GetDoor(door_id);
-        return (door_obj.is_event || AP_GetDoorShuffleMode() == kNO_DOORS)
-                   ? kMaybe
-                   : kNo;
-      } else if (door_reachable == kMaybe) {
-        return kMaybe;
-      }
+    return final_decision;
+  }
+
+  Decision IsDoorReachable_Helper(int door_id) {
+    if (door_report_.count(door_id)) {
+      door_report_[door_id].clear();
+    } else {
+      door_report_[door_id] = {};
     }
 
-    for (int panel_id : panel_obj.required_panels) {
-      if (!solveable_panels_.count(panel_id)) {
-        return kMaybe;
-      }
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id),
+                                    &door_report_[door_id]);
+  }
+
+  Decision IsDoorReachable(int door_id) {
+    if (options_.parent) {
+      return options_.parent->IsDoorReachable(door_id);
     }
 
-    if (AP_IsColorShuffle()) {
-      for (LingoColor color : panel_obj.colors) {
-        if (!AP_HasItem(GD_GetItemIdForColor(color))) {
-          return kNo;
-        }
-      }
+    if (door_decisions_.count(door_id)) {
+      return door_decisions_.at(door_id);
+    }
+
+    Decision result = IsDoorReachable_Helper(door_id);
+    if (result != kMaybe) {
+      door_decisions_[door_id] = result;
+    }
+
+    return result;
+  }
+
+  Decision IsPanelReachable(int panel_id) {
+    return AreRequirementsSatisfied(GetState().requirements.GetPanel(panel_id));
+  }
+
+  Decision IsPaintingReachable(int painting_id) {
+    const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+    if (painting.door) {
+      return IsDoorReachable(*painting.door);
     }
 
     if (panel_obj.panel_door != -1 && AP_GetDoorShuffleMode() == kPANELS_MODE) {
@@ -417,11 +594,20 @@ class StateCalculator {
   std::set<int> reachable_rooms_;
   std::map<int, Decision> door_decisions_;
   std::set<int> solveable_panels_;
+  std::set<int> reachable_paintings_;
+  std::map<int, std::map<std::string, bool>> door_report_;
 };
 
 }  // namespace
 
+void ResetReachabilityRequirements() {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+  GetState().requirements.Reset();
+}
+
 void RecalculateReachability() {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
   state_calculator.Calculate();
 
@@ -444,10 +630,21 @@ void RecalculateReachability() {
     }
   }
 
-  {
-    std::lock_guard reachability_guard(GetState().reachability_mutex);
-    std::swap(GetState().reachability, new_reachability);
+  std::set<int> new_reachable_doors;
+  for (const auto& [door_id, decision] : state_calculator.GetDoorDecisions()) {
+    if (decision == kYes) {
+      new_reachable_doors.insert(door_id);
+    }
   }
+
+  std::set<int> reachable_paintings = state_calculator.GetReachablePaintings();
+  std::map<int, std::map<std::string, bool>> door_reports =
+      state_calculator.GetDoorReports();
+  
+  std::swap(GetState().reachability, new_reachability);
+  std::swap(GetState().reachable_doors, new_reachable_doors);
+  std::swap(GetState().reachable_paintings, reachable_paintings);
+  std::swap(GetState().door_reports, door_reports);
 }
 
 bool IsLocationReachable(int location_id) {
@@ -459,3 +656,21 @@ bool IsLocationReachable(int location_id) {
     return false;
   }
 }
+
+bool IsDoorOpen(int door_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().reachable_doors.count(door_id);
+}
+
+bool IsPaintingReachable(int painting_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().reachable_paintings.count(painting_id);
+}
+
+const std::map<std::string, bool>& GetDoorRequirements(int door_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().door_reports.at(door_id);
+}