From 67a2efe7be6f4872adca8d944ebf403046472a98 Mon Sep 17 00:00:00 2001
From: Star Rauchenberger <fefferburbia@gmail.com>
Date: Thu, 6 Jun 2024 13:53:20 -0400
Subject: Proper painting reachability detection

---
 src/tracker_state.cpp | 67 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 56 insertions(+), 11 deletions(-)

(limited to 'src/tracker_state.cpp')

diff --git a/src/tracker_state.cpp b/src/tracker_state.cpp
index 187a4a8..46bdbec 100644
--- a/src/tracker_state.cpp
+++ b/src/tracker_state.cpp
@@ -141,6 +141,7 @@ class RequirementCalculator {
 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;
@@ -170,6 +171,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});
 
@@ -177,6 +179,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)) {
@@ -192,7 +196,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;
@@ -227,16 +257,8 @@ class StateCalculator {
           }
 
           if (AP_IsPaintingShuffle()) {
-            for (const PaintingExit& out_edge : room_obj.paintings) {
-              if (AP_GetPaintingMapping().count(out_edge.id) &&
-                  AP_GetCheckedPaintings().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);
             }
           }
 
@@ -285,6 +307,7 @@ 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
@@ -302,6 +325,10 @@ 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_;
   }
@@ -450,6 +477,15 @@ class StateCalculator {
     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);
+    }
+
+    return kYes;
+  }
+
   Decision IsExitUsable(const Exit& room_exit) {
     if (room_exit.type == EntranceType::kPilgrimage) {
       if (options_.pilgrimage || !AP_IsPilgrimageEnabled()) {
@@ -533,6 +569,7 @@ 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_;
 };
 
@@ -573,6 +610,7 @@ void RecalculateReachability() {
     }
   }
 
+  std::set<int> reachable_paintings = state_calculator.GetReachablePaintings();
   std::map<int, std::map<std::string, bool>> door_reports =
       state_calculator.GetDoorReports();
 
@@ -580,6 +618,7 @@ void RecalculateReachability() {
     std::lock_guard reachability_guard(GetState().reachability_mutex);
     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);
   }
 }
@@ -600,6 +639,12 @@ bool IsDoorOpen(int door_id) {
   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);
 
-- 
cgit 1.4.1