Added door popups that report requirements

6 files changed, 377 insertions, 136 deletions

@@ -271,6 +271,7 @@ struct APState {
       connected = true;
       has_connection_result = true;
 
+      ResetReachabilityRequirements();
       RefreshTracker(true);
 
       std::list<std::string> corrected_keys;
@@ -447,6 +448,8 @@ struct APState {
     return ap_id;
   }
 
+  std::string GetItemName(int id) { return apclient->get_item_name(id); }
+
   bool HasReachedGoal() {
     return data_storage.count(victory_data_storage_key) &&
            std::any_cast<int>(data_storage.at(victory_data_storage_key)) ==
@@ -485,6 +488,10 @@ bool AP_HasItem(int item_id, int quantity) {
   return GetState().HasItem(item_id, quantity);
 }
 
+std::string AP_GetItemName(int item_id) {
+  return GetState().GetItemName(item_id);
+}
+
 DoorShuffleMode AP_GetDoorShuffleMode() { return GetState().door_shuffle_mode; }
 
 bool AP_IsColorShuffle() { return GetState().color_shuffle; }
@@ -49,6 +49,8 @@ bool AP_HasCheckedHuntPanel(int location_id);
 
 bool AP_HasItem(int item_id, int quantity = 1);
 
+std::string AP_GetItemName(int item_id);
+
 DoorShuffleMode AP_GetDoorShuffleMode();
 
 bool AP_IsColorShuffle();
@@ -33,6 +33,14 @@ SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
     return;
   }
 
+  unchecked_eye_ =
+      wxBitmap(wxImage(GetAbsolutePath("assets/unchecked.png").c_str(),
+                       wxBITMAP_TYPE_PNG)
+                   .Scale(32, 32));
+  checked_eye_ = wxBitmap(
+      wxImage(GetAbsolutePath("assets/checked.png").c_str(), wxBITMAP_TYPE_PNG)
+          .Scale(32, 32));
+
   tree_ = std::make_unique<quadtree::Quadtree<int, GetItemBox>>(
       quadtree::Box<float>{0, 0, static_cast<float>(map_image_.GetWidth()),
                            static_cast<float>(map_image_.GetHeight())});
@@ -113,75 +121,144 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
   wxBufferedPaintDC dc(this);
   dc.DrawBitmap(rendered_, 0, 0);
 
-  if (hovered_item_ && networks_.IsItemInNetwork(*hovered_item_)) {
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+  if (hovered_item_) {
+    const SubwayItem &subway_item = GD_GetSubwayItem(*hovered_item_);
+    if (subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) {
+      const std::map<std::string, bool> &report =
+          GetDoorRequirements(*subway_item.door);
 
-    for (const auto &[item_id1, item_id2] :
-         networks_.GetNetworkGraph(*hovered_item_)) {
-      const SubwayItem &item1 = GD_GetSubwayItem(item_id1);
-      const SubwayItem &item2 = GD_GetSubwayItem(item_id2);
+      int acc_height = 10;
+      int col_width = 0;
 
-      int item1_x = (item1.x + AREA_ACTUAL_SIZE / 2) * render_width_ / map_image_.GetWidth() + render_x_;
-      int item1_y = (item1.y + AREA_ACTUAL_SIZE / 2) * render_width_ / map_image_.GetWidth() + render_y_;
+      for (const auto &[text, obtained] : report) {
+        wxSize item_extent = dc.GetTextExtent(text);
+        int item_height = std::max(32, item_extent.GetHeight()) + 10;
+        acc_height += item_height;
 
-      int item2_x = (item2.x + AREA_ACTUAL_SIZE / 2) * render_width_ / map_image_.GetWidth() + render_x_;
-      int item2_y = (item2.y + AREA_ACTUAL_SIZE / 2) * render_width_ / map_image_.GetWidth() + render_y_;
+        if (item_extent.GetWidth() > col_width) {
+          col_width = item_extent.GetWidth();
+        }
+      }
+      
+      int item_width = col_width + 10 + 32;
+      int full_width = item_width + 20;
+
+      int popup_x = (subway_item.x + AREA_ACTUAL_SIZE / 2) * render_width_ /
+                        map_image_.GetWidth() +
+                    render_x_;
+      int popup_y = (subway_item.y + AREA_ACTUAL_SIZE / 2) * render_width_ /
+                        map_image_.GetWidth() +
+                    render_y_;
+
+      if (popup_x + full_width > GetSize().GetWidth()) {
+        popup_x = GetSize().GetWidth() - full_width;
+      }
+      if (popup_y + acc_height > GetSize().GetHeight()) {
+        popup_y = GetSize().GetHeight() - acc_height;
+      }
 
-      int left = std::min(item1_x, item2_x);
-      int top = std::min(item1_y, item2_y);
-      int right = std::max(item1_x, item2_x);
-      int bottom = std::max(item1_y, item2_y);
+      dc.SetPen(*wxTRANSPARENT_PEN);
+      dc.SetBrush(*wxBLACK_BRUSH);
+      dc.DrawRectangle({popup_x, popup_y}, {full_width, acc_height});
 
-      int halfwidth = right - left;
-      int halfheight = bottom - top;
+      dc.SetFont(GetFont());
 
-      if (halfwidth < 4 || halfheight < 4) {
-        dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
-        dc.DrawLine(item1_x, item1_y, item2_x, item2_y);
-        dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
-        dc.DrawLine(item1_x, item1_y, item2_x, item2_y);
-      } else {
-        int ellipse_x;
-        int ellipse_y;
-        double start;
-        double end;
+      int cur_height = 10;
 
-        if (item1_x > item2_x) {
-          ellipse_y = top;
+      for (const auto& [text, obtained] : report) {
+        wxBitmap *eye_ptr = obtained ? &unchecked_eye_ : &checked_eye_;
 
-          if (item1_y > item2_y) {
-            ellipse_x = left - halfwidth;
+        dc.DrawBitmap(*eye_ptr, {popup_x + 10, popup_y + cur_height});
 
-            start = 0;
-            end = 90;
-          } else {
-            ellipse_x = left;
+        dc.SetTextForeground(obtained ? *wxWHITE : *wxRED);
+        wxSize item_extent = dc.GetTextExtent(text);
+        dc.DrawText(
+            text,
+            {popup_x + 10 + 32 + 10,
+             popup_y + cur_height + (32 - dc.GetFontMetrics().height) / 2});
 
-            start = 90;
-            end = 180;
-          }
+        cur_height += 10 + 32;
+      }
+    }
+
+    if (networks_.IsItemInNetwork(*hovered_item_)) {
+      dc.SetBrush(*wxTRANSPARENT_BRUSH);
+
+      for (const auto &[item_id1, item_id2] :
+           networks_.GetNetworkGraph(*hovered_item_)) {
+        const SubwayItem &item1 = GD_GetSubwayItem(item_id1);
+        const SubwayItem &item2 = GD_GetSubwayItem(item_id2);
+
+        int item1_x = (item1.x + AREA_ACTUAL_SIZE / 2) * render_width_ /
+                          map_image_.GetWidth() +
+                      render_x_;
+        int item1_y = (item1.y + AREA_ACTUAL_SIZE / 2) * render_width_ /
+                          map_image_.GetWidth() +
+                      render_y_;
+
+        int item2_x = (item2.x + AREA_ACTUAL_SIZE / 2) * render_width_ /
+                          map_image_.GetWidth() +
+                      render_x_;
+        int item2_y = (item2.y + AREA_ACTUAL_SIZE / 2) * render_width_ /
+                          map_image_.GetWidth() +
+                      render_y_;
+
+        int left = std::min(item1_x, item2_x);
+        int top = std::min(item1_y, item2_y);
+        int right = std::max(item1_x, item2_x);
+        int bottom = std::max(item1_y, item2_y);
+
+        int halfwidth = right - left;
+        int halfheight = bottom - top;
+
+        if (halfwidth < 4 || halfheight < 4) {
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawLine(item1_x, item1_y, item2_x, item2_y);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawLine(item1_x, item1_y, item2_x, item2_y);
         } else {
-          ellipse_y = top - halfheight;
+          int ellipse_x;
+          int ellipse_y;
+          double start;
+          double end;
 
-          if (item1_y > item2_y) {
-            ellipse_x = left - halfwidth;
+          if (item1_x > item2_x) {
+            ellipse_y = top;
 
-            start = 270;
-            end = 360;
+            if (item1_y > item2_y) {
+              ellipse_x = left - halfwidth;
+
+              start = 0;
+              end = 90;
+            } else {
+              ellipse_x = left;
+
+              start = 90;
+              end = 180;
+            }
           } else {
-            ellipse_x = left;
+            ellipse_y = top - halfheight;
+
+            if (item1_y > item2_y) {
+              ellipse_x = left - halfwidth;
 
-            start = 180;
-            end = 270;
+              start = 270;
+              end = 360;
+            } else {
+              ellipse_x = left;
+
+              start = 180;
+              end = 270;
+            }
           }
-        }
 
-        dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
-        dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2, halfheight * 2,
-                           start, end);
-        dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
-        dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2, halfheight * 2,
-                           start, end);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2, halfheight * 2,
+                             start, end);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2, halfheight * 2,
+                             start, end);
+        }
       }
     }
   }
@@ -34,6 +34,8 @@ class SubwayMap : public wxPanel {
 
   wxImage map_image_;
   wxImage owl_image_;
+  wxBitmap unchecked_eye_;
+  wxBitmap checked_eye_;
 
   wxBitmap rendered_;
   int render_x_ = 0;
@@ -12,10 +12,138 @@
 
 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 (!AP_IsPilgrimageEnabled() &&
+          door_obj.type == DoorType::kSunPainting) {
+        requirements.items.insert(door_obj.ap_item_id);
+      } 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::mutex reachability_mutex;
+  RequirementCalculator requirements;
+  std::map<int, std::map<std::string, bool>> door_reports;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -172,6 +300,10 @@ class StateCalculator {
 
   const std::set<int>& GetSolveablePanels() const { return solveable_panels_; }
 
+  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);
@@ -188,68 +320,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() == kNO_DOORS || door_obj.skip_item) {
-      if (!reachable_rooms_.count(door_obj.room)) {
-        return kMaybe;
-      }
+  Decision AreRequirementsSatisfied(const Requirements& reqs, std::map<std::string, bool>* report = nullptr) {
+    if (reqs.disabled) {
+      return kNo;
+    }
 
-      for (int panel_id : door_obj.panels) {
-        if (!solveable_panels_.count(panel_id)) {
-          return kMaybe;
-        }
-      }
+    Decision final_decision = kYes;
 
-      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);
-    }
-  }
+    for (int door_id : reqs.doors) {
+      const Door& door_obj = GD_GetDoor(door_id);
+      Decision decision = IsNonGroupedDoorReachable(door_obj);
 
-  Decision IsDoorReachable(int door_id) {
-    if (options_.parent) {
-      return options_.parent->IsDoorReachable(door_id);
-    }
+      if (report) {
+        (*report)[door_obj.item_name] = (decision == kYes);
+      }
 
-    if (door_decisions_.count(door_id)) {
-      return door_decisions_.at(door_id);
+      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;
+      }
 
-    Decision result = IsDoorReachable_Helper(door_id);
-    if (result != kMaybe) {
-      door_decisions_[door_id] = result;
+      if (!has_item) {
+        final_decision = kNo;
+      }
     }
 
-    return result;
-  }
-
-  Decision IsPanelReachable(int panel_id) {
-    const Panel& panel_obj = GD_GetPanel(panel_id);
+    for (int room_id : reqs.rooms) {
+      bool reachable = reachable_rooms_.count(room_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()) {
@@ -262,12 +378,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_) {
@@ -278,44 +400,52 @@ 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;
+      }
+      
+      if (can_level2 && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    for (int room_id : panel_obj.required_rooms) {
-      if (!reachable_rooms_.count(room_id)) {
-        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] = {};
     }
+    
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id),
+                                    &door_report_[door_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;
-      }
+  Decision IsDoorReachable(int door_id) {
+    if (options_.parent) {
+      return options_.parent->IsDoorReachable(door_id);
     }
 
-    for (int panel_id : panel_obj.required_panels) {
-      if (!solveable_panels_.count(panel_id)) {
-        return kMaybe;
-      }
+    if (door_decisions_.count(door_id)) {
+      return door_decisions_.at(door_id);
     }
 
-    if (AP_IsColorShuffle()) {
-      for (LingoColor color : panel_obj.colors) {
-        if (!AP_HasItem(GD_GetItemIdForColor(color))) {
-          return kNo;
-        }
-      }
+    Decision result = IsDoorReachable_Helper(door_id);
+    if (result != kMaybe) {
+      door_decisions_[door_id] = result;
     }
 
-    return kYes;
+    return result;
+  }
+
+  Decision IsPanelReachable(int panel_id) {
+    return AreRequirementsSatisfied(GetState().requirements.GetPanel(panel_id));
   }
 
   Decision IsExitUsable(const Exit& room_exit) {
@@ -401,10 +531,16 @@ class StateCalculator {
   std::set<int> reachable_rooms_;
   std::map<int, Decision> door_decisions_;
   std::set<int> solveable_panels_;
+  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() {
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
   state_calculator.Calculate();
@@ -435,10 +571,14 @@ void RecalculateReachability() {
     }
   }
 
+  std::map<int, std::map<std::string, bool>> door_reports =
+      state_calculator.GetDoorReports();
+
   {
     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().door_reports, door_reports);
   }
 }
 
@@ -457,3 +597,9 @@ bool IsDoorOpen(int door_id) {
 
   return GetState().reachable_doors.count(door_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);
+}
@@ -1,10 +1,17 @@
 #ifndef TRACKER_STATE_H_8639BC90
 #define TRACKER_STATE_H_8639BC90
 
+#include <map>
+#include <string>
+
+void ResetReachabilityRequirements();
+
 void RecalculateReachability();
 
 bool IsLocationReachable(int location_id);
 
 bool IsDoorOpen(int door_id);
 
+const std::map<std::string, bool>& GetDoorRequirements(int door_id);
+
 #endif /* end of include guard: TRACKER_STATE_H_8639BC90 */