8 files changed, 504 insertions, 204 deletions

@@ -64,8 +64,14 @@ struct APState {
   LocationChecks location_checks = kNORMAL_LOCATIONS;
   VictoryCondition victory_condition = kTHE_END;
   bool early_color_hallways = false;
+  bool pilgrimage_enabled = false;
+  bool pilgrimage_allows_roof_access = false;
+  bool pilgrimage_allows_paintings = false;
+  SunwarpAccess sunwarp_access = kSUNWARP_ACCESS_NORMAL;
+  bool sunwarp_shuffle = false;
 
   std::map<std::string, std::string> painting_mapping;
+  std::map<int, SunwarpMapping> sunwarp_mapping;
 
   void Connect(std::string server, std::string player, std::string password) {
     if (!initialized) {
@@ -136,6 +142,12 @@ struct APState {
     location_checks = kNORMAL_LOCATIONS;
     victory_condition = kTHE_END;
     early_color_hallways = false;
+    pilgrimage_enabled = false;
+    pilgrimage_allows_roof_access = false;
+    pilgrimage_allows_paintings = false;
+    sunwarp_access = kSUNWARP_ACCESS_NORMAL;
+    sunwarp_shuffle = false;
+    sunwarp_mapping.clear();
 
     connected = false;
     has_connection_result = false;
@@ -221,6 +233,19 @@ struct APState {
           slot_data["victory_condition"].get<VictoryCondition>();
       early_color_hallways = slot_data.contains("early_color_hallways") &&
                              slot_data["early_color_hallways"].get<int>() == 1;
+      pilgrimage_enabled = slot_data.contains("enable_pilgrimage") &&
+                           slot_data["enable_pilgrimage"].get<int>() == 1;
+      pilgrimage_allows_roof_access =
+          slot_data.contains("pilgrimage_allows_roof_access") &&
+          slot_data["pilgrimage_allows_roof_access"].get<int>() == 1;
+      pilgrimage_allows_paintings =
+          slot_data.contains("pilgrimage_allows_paintings") &&
+          slot_data["pilgrimage_allows_paintings"].get<int>() == 1;
+      sunwarp_access = slot_data.contains("sunwarp_access")
+                           ? slot_data["sunwarp_access"].get<SunwarpAccess>()
+                           : kSUNWARP_ACCESS_NORMAL;
+      sunwarp_shuffle = slot_data.contains("shuffle_sunwarps") &&
+                        slot_data["shuffle_sunwarps"].get<int>() == 1;
 
       if (painting_shuffle && slot_data.contains("painting_entrance_to_exit")) {
         painting_mapping.clear();
@@ -231,6 +256,18 @@ struct APState {
         }
       }
 
+      if (sunwarp_shuffle && slot_data.contains("sunwarp_permutation")) {
+        std::vector<int> inverted_sunwarps;
+        for (const auto& item : slot_data["sunwarp_permutation"]) {
+          inverted_sunwarps.push_back(item);
+        }
+
+        for (int i = 0; i < 6; i++) {
+          sunwarp_mapping[inverted_sunwarps[i]] = SunwarpMapping{
+              .dots = i + 1, .exit_index = inverted_sunwarps[i + 6]};
+        }
+      }
+
       connected = true;
       has_connection_result = true;
 
@@ -346,7 +383,7 @@ struct APState {
       } else {
         data_storage.erase(key);
       }
-      
+
       TrackerLog("Data storage " + key + " retrieved as null");
     }
   }
@@ -461,6 +498,24 @@ bool AP_HasAchievement(const std::string& achievement_name) {
 
 bool AP_HasEarlyColorHallways() { return GetState().early_color_hallways; }
 
+bool AP_IsPilgrimageEnabled() { return GetState().pilgrimage_enabled; }
+
+bool AP_DoesPilgrimageAllowRoofAccess() {
+  return GetState().pilgrimage_allows_roof_access;
+}
+
+bool AP_DoesPilgrimageAllowPaintings() {
+  return GetState().pilgrimage_allows_paintings;
+}
+
+SunwarpAccess AP_GetSunwarpAccess() { return GetState().sunwarp_access; }
+
+bool AP_IsSunwarpShuffle() { return GetState().sunwarp_shuffle; }
+
+const std::map<int, SunwarpMapping>& AP_GetSunwarpMapping() {
+  return GetState().sunwarp_mapping;
+}
+
 bool AP_HasReachedGoal() { return GetState().HasReachedGoal(); }
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
@@ -12,9 +12,31 @@ class TrackerFrame;
 
 enum DoorShuffleMode { kNO_DOORS = 0, kSIMPLE_DOORS = 1, kCOMPLEX_DOORS = 2 };
 
-enum VictoryCondition { kTHE_END = 0, kTHE_MASTER = 1, kLEVEL_2 = 2 };
-
-enum LocationChecks { kNORMAL_LOCATIONS = 0, kREDUCED_LOCATIONS = 1, kPANELSANITY = 2 };
+enum VictoryCondition {
+  kTHE_END = 0,
+  kTHE_MASTER = 1,
+  kLEVEL_2 = 2,
+  kPILGRIMAGE = 3
+};
+
+enum LocationChecks {
+  kNORMAL_LOCATIONS = 0,
+  kREDUCED_LOCATIONS = 1,
+  kPANELSANITY = 2
+};
+
+enum SunwarpAccess {
+  kSUNWARP_ACCESS_NORMAL = 0,
+  kSUNWARP_ACCESS_DISABLED = 1,
+  kSUNWARP_ACCESS_UNLOCK = 2,
+  kSUNWARP_ACCESS_INDIVIDUAL = 3,
+  kSUNWARP_ACCESS_PROGRESSIVE = 4
+};
+
+struct SunwarpMapping {
+  int dots;
+  int exit_index;
+};
 
 void AP_SetTrackerFrame(TrackerFrame* tracker_frame);
 
@@ -46,6 +68,18 @@ bool AP_HasAchievement(const std::string& achievement_name);
 
 bool AP_HasEarlyColorHallways();
 
+bool AP_IsPilgrimageEnabled();
+
+bool AP_DoesPilgrimageAllowRoofAccess();
+
+bool AP_DoesPilgrimageAllowPaintings();
+
+SunwarpAccess AP_GetSunwarpAccess();
+
+bool AP_IsSunwarpShuffle();
+
+const std::map<int, SunwarpMapping>& AP_GetSunwarpMapping();
+
 bool AP_HasReachedGoal();
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition();
@@ -53,11 +53,14 @@ struct GameData {
   std::vector<int> door_definition_order_;
 
   std::map<std::string, int> room_by_painting_;
+  std::map<int, int> room_by_sunwarp_;
 
   std::vector<int> achievement_panels_;
 
   std::map<LingoColor, int> ap_id_by_color_;
 
+  std::vector<int> sunwarp_doors_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -66,8 +69,6 @@ struct GameData {
         YAML::LoadFile(GetAbsolutePath("assets/LL1.yaml"));
     YAML::Node areas_config =
         YAML::LoadFile(GetAbsolutePath("assets/areas.yaml"));
-    YAML::Node pilgrimage_config =
-        YAML::LoadFile(GetAbsolutePath("assets/pilgrimage.yaml"));
     YAML::Node ids_config = YAML::LoadFile(GetAbsolutePath("assets/ids.yaml"));
 
     auto init_color_id = [this, &ids_config](const std::string &color_name) {
@@ -102,6 +103,40 @@ struct GameData {
       for (const auto &entrance_it : room_it.second["entrances"]) {
         int from_room_id = AddOrGetRoom(entrance_it.first.as<std::string>());
 
+        auto process_single_entrance =
+            [this, room_id, from_room_id](const YAML::Node &option) {
+              Exit exit_obj;
+              exit_obj.destination_room = room_id;
+
+              if (option["door"]) {
+                std::string door_room = rooms_[room_id].name;
+                if (option["room"]) {
+                  door_room = option["room"].as<std::string>();
+                }
+                exit_obj.door =
+                    AddOrGetDoor(door_room, option["door"].as<std::string>());
+              }
+
+              if (option["painting"] && option["painting"].as<bool>()) {
+                exit_obj.type = EntranceType::kPainting;
+              }
+
+              if (option["sunwarp"] && option["sunwarp"].as<bool>()) {
+                exit_obj.type = EntranceType::kSunwarp;
+              }
+
+              if (option["warp"] && option["warp"].as<bool>()) {
+                exit_obj.type = EntranceType::kWarp;
+              }
+
+              if (rooms_[from_room_id].name == "Crossroads" &&
+                  rooms_[room_id].name == "Roof") {
+                exit_obj.type = EntranceType::kCrossroadsRoofAccess;
+              }
+
+              rooms_[from_room_id].exits.push_back(exit_obj);
+            };
+
         switch (entrance_it.second.Type()) {
           case YAML::NodeType::Scalar: {
             // This is just "true".
@@ -109,42 +144,12 @@ struct GameData {
             break;
           }
           case YAML::NodeType::Map: {
-            Exit exit_obj;
-            exit_obj.destination_room = room_id;
-
-            if (entrance_it.second["door"]) {
-              std::string door_room = rooms_[room_id].name;
-              if (entrance_it.second["room"]) {
-                door_room = entrance_it.second["room"].as<std::string>();
-              }
-              exit_obj.door = AddOrGetDoor(
-                  door_room, entrance_it.second["door"].as<std::string>());
-            }
-
-            if (entrance_it.second["painting"]) {
-              exit_obj.painting = entrance_it.second["painting"].as<bool>();
-            }
-
-            rooms_[from_room_id].exits.push_back(exit_obj);
+            process_single_entrance(entrance_it.second);
             break;
           }
           case YAML::NodeType::Sequence: {
             for (const auto &option : entrance_it.second) {
-              Exit exit_obj;
-              exit_obj.destination_room = room_id;
-
-              std::string door_room = rooms_[room_id].name;
-              if (option["room"]) {
-                door_room = option["room"].as<std::string>();
-              }
-              exit_obj.door =
-                  AddOrGetDoor(door_room, option["door"].as<std::string>());
-
-              if (option["painting"]) {
-                exit_obj.painting = option["painting"].as<bool>();
-              }
-
-              rooms_[from_room_id].exits.push_back(exit_obj);
+              process_single_entrance(option);
             }
 
             break;
@@ -405,6 +410,14 @@ struct GameData {
             doors_[door_id].exclude_reduce =
                 !door_it.second["include_reduce"].as<bool>();
           }
+
+          if (doors_[door_id].name.ends_with(" Sunwarp")) {
+            sunwarp_doors_.push_back(door_id);
+            doors_[door_id].type = DoorType::kSunwarp;
+          } else if (doors_[door_id].item_name ==
+                     "Pilgrim Room - Sun Painting") {
+            doors_[door_id].type = DoorType::kSunPainting;
+          }
         }
       }
 
@@ -432,6 +445,18 @@ struct GameData {
         }
       }
 
+      if (room_it.second["sunwarps"]) {
+        for (const auto &sunwarp : room_it.second["sunwarps"]) {
+          int index = sunwarp["dots"].as<int>() - 1;
+          if (sunwarp["direction"].as<std::string>() == "exit") {
+            index += 6;
+          }
+
+          rooms_[room_id].sunwarps.push_back(index);
+          room_by_sunwarp_[index] = room_id;
+        }
+      }
+
       if (room_it.second["progression"]) {
         for (const auto &progression_it : room_it.second["progression"]) {
           std::string progressive_item_name =
@@ -575,33 +600,6 @@ struct GameData {
       }
     }
 
-    // Set up fake pilgrimage.
-    int fake_pilgrim_panel_id =
-        AddOrGetPanel("Starting Room", "!! Fake Pilgrimage Panel");
-    Panel &fake_pilgrim_panel_obj = panels_[fake_pilgrim_panel_id];
-    fake_pilgrim_panel_obj.non_counting = true;
-
-    for (const auto &config_node : pilgrimage_config) {
-      fake_pilgrim_panel_obj.required_doors.push_back(
-          AddOrGetDoor(config_node["room"].as<std::string>(),
-                       config_node["door"].as<std::string>()));
-    }
-
-    int fake_pilgrim_door_id =
-        AddOrGetDoor("Starting Room", "!! Fake Pilgrimage Door");
-    Door &fake_pilgrim_door_obj = doors_[fake_pilgrim_door_id];
-    fake_pilgrim_door_obj.panels.push_back(fake_pilgrim_panel_id);
-    fake_pilgrim_door_obj.skip_location = true;
-    fake_pilgrim_door_obj.skip_item = true;
-    fake_pilgrim_door_obj.is_event = true;
-
-    int starting_room_id = AddOrGetRoom("Starting Room");
-    Room &starting_room_obj = rooms_[starting_room_id];
-    starting_room_obj.panels.push_back(fake_pilgrim_panel_id);
-    starting_room_obj.exits.push_back(
-        Exit{.destination_room = AddOrGetRoom("Pilgrim Antechamber"),
-             .door = fake_pilgrim_door_id});
-
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
       std::ostringstream errstr;
@@ -679,6 +677,10 @@ const std::vector<Door> &GD_GetDoors() { return GetState().doors_; }
 
 const Door &GD_GetDoor(int door_id) { return GetState().doors_.at(door_id); }
 
+int GD_GetDoorByName(const std::string &name) {
+  return GetState().door_by_id_.at(name);
+}
+
 const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
@@ -694,3 +696,11 @@ const std::vector<int> &GD_GetAchievementPanels() {
 int GD_GetItemIdForColor(LingoColor color) {
   return GetState().ap_id_by_color_.at(color);
 }
+
+const std::vector<int> &GD_GetSunwarpDoors() {
+  return GetState().sunwarp_doors_;
+}
+
+int GD_GetRoomForSunwarp(int index) {
+  return GetState().room_by_sunwarp_.at(index);
+}
@@ -23,6 +23,21 @@ constexpr int kLOCATION_NORMAL = 1;
 constexpr int kLOCATION_REDUCED = 2;
 constexpr int kLOCATION_INSANITY = 4;
 
+enum class EntranceType {
+  kNormal,
+  kPainting,
+  kSunwarp,
+  kWarp,
+  kPilgrimage,
+  kCrossroadsRoofAccess,
+};
+
+enum class DoorType {
+  kNormal,
+  kSunwarp,
+  kSunPainting,
+};
+
 struct Panel {
   int id;
   int room;
@@ -61,12 +76,13 @@ struct Door {
   int ap_item_id = -1;
   int group_ap_item_id = -1;
   int ap_location_id = -1;
+  DoorType type = DoorType::kNormal;
 };
 
 struct Exit {
   int destination_room;
   std::optional<int> door;
-  bool painting = false;
+  EntranceType type = EntranceType::kNormal;
 };
 
 struct PaintingExit {
@@ -78,6 +94,7 @@ struct Room {
   std::string name;
   std::vector<Exit> exits;
   std::vector<PaintingExit> paintings;
+  std::vector<int> sunwarps;
   std::vector<int> panels;
 };
 
@@ -107,9 +124,12 @@ int GD_GetRoomByName(const std::string& name);
 const Room& GD_GetRoom(int room_id);
 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);
 int GD_GetRoomForPainting(const std::string& painting_id);
 const std::vector<int>& GD_GetAchievementPanels();
 int GD_GetItemIdForColor(LingoColor color);
+const std::vector<int>& GD_GetSunwarpDoors();
+int GD_GetRoomForSunwarp(int index);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -36,5 +36,7 @@ bool IsLocationWinCondition(const Location& location) {
              "Orange Tower Seventh Floor - THE MASTER";
     case kLEVEL_2:
       return location.ap_location_name == "Second Room - LEVEL 2";
+    case kPILGRIMAGE:
+      return location.ap_location_name == "Pilgrim Antechamber - PILGRIM";
   }
 }
@@ -25,7 +25,7 @@ class TrackerPanel : public wxPanel {
     int real_y2 = 0;
     bool active = true;
   };
- 
+
   void OnPaint(wxPaintEvent &event);
   void OnMouseMove(wxMouseEvent &event);
 
@@ -24,27 +24,150 @@ TrackerState& GetState() {
   return *instance;
 }
 
-Decision IsDoorReachable_Helper(int door_id,
-                                const std::set<int>& reachable_rooms,
-                                const std::set<int>& solveable_panels) {
-  const Door& door_obj = GD_GetDoor(door_id);
+class StateCalculator;
 
-  if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
-    if (!reachable_rooms.count(door_obj.room)) {
-      return kMaybe;
-    }
+struct StateCalculatorOptions {
+  int start;
+  bool pilgrimage = false;
+  StateCalculator* parent = nullptr;
+};
 
-    for (int panel_id : door_obj.panels) {
-      if (!solveable_panels.count(panel_id)) {
-        return kMaybe;
+class StateCalculator {
+ public:
+  StateCalculator() = default;
+
+  explicit StateCalculator(StateCalculatorOptions options)
+      : options_(options) {}
+
+  void Calculate() {
+    std::list<int> panel_boundary;
+    std::list<Exit> flood_boundary;
+    flood_boundary.push_back({.destination_room = options_.start});
+
+    bool reachable_changed = true;
+    while (reachable_changed) {
+      reachable_changed = false;
+
+      std::list<int> new_panel_boundary;
+      for (int panel_id : panel_boundary) {
+        if (solveable_panels_.count(panel_id)) {
+          continue;
+        }
+
+        Decision panel_reachable = IsPanelReachable(panel_id);
+        if (panel_reachable == kYes) {
+          solveable_panels_.insert(panel_id);
+          reachable_changed = true;
+        } else if (panel_reachable == kMaybe) {
+          new_panel_boundary.push_back(panel_id);
+        }
+      }
+
+      std::list<Exit> new_boundary;
+      for (const Exit& room_exit : flood_boundary) {
+        if (reachable_rooms_.count(room_exit.destination_room)) {
+          continue;
+        }
+
+        bool valid_transition = false;
+
+        Decision exit_usable = IsExitUsable(room_exit);
+        if (exit_usable == kYes) {
+          valid_transition = true;
+        } else if (exit_usable == kMaybe) {
+          new_boundary.push_back(room_exit);
+        }
+
+        if (valid_transition) {
+          reachable_rooms_.insert(room_exit.destination_room);
+          reachable_changed = true;
+
+          const Room& room_obj = GD_GetRoom(room_exit.destination_room);
+          for (const Exit& out_edge : room_obj.exits) {
+            if (out_edge.type == EntranceType::kPainting &&
+                AP_IsPaintingShuffle()) {
+              continue;
+            }
+
+            if (out_edge.type == EntranceType::kSunwarp &&
+                AP_IsSunwarpShuffle()) {
+              continue;
+            }
+
+            new_boundary.push_back(out_edge);
+          }
+
+          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);
+              }
+            }
+          }
+
+          if (AP_IsSunwarpShuffle()) {
+            for (int index : room_obj.sunwarps) {
+              if (AP_GetSunwarpMapping().count(index)) {
+                const SunwarpMapping& sm = AP_GetSunwarpMapping().at(index);
+
+                Exit sunwarp_exit;
+                sunwarp_exit.destination_room =
+                    GD_GetRoomForSunwarp(sm.exit_index);
+                sunwarp_exit.door = GD_GetSunwarpDoors().at(sm.dots - 1);
+
+                new_boundary.push_back(sunwarp_exit);
+              }
+            }
+          }
+
+          if (AP_HasEarlyColorHallways() && room_obj.name == "Starting Room") {
+            new_boundary.push_back(
+                {.destination_room = GD_GetRoomByName("Outside The Undeterred"),
+                 .type = EntranceType::kPainting});
+          }
+
+          if (AP_IsPilgrimageEnabled()) {
+            if (room_obj.name == "Hub Room") {
+              new_boundary.push_back(
+                  {.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"),
+                   .door =
+                       GD_GetDoorByName("Pilgrim Antechamber - Sun Painting"),
+                   .type = EntranceType::kPainting});
+            }
+          }
+
+          for (int panel_id : room_obj.panels) {
+            new_panel_boundary.push_back(panel_id);
+          }
+        }
       }
+
+      flood_boundary = new_boundary;
+      panel_boundary = new_panel_boundary;
     }
+  }
 
-    return kYes;
-  } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
-             !door_obj.group_name.empty()) {
-    return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
-  } else {
+  const std::set<int>& GetReachableRooms() const { return reachable_rooms_; }
+
+  const std::map<int, Decision>& GetDoorDecisions() const {
+    return door_decisions_;
+  }
+
+  const std::set<int>& GetSolveablePanels() const { return solveable_panels_; }
+
+ private:
+  Decision IsNonGroupedDoorReachable(const Door& door_obj) {
     bool has_item = AP_HasItem(door_obj.ap_item_id);
 
     if (!has_item) {
@@ -58,175 +181,231 @@ Decision IsDoorReachable_Helper(int door_id,
 
     return has_item ? kYes : kNo;
   }
-}
-
-Decision IsPanelReachable_Helper(int panel_id,
-                                 const std::set<int>& reachable_rooms,
-                                 const std::set<int>& solveable_panels) {
-  const Panel& panel_obj = GD_GetPanel(panel_id);
 
-  if (!reachable_rooms.count(panel_obj.room)) {
-    return kMaybe;
-  }
-
-  if (panel_obj.name == "THE MASTER") {
-    int achievements_accessible = 0;
-
-    for (int achieve_id : GD_GetAchievementPanels()) {
-      if (solveable_panels.count(achieve_id)) {
-        achievements_accessible++;
+  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() == kNO_DOORS || door_obj.skip_item) {
+      if (!reachable_rooms_.count(door_obj.room)) {
+        return kMaybe;
+      }
 
-        if (achievements_accessible >= AP_GetMasteryRequirement()) {
-          break;
+      for (int panel_id : door_obj.panels) {
+        if (!solveable_panels_.count(panel_id)) {
+          return kMaybe;
         }
       }
-    }
 
-    return (achievements_accessible >= AP_GetMasteryRequirement()) ? kYes
-                                                                   : kMaybe;
+      return kYes;
+    } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
+               !door_obj.group_name.empty()) {
+      return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
+    } else {
+      return IsNonGroupedDoorReachable(door_obj);
+    }
   }
 
-  if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
-      AP_GetLevel2Requirement() > 1) {
-    int counting_panels_accessible = 0;
+  Decision IsDoorReachable(int door_id) {
+    if (options_.parent) {
+      return options_.parent->IsDoorReachable(door_id);
+    }
 
-    for (int solved_panel_id : solveable_panels) {
-      const Panel& solved_panel = GD_GetPanel(solved_panel_id);
+    if (door_decisions_.count(door_id)) {
+      return door_decisions_.at(door_id);
+    }
 
-      if (!solved_panel.non_counting) {
-        counting_panels_accessible++;
-      }
+    Decision result = IsDoorReachable_Helper(door_id);
+    if (result != kMaybe) {
+      door_decisions_[door_id] = result;
     }
 
-    return (counting_panels_accessible >= AP_GetLevel2Requirement() - 1)
-               ? kYes
-               : kMaybe;
+    return result;
   }
 
-  for (int room_id : panel_obj.required_rooms) {
-    if (!reachable_rooms.count(room_id)) {
-      return kMaybe;
-    }
-  }
+  Decision IsPanelReachable(int panel_id) {
+    const Panel& panel_obj = GD_GetPanel(panel_id);
 
-  for (int door_id : panel_obj.required_doors) {
-    Decision door_reachable =
-        IsDoorReachable_Helper(door_id, reachable_rooms, solveable_panels);
-    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) {
+    if (!reachable_rooms_.count(panel_obj.room)) {
       return kMaybe;
     }
-  }
 
-  for (int panel_id : panel_obj.required_panels) {
-    if (!solveable_panels.count(panel_id)) {
-      return kMaybe;
-    }
-  }
+    if (panel_obj.name == "THE MASTER") {
+      int achievements_accessible = 0;
 
-  if (AP_IsColorShuffle()) {
-    for (LingoColor color : panel_obj.colors) {
-      if (!AP_HasItem(GD_GetItemIdForColor(color))) {
-        return kNo;
-      }
-    }
-  }
+      for (int achieve_id : GD_GetAchievementPanels()) {
+        if (solveable_panels_.count(achieve_id)) {
+          achievements_accessible++;
 
-  return kYes;
-}
+          if (achievements_accessible >= AP_GetMasteryRequirement()) {
+            break;
+          }
+        }
+      }
 
-}  // namespace
+      return (achievements_accessible >= AP_GetMasteryRequirement()) ? kYes
+                                                                     : kMaybe;
+    }
 
-void RecalculateReachability() {
-  std::set<int> reachable_rooms;
-  std::set<int> solveable_panels;
+    if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
+        AP_GetLevel2Requirement() > 1) {
+      int counting_panels_accessible = 0;
 
-  std::list<int> panel_boundary;
-  std::list<Exit> flood_boundary;
-  flood_boundary.push_back({.destination_room = GD_GetRoomByName("Menu")});
+      for (int solved_panel_id : solveable_panels_) {
+        const Panel& solved_panel = GD_GetPanel(solved_panel_id);
 
-  if (AP_HasEarlyColorHallways()) {
-    flood_boundary.push_back(
-        {.destination_room = GD_GetRoomByName("Outside The Undeterred")});
-  }
+        if (!solved_panel.non_counting) {
+          counting_panels_accessible++;
+        }
+      }
 
-  bool reachable_changed = true;
-  while (reachable_changed) {
-    reachable_changed = false;
+      return (counting_panels_accessible >= AP_GetLevel2Requirement() - 1)
+                 ? kYes
+                 : kMaybe;
+    }
 
-    std::list<int> new_panel_boundary;
-    for (int panel_id : panel_boundary) {
-      if (solveable_panels.count(panel_id)) {
-        continue;
+    for (int room_id : panel_obj.required_rooms) {
+      if (!reachable_rooms_.count(room_id)) {
+        return kMaybe;
       }
+    }
 
-      Decision panel_reachable =
-          IsPanelReachable_Helper(panel_id, reachable_rooms, solveable_panels);
-      if (panel_reachable == kYes) {
-        solveable_panels.insert(panel_id);
-        reachable_changed = true;
-      } else if (panel_reachable == kMaybe) {
-        new_panel_boundary.push_back(panel_id);
+    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;
       }
     }
 
-    std::list<Exit> new_boundary;
-    for (const Exit& room_exit : flood_boundary) {
-      if (reachable_rooms.count(room_exit.destination_room)) {
-        continue;
+    for (int panel_id : panel_obj.required_panels) {
+      if (!solveable_panels_.count(panel_id)) {
+        return kMaybe;
       }
+    }
 
-      bool valid_transition = false;
-      if (room_exit.door.has_value()) {
-        Decision door_reachable = IsDoorReachable_Helper(
-            *room_exit.door, reachable_rooms, solveable_panels);
-        if (door_reachable == kYes) {
-          valid_transition = true;
-        } else if (door_reachable == kMaybe) {
-          new_boundary.push_back(room_exit);
+    if (AP_IsColorShuffle()) {
+      for (LingoColor color : panel_obj.colors) {
+        if (!AP_HasItem(GD_GetItemIdForColor(color))) {
+          return kNo;
         }
-      } else {
-        valid_transition = true;
       }
+    }
 
-      if (valid_transition) {
-        reachable_rooms.insert(room_exit.destination_room);
-        reachable_changed = true;
+    return kYes;
+  }
 
-        const Room& room_obj = GD_GetRoom(room_exit.destination_room);
-        for (const Exit& out_edge : room_obj.exits) {
-          if (!out_edge.painting || !AP_IsPaintingShuffle()) {
-            new_boundary.push_back(out_edge);
+  Decision IsExitUsable(const Exit& room_exit) {
+    if (room_exit.type == EntranceType::kPilgrimage) {
+      if (options_.pilgrimage || !AP_IsPilgrimageEnabled()) {
+        return kNo;
+      }
+
+      if (AP_GetSunwarpAccess() != kSUNWARP_ACCESS_NORMAL) {
+        for (int door_id : GD_GetSunwarpDoors()) {
+          Decision sub_decision = IsDoorReachable(door_id);
+          if (sub_decision != kYes) {
+            return sub_decision;
           }
         }
+      }
 
-        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;
+      std::vector<std::tuple<int, int>> pilgrimage_pairs;
+      if (AP_IsSunwarpShuffle()) {
+        pilgrimage_pairs = std::vector<std::tuple<int, int>>(5);
 
-              new_boundary.push_back(painting_exit);
-            }
+        for (const auto& [start_index, mapping] : AP_GetSunwarpMapping()) {
+          if (mapping.dots > 1) {
+            std::get<1>(pilgrimage_pairs[mapping.dots - 2]) = start_index;
+          }
+          if (mapping.dots < 6) {
+            std::get<0>(pilgrimage_pairs[mapping.dots - 1]) =
+                mapping.exit_index;
           }
         }
+      } else {
+        pilgrimage_pairs = {{6, 1}, {8, 3}, {9, 4}, {10, 5}};
+      }
 
-        for (int panel_id : room_obj.panels) {
-          new_panel_boundary.push_back(panel_id);
+      for (const auto& [from_sunwarp, to_sunwarp] : pilgrimage_pairs) {
+        StateCalculator pilgrimage_calculator(
+            {.start = GD_GetRoomForSunwarp(from_sunwarp),
+             .pilgrimage = true,
+             .parent = this});
+        pilgrimage_calculator.Calculate();
+
+        if (!pilgrimage_calculator.GetReachableRooms().count(
+                GD_GetRoomForSunwarp(to_sunwarp))) {
+          return kMaybe;
         }
       }
+
+      return kYes;
+    }
+
+    if (options_.pilgrimage) {
+      if (room_exit.type == EntranceType::kWarp ||
+          room_exit.type == EntranceType::kSunwarp) {
+        return kNo;
+      }
+      if (room_exit.type == EntranceType::kCrossroadsRoofAccess &&
+          !AP_DoesPilgrimageAllowRoofAccess()) {
+        return kNo;
+      }
+      if (room_exit.type == EntranceType::kPainting &&
+          !AP_DoesPilgrimageAllowPaintings()) {
+        return kNo;
+      }
     }
 
-    flood_boundary = new_boundary;
-    panel_boundary = new_panel_boundary;
+    if (room_exit.type == EntranceType::kSunwarp) {
+      if (AP_GetSunwarpAccess() == kSUNWARP_ACCESS_NORMAL) {
+        return kYes;
+      } else if (AP_GetSunwarpAccess() == kSUNWARP_ACCESS_DISABLED) {
+        return kNo;
+      }
+    }
+
+    if (room_exit.door.has_value()) {
+      return IsDoorReachable(*room_exit.door);
+    }
+
+    return kYes;
   }
 
+  StateCalculatorOptions options_;
+
+  std::set<int> reachable_rooms_;
+  std::map<int, Decision> door_decisions_;
+  std::set<int> solveable_panels_;
+};
+
+}  // namespace
+
+void RecalculateReachability() {
+  StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
+  state_calculator.Calculate();
+
+  const std::set<int>& reachable_rooms = state_calculator.GetReachableRooms();
+  const std::set<int>& solveable_panels = state_calculator.GetSolveablePanels();
+
   std::map<int, bool> new_reachability;
   for (const MapArea& map_area : GD_GetMapAreas()) {
     for (size_t section_id = 0; section_id < map_area.locations.size();
@@ -37,6 +37,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 8, 0);
+constexpr const Version kTrackerVersion = Version(0, 9, 0);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file