Added sunwarp access support

6 files changed, 91 insertions, 20 deletions

@@ -1,20 +1,35 @@
 ---
   - room: Second Room
     door: Exit Door
+  - room: Hub Room
+    door: 1 Sunwarp
+    sunwarp: True
   - room: Crossroads
     door: Tower Entrance
   - room: Orange Tower Fourth Floor
     door: Hot Crusts Door
+  - room: Hot Crusts Area
+    door: 2 Sunwarp
+    sunwarp: True
+  - room: Orange Tower Third Floor
+    door: 3 Sunwarp
+    sunwarp: True
   - room: Outside The Initiated
     door: Shortcut to Hub Room
   - room: Orange Tower First Floor
     door: Shortcut to Hub Room
+  - room: Orange Tower First Floor
+    door: 4 Sunwarp
+    sunwarp: True
   - room: Directional Gallery
     door: Shortcut to The Undeterred
   - room: Orange Tower First Floor
     door: Salt Pepper Door
   - room: Hub Room
     door: Crossroads Entrance
+  - room: Orange Tower Fourth Floor
+    door: 5 Sunwarp
+    sunwarp: True
   - room: Color Hunt
     door: Shortcut to The Steady
   - room: The Bearer
@@ -25,3 +40,6 @@
     door: Shortcut to Hub Room
   - room: Outside The Agreeable
     door: Tenacious Entrance
+  - room: Outside The Agreeable
+    door: 6 Sunwarp
+    sunwarp: True
@@ -60,6 +60,7 @@ struct APState {
   LocationChecks location_checks = kNORMAL_LOCATIONS;
   VictoryCondition victory_condition = kTHE_END;
   bool early_color_hallways = false;
+  SunwarpAccess sunwarp_access = kSUNWARP_ACCESS_NORMAL;
 
   std::map<std::string, std::string> painting_mapping;
 
@@ -128,6 +129,7 @@ struct APState {
     location_checks = kNORMAL_LOCATIONS;
     victory_condition = kTHE_END;
     early_color_hallways = false;
+    sunwarp_access = kSUNWARP_ACCESS_NORMAL;
 
     connected = false;
     has_connection_result = false;
@@ -222,6 +224,7 @@ 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;
+      sunwarp_access = slot_data["sunwarp_access"].get<SunwarpAccess>();
 
       if (painting_shuffle && slot_data.contains("painting_entrance_to_exit")) {
         painting_mapping.clear();
@@ -417,3 +420,5 @@ bool AP_HasAchievement(const std::string& achievement_name) {
 }
 
 bool AP_HasEarlyColorHallways() { return GetState().early_color_hallways; }
+
+SunwarpAccess AP_GetSunwarpAccess() { return GetState().sunwarp_access; }
@@ -14,6 +14,8 @@ enum VictoryCondition { kTHE_END = 0, kTHE_MASTER = 1, kLEVEL_2 = 2 };
 
 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_PROGRESSIVE = 3 };
+
 void AP_SetTrackerFrame(TrackerFrame* tracker_frame);
 
 void AP_Connect(std::string server, std::string player, std::string password);
@@ -44,4 +46,6 @@ bool AP_HasAchievement(const std::string& achievement_name);
 
 bool AP_HasEarlyColorHallways();
 
+SunwarpAccess AP_GetSunwarpAccess();
+
 #endif /* end of include guard: AP_STATE_H_664A4180 */
@@ -58,6 +58,9 @@ struct GameData {
 
   std::map<LingoColor, int> ap_id_by_color_;
 
+  std::vector<int> pilgrimage_;
+  std::vector<int> pilgrimage_with_sunwarps_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -125,6 +128,10 @@ struct GameData {
               exit_obj.painting = entrance_it.second["painting"].as<bool>();
             }
 
+            if (entrance_it.second["sunwarp"]) {
+              exit_obj.sunwarp = entrance_it.second["sunwarp"].as<bool>();
+            }
+
             rooms_[from_room_id].exits.push_back(exit_obj);
             break;
           }
@@ -144,6 +151,10 @@ struct GameData {
                 exit_obj.painting = option["painting"].as<bool>();
               }
 
+              if (option["sunwarp"]) {
+                exit_obj.sunwarp = option["sunwarp"].as<bool>();
+              }
+
               rooms_[from_room_id].exits.push_back(exit_obj);
             }
 
@@ -576,31 +587,20 @@ 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 door_id = AddOrGetDoor(config_node["room"].as<std::string>(),
+                                 config_node["door"].as<std::string>());
+      if (config_node["sunwarp"] && config_node["sunwarp"].as<bool>()) {
+        pilgrimage_with_sunwarps_.push_back(door_id);
+      }
+      pilgrimage_.push_back(door_id);
     }
 
-    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});
+             .pilgrimage = true});
 
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
@@ -694,3 +694,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_GetPilgrimageDoors(bool include_sunwarps) {
+  if (include_sunwarps) {
+    return GetState().pilgrimage_with_sunwarps_;
+  } else {
+    return GetState().pilgrimage_;
+  }
+}
@@ -67,6 +67,8 @@ struct Exit {
   int destination_room;
   std::optional<int> door;
   bool painting = false;
+  bool sunwarp = false;
+  bool pilgrimage = false;
 };
 
 struct PaintingExit {
@@ -111,5 +113,6 @@ 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_GetPilgrimageDoors(bool include_sunwarps);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -182,13 +182,46 @@ void RecalculateReachability() {
 
       bool valid_transition = false;
       if (room_exit.door.has_value()) {
-        Decision door_reachable = IsDoorReachable_Helper(
-            *room_exit.door, reachable_rooms, solveable_panels);
+        Decision door_reachable = kMaybe;
+        if (room_exit.sunwarp) {
+          if (AP_GetSunwarpAccess() == kSUNWARP_ACCESS_NORMAL) {
+            door_reachable = kYes;
+          } else if (AP_GetSunwarpAccess() == kSUNWARP_ACCESS_DISABLED) {
+            door_reachable = kNo;
+          } else {
+            door_reachable = IsDoorReachable_Helper(
+                *room_exit.door, reachable_rooms, solveable_panels);
+          }
+        } else {
+          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);
         }
+      } else if (room_exit.pilgrimage) {
+        Decision pilgrimage_reachable = kYes;
+        if (AP_GetSunwarpAccess() == kSUNWARP_ACCESS_DISABLED) {
+          pilgrimage_reachable = kNo;
+        }
+        if (pilgrimage_reachable == kYes) {
+          for (int door_id : GD_GetPilgrimageDoors(
+                   AP_GetSunwarpAccess() == kSUNWARP_ACCESS_UNLOCK ||
+                   AP_GetSunwarpAccess() == kSUNWARP_ACCESS_PROGRESSIVE)) {
+            pilgrimage_reachable = IsDoorReachable_Helper(
+                door_id, reachable_rooms, solveable_panels);
+            if (pilgrimage_reachable != kYes) {
+              break;
+            }
+          }
+        }
+        if (pilgrimage_reachable == kYes) {
+          valid_transition = true;
+        } else if (pilgrimage_reachable == kMaybe) {
+          new_boundary.push_back(room_exit);
+        }
       } else {
         valid_transition = true;
       }