1 files changed, 677 insertions, 165 deletions

@@ -1,22 +1,36 @@
 #include "subway_map.h"
 
+#include <fmt/core.h>
 #include <wx/dcbuffer.h>
+#include <wx/dcgraph.h>
 
 #include <sstream>
 
 #include "ap_state.h"
 #include "game_data.h"
 #include "global.h"
+#include "report_popup.h"
 #include "tracker_state.h"
 
 constexpr int AREA_ACTUAL_SIZE = 21;
 constexpr int OWL_ACTUAL_SIZE = 32;
+constexpr int PAINTING_RADIUS = 9; // the actual circles on the map are radius 11
+constexpr int PAINTING_EXIT_RADIUS = 6;
 
-enum class ItemDrawType {
-  kNone,
-  kBox,
-  kOwl
-};
+enum class ItemDrawType { kNone, kBox, kOwl, kOwlExit };
+
+namespace {
+
+wxPoint GetSubwayItemMapCenter(const SubwayItem &subway_item) {
+  if (subway_item.painting) {
+    return {subway_item.x, subway_item.y};
+  } else {
+    return {subway_item.x + AREA_ACTUAL_SIZE / 2,
+            subway_item.y + AREA_ACTUAL_SIZE / 2};
+  }
+}
+
+}  // namespace
 
 SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
   SetBackgroundStyle(wxBG_STYLE_PAINT);
@@ -42,28 +56,109 @@ SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
 
   Redraw();
 
+  scroll_timer_ = new wxTimer(this);
+
   Bind(wxEVT_PAINT, &SubwayMap::OnPaint, this);
   Bind(wxEVT_MOTION, &SubwayMap::OnMouseMove, this);
+  Bind(wxEVT_MOUSEWHEEL, &SubwayMap::OnMouseScroll, this);
+  Bind(wxEVT_LEAVE_WINDOW, &SubwayMap::OnMouseLeave, this);
+  Bind(wxEVT_LEFT_DOWN, &SubwayMap::OnMouseClick, this);
+  Bind(wxEVT_TIMER, &SubwayMap::OnTimer, this);
+
+  zoom_slider_ = new wxSlider(this, wxID_ANY, 0, 0, 8, FromDIP(wxPoint{15, 15}));
+  zoom_slider_->Bind(wxEVT_SLIDER, &SubwayMap::OnZoomSlide, this);
+
+  help_button_ = new wxButton(this, wxID_ANY, "Help");
+  help_button_->Bind(wxEVT_BUTTON, &SubwayMap::OnClickHelp, this);
+  SetUpHelpButton();
+
+  report_popup_ = new ReportPopup(this);
 }
 
 void SubwayMap::OnConnect() {
   networks_.Clear();
 
   std::map<std::string, std::vector<int>> tagged;
+  std::map<std::string, std::vector<int>> entrances;
+  std::map<std::string, std::vector<int>> exits;
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
-    if (AP_IsPaintingShuffle() && !subway_item.paintings.empty()) {
+    if (AP_HasEarlyColorHallways() &&
+        subway_item.special == "early_color_hallways") {
+      entrances["early_ch"].push_back(subway_item.id);
+    }
+
+    if (AP_IsPaintingShuffle() && subway_item.painting) {
       continue;
     }
 
     for (const std::string &tag : subway_item.tags) {
       tagged[tag].push_back(subway_item.id);
     }
+    for (const std::string &tag : subway_item.entrances) {
+      entrances[tag].push_back(subway_item.id);
+    }
+    for (const std::string &tag : subway_item.exits) {
+      exits[tag].push_back(subway_item.id);
+    }
 
-    if (!AP_IsSunwarpShuffle() && subway_item.sunwarp && subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
-      std::ostringstream tag;
-      tag << "sunwarp" << subway_item.sunwarp->dots;
+    if (!AP_IsSunwarpShuffle() && subway_item.sunwarp) {
+      std::string tag = fmt::format("sunwarp{}", subway_item.sunwarp->dots);
+      switch (subway_item.sunwarp->type) {
+        case SubwaySunwarpType::kEnter:
+          entrances[tag].push_back(subway_item.id);
+          break;
+        case SubwaySunwarpType::kExit:
+          exits[tag].push_back(subway_item.id);
+          break;
+        default:
+          break;
+      }
+    }
 
-      tagged[tag.str()].push_back(subway_item.id);
+    if (!AP_IsPilgrimageEnabled()) {
+      if (subway_item.special == "sun_painting") {
+        entrances["sun_painting"].push_back(subway_item.id);
+      } else if (subway_item.special == "sun_painting_exit") {
+        exits["sun_painting"].push_back(subway_item.id);
+      }
+    }
+  }
+
+  if (AP_IsSunwarpShuffle()) {
+    sunwarp_mapping_ = AP_GetSunwarpMapping();
+
+    SubwaySunwarp final_sunwarp{.dots = 6, .type = SubwaySunwarpType::kFinal};
+    int final_sunwarp_item = GD_GetSubwayItemForSunwarp(final_sunwarp);
+
+    for (const auto &[index, mapping] : sunwarp_mapping_) {
+      std::string tag = fmt::format("sunwarp{}", mapping.dots);
+
+      SubwaySunwarp fromWarp;
+      if (index < 6) {
+        fromWarp.dots = index + 1;
+        fromWarp.type = SubwaySunwarpType::kEnter;
+      } else {
+        fromWarp.dots = index - 5;
+        fromWarp.type = SubwaySunwarpType::kExit;
+      }
+
+      SubwaySunwarp toWarp;
+      if (mapping.exit_index < 6) {
+        toWarp.dots = mapping.exit_index + 1;
+        toWarp.type = SubwaySunwarpType::kEnter;
+      } else {
+        toWarp.dots = mapping.exit_index - 5;
+        toWarp.type = SubwaySunwarpType::kExit;
+      }
+
+      entrances[tag].push_back(GD_GetSubwayItemForSunwarp(fromWarp));
+      exits[tag].push_back(GD_GetSubwayItemForSunwarp(toWarp));
+
+      networks_.AddLinkToNetwork(
+          final_sunwarp_item, GD_GetSubwayItemForSunwarp(fromWarp),
+          mapping.dots == 6 ? final_sunwarp_item
+                            : GD_GetSubwayItemForSunwarp(toWarp),
+          false);
     }
   }
 
@@ -73,115 +168,243 @@ void SubwayMap::OnConnect() {
          tag_it1++) {
       for (auto tag_it2 = std::next(tag_it1); tag_it2 != items.end();
            tag_it2++) {
-        networks_.AddLink(*tag_it1, *tag_it2);
+        // two links because tags are bi-directional
+        networks_.AddLink(*tag_it1, *tag_it2, true);
+      }
+    }
+  }
+
+  for (const auto &[tag, items] : entrances) {
+    if (!exits.contains(tag)) continue;
+    for (auto exit : exits[tag]) {
+      for (auto entrance : items) {
+        networks_.AddLink(entrance, exit, false);
       }
     }
   }
 
   checked_paintings_.clear();
+
+  UpdateIndicators();
 }
 
 void SubwayMap::UpdateIndicators() {
+  if (AP_IsSunwarpShuffle()) {
+    sunwarp_mapping_ = AP_GetSunwarpMapping();
+  }
+
   if (AP_IsPaintingShuffle()) {
-    for (const std::string &painting_id : AP_GetCheckedPaintings()) {
+    std::map<std::string, std::string> painting_mapping =
+        AP_GetPaintingMapping();
+    std::set<std::string> remote_checked_paintings = AP_GetCheckedPaintings();
+
+    for (const std::string &painting_id : remote_checked_paintings) {
       if (!checked_paintings_.count(painting_id)) {
         checked_paintings_.insert(painting_id);
 
-        if (AP_GetPaintingMapping().count(painting_id)) {
-          networks_.AddLink(GD_GetSubwayItemForPainting(painting_id),
-                            GD_GetSubwayItemForPainting(
-                                AP_GetPaintingMapping().at(painting_id)));
+        if (painting_mapping.count(painting_id)) {
+          std::optional<int> from_id = GD_GetSubwayItemForPainting(painting_id);
+          std::optional<int> to_id = GD_GetSubwayItemForPainting(painting_mapping.at(painting_id));
+
+          if (from_id && to_id) {
+            networks_.AddLink(*from_id, *to_id, false);
+          }
         }
       }
     }
   }
 
+  report_popup_->UpdateIndicators();
+
   Redraw();
 }
 
 void SubwayMap::UpdateSunwarp(SubwaySunwarp from_sunwarp,
-  SubwaySunwarp to_sunwarp) {
+                              SubwaySunwarp to_sunwarp) {
   networks_.AddLink(GD_GetSubwayItemForSunwarp(from_sunwarp),
-                    GD_GetSubwayItemForSunwarp(to_sunwarp));
+                    GD_GetSubwayItemForSunwarp(to_sunwarp), false);
+}
+
+void SubwayMap::Zoom(bool in) {
+  wxPoint focus_point;
+
+  if (mouse_position_) {
+    focus_point = *mouse_position_;
+  } else {
+    focus_point = {GetSize().GetWidth() / 2, GetSize().GetHeight() / 2};
+  }
+
+  if (in) {
+    if (zoom_ < 3.0) {
+      SetZoom(zoom_ + 0.25, focus_point);
+    }
+  } else {
+    if (zoom_ > 1.0) {
+      SetZoom(zoom_ - 0.25, focus_point);
+    }
+  }
 }
 
 void SubwayMap::OnPaint(wxPaintEvent &event) {
   if (GetSize() != rendered_.GetSize()) {
-    Redraw();
-  }
+    wxSize panel_size = GetSize();
+    wxSize image_size = map_image_.GetSize();
+
+    render_x_ = 0;
+    render_y_ = 0;
+    render_width_ = panel_size.GetWidth();
+    render_height_ = panel_size.GetHeight();
+
+    if (image_size.GetWidth() * panel_size.GetHeight() >
+        panel_size.GetWidth() * image_size.GetHeight()) {
+      render_height_ = (panel_size.GetWidth() * image_size.GetHeight()) /
+                       image_size.GetWidth();
+      render_y_ = (panel_size.GetHeight() - render_height_) / 2;
+    } else {
+      render_width_ = (image_size.GetWidth() * panel_size.GetHeight()) /
+                      image_size.GetHeight();
+      render_x_ = (panel_size.GetWidth() - render_width_) / 2;
+    }
 
-  wxBufferedPaintDC dc(this);
-  dc.DrawBitmap(rendered_, 0, 0);
+    SetZoomPos({zoom_x_, zoom_y_});
 
-  if (hovered_item_ && networks_.IsItemInNetwork(*hovered_item_)) {
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    SetUpHelpButton();
 
-    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);
+    zoom_slider_->SetSize(FromDIP(15), FromDIP(15), wxDefaultCoord,
+                          wxDefaultCoord, wxSIZE_AUTO);
+  }
 
-      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_;
+  wxBufferedPaintDC dc(this);
+  dc.SetBackground(*wxWHITE_BRUSH);
+  dc.Clear();
+
+  {
+    wxMemoryDC rendered_dc;
+    rendered_dc.SelectObject(rendered_);
+
+    int dst_x;
+    int dst_y;
+    int dst_w;
+    int dst_h;
+    int src_x;
+    int src_y;
+    int src_w;
+    int src_h;
+
+    int zoomed_width = render_width_ * zoom_;
+    int zoomed_height = render_height_ * zoom_;
+
+    if (zoomed_width <= GetSize().GetWidth()) {
+      dst_x = (GetSize().GetWidth() - zoomed_width) / 2;
+      dst_w = zoomed_width;
+      src_x = 0;
+      src_w = map_image_.GetWidth();
+    } else {
+      dst_x = 0;
+      dst_w = GetSize().GetWidth();
+      src_x = -zoom_x_ * map_image_.GetWidth() / render_width_ / zoom_;
+      src_w =
+          GetSize().GetWidth() * map_image_.GetWidth() / render_width_ / zoom_;
+    }
 
-      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 (zoomed_height <= GetSize().GetHeight()) {
+      dst_y = (GetSize().GetHeight() - zoomed_height) / 2;
+      dst_h = zoomed_height;
+      src_y = 0;
+      src_h = map_image_.GetHeight();
+    } else {
+      dst_y = 0;
+      dst_h = GetSize().GetHeight();
+      src_y = -zoom_y_ * map_image_.GetWidth() / render_width_ / zoom_;
+      src_h =
+          GetSize().GetHeight() * map_image_.GetWidth() / render_width_ / zoom_;
+    }
 
-      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);
+    wxGCDC gcdc(dc);
+    gcdc.GetGraphicsContext()->SetInterpolationQuality(wxINTERPOLATION_GOOD);
+    gcdc.StretchBlit(dst_x, dst_y, dst_w, dst_h, &rendered_dc, src_x, src_y,
+                     src_w, src_h);
+  }
 
-      int halfwidth = right - left;
-      int halfheight = bottom - top;
+  if (hovered_item_) {
+    if (networks_.IsItemInNetwork(*hovered_item_)) {
+      dc.SetBrush(*wxTRANSPARENT_BRUSH);
+
+      for (const auto node : networks_.GetNetworkGraph(*hovered_item_)) {
+        const SubwayItem &item1 = GD_GetSubwayItem(node.entry);
+        const SubwayItem &item2 = GD_GetSubwayItem(node.exit);
+
+        wxPoint item1_pos = MapPosToRenderPos(GetSubwayItemMapCenter(item1));
+        wxPoint item2_pos = MapPosToRenderPos(GetSubwayItemMapCenter(item2));
+
+        int left = std::min(item1_pos.x, item2_pos.x);
+        int top = std::min(item1_pos.y, item2_pos.y);
+        int right = std::max(item1_pos.x, item2_pos.x);
+        int bottom = std::max(item1_pos.y, item2_pos.y);
+
+        int halfwidth = right - left;
+        int halfheight = bottom - top;
+
+        if (halfwidth < 4 || halfheight < 4) {
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawLine(item1_pos, item2_pos);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawLine(item1_pos, item2_pos);
+          if (!node.two_way) {
+            dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 2));
+            dc.SetBrush(*wxCYAN_BRUSH);
+            dc.DrawCircle(item2_pos, 4);
+            dc.SetBrush(*wxTRANSPARENT_BRUSH);
+          }
+        } else {
+          int ellipse_x;
+          int ellipse_y;
+          double start;
+          double end;
 
-      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;
+          if (item1_pos.x > item2_pos.x) {
+            ellipse_y = top;
 
-        if (item1_x > item2_x) {
-          ellipse_y = top;
+            if (item1_pos.y > item2_pos.y) {
+              ellipse_x = left - halfwidth;
 
-          if (item1_y > item2_y) {
-            ellipse_x = left - halfwidth;
+              start = 0;
+              end = 90;
+            } else {
+              ellipse_x = left;
 
-            start = 0;
-            end = 90;
+              start = 90;
+              end = 180;
+            }
           } else {
-            ellipse_x = left;
+            ellipse_y = top - halfheight;
 
-            start = 90;
-            end = 180;
-          }
-        } else {
-          ellipse_y = top - halfheight;
+            if (item1_pos.y > item2_pos.y) {
+              ellipse_x = left - halfwidth;
 
-          if (item1_y > item2_y) {
-            ellipse_x = left - halfwidth;
+              start = 270;
+              end = 360;
+            } else {
+              ellipse_x = left;
 
-            start = 270;
-            end = 360;
-          } else {
-            ellipse_x = left;
+              start = 180;
+              end = 270;
+            }
+          }
 
-            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);
+          if (!node.two_way) {
+            dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 2));
+            dc.SetBrush(*wxCYAN_BRUSH);
+            dc.DrawCircle(item2_pos, 4);
+            dc.SetBrush(*wxTRANSPARENT_BRUSH);
           }
         }
-
-        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);
       }
     }
   }
@@ -190,137 +413,426 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
 }
 
 void SubwayMap::OnMouseMove(wxMouseEvent &event) {
-  int mouse_x = std::clamp(
-      (event.GetX() - render_x_) * map_image_.GetWidth() / render_width_,
-      0, map_image_.GetWidth() - 1);
-  int mouse_y = std::clamp(
-      (event.GetY() - render_y_) * map_image_.GetWidth() / render_width_,
-      0, map_image_.GetHeight() - 1);
+  wxPoint mouse_pos = RenderPosToMapPos(event.GetPosition());
 
   std::vector<int> hovered = tree_->query(
-      {static_cast<float>(mouse_x), static_cast<float>(mouse_y), 2, 2});
-  std::optional<int> new_hovered_item;
+      {static_cast<float>(mouse_pos.x), static_cast<float>(mouse_pos.y), 2, 2});
   if (!hovered.empty()) {
-    new_hovered_item = hovered[0];
+    actual_hover_ = hovered[0];
+  } else {
+    actual_hover_ = std::nullopt;
   }
 
-  if (new_hovered_item != hovered_item_) {
-    hovered_item_ = new_hovered_item;
+  if (!sticky_hover_ && actual_hover_ != hovered_item_) {
+    EvaluateHover();
+  }
 
-    Refresh();
+  if (scroll_mode_) {
+    EvaluateScroll(event.GetPosition());
   }
 
+  mouse_position_ = event.GetPosition();
+
   event.Skip();
 }
 
-void SubwayMap::Redraw() {
-  wxSize panel_size = GetSize();
-  wxSize image_size = map_image_.GetSize();
-
-  render_x_ = 0;
-  render_y_ = 0;
-  render_width_ = panel_size.GetWidth();
-  render_height_ = panel_size.GetHeight();
-
-  if (image_size.GetWidth() * panel_size.GetHeight() >
-      panel_size.GetWidth() * image_size.GetHeight()) {
-    render_height_ = (panel_size.GetWidth() * image_size.GetHeight()) /
-                     image_size.GetWidth();
-    render_y_ = (panel_size.GetHeight() - render_height_) / 2;
+void SubwayMap::OnMouseScroll(wxMouseEvent &event) {
+  double new_zoom = zoom_;
+  if (event.GetWheelRotation() > 0) {
+    new_zoom = std::min(3.0, zoom_ + 0.25);
   } else {
-    render_width_ = (image_size.GetWidth() * panel_size.GetHeight()) /
-                    image_size.GetHeight();
-    render_x_ = (panel_size.GetWidth() - render_width_) / 2;
+    new_zoom = std::max(1.0, zoom_ - 0.25);
+  }
+
+  if (zoom_ != new_zoom) {
+    SetZoom(new_zoom, event.GetPosition());
+  }
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseLeave(wxMouseEvent &event) {
+  SetScrollSpeed(0, 0);
+  mouse_position_ = std::nullopt;
+}
+
+void SubwayMap::OnMouseClick(wxMouseEvent &event) {
+  bool finished = false;
+
+  if (actual_hover_) {
+    const SubwayItem &subway_item = GD_GetSubwayItem(*actual_hover_);
+    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
+
+    if ((subway_door && !GetDoorRequirements(*subway_door).empty()) ||
+        networks_.IsItemInNetwork(*hovered_item_)) {
+      if (actual_hover_ != hovered_item_) {
+        EvaluateHover();
+
+        if (!hovered_item_) {
+          sticky_hover_ = false;
+        }
+      } else {
+        sticky_hover_ = !sticky_hover_;
+      }
+
+      finished = true;
+    }
+  }
+
+  if (!finished) {
+    if (scroll_mode_) {
+      scroll_mode_ = false;
+
+      SetScrollSpeed(0, 0);
+
+      SetCursor(wxCURSOR_ARROW);
+    } else if (event.GetPosition().x < GetSize().GetWidth() / 6 ||
+               event.GetPosition().x > 5 * GetSize().GetWidth() / 6 ||
+               event.GetPosition().y < GetSize().GetHeight() / 6 ||
+               event.GetPosition().y > 5 * GetSize().GetHeight() / 6) {
+      scroll_mode_ = true;
+
+      EvaluateScroll(event.GetPosition());
+
+      SetCursor(wxCURSOR_CROSS);
+    } else {
+      sticky_hover_ = false;
+    }
+  }
+}
+
+void SubwayMap::OnTimer(wxTimerEvent &event) {
+  SetZoomPos({zoom_x_ + scroll_x_, zoom_y_ + scroll_y_});
+  Refresh();
+}
+
+void SubwayMap::OnZoomSlide(wxCommandEvent &event) {
+  double new_zoom = 1.0 + 0.25 * zoom_slider_->GetValue();
+
+  if (new_zoom != zoom_) {
+    SetZoom(new_zoom, {GetSize().GetWidth() / 2, GetSize().GetHeight() / 2});
   }
+}
 
-  rendered_ = wxBitmap(
-      map_image_
-          .Scale(render_width_, render_height_, wxIMAGE_QUALITY_BILINEAR)
-          .Size(panel_size, {render_x_, render_y_}, 255, 255, 255));
+void SubwayMap::OnClickHelp(wxCommandEvent &event) {
+  wxMessageBox(
+      "Zoom in/out using the mouse wheel, Ctrl +/-, or the slider in the "
+      "corner.\nClick on a side of the screen to start panning. It will follow "
+      "your mouse. Click again to stop.\nHover over a door to see the "
+      "requirements to open it.\nHover over a warp or active painting to see "
+      "what it is connected to.\nFor one-way connections, there will be a "
+      "circle at the exit.\nCircles represent paintings.\nA red circle means "
+      "that the painting is locked by a door.\nA blue circle means painting "
+      "shuffle is enabled and the painting has not been checked yet.\nA black "
+      "circle means the painting is not a warp.\nA green circle means that the "
+      "painting is a warp.\nPainting exits will be indicated with an X.\nClick "
+      "on a door or warp to make the popup stick until you click again.",
+      "Subway Map Help");
+}
+
+void SubwayMap::Redraw() {
+  rendered_ = wxBitmap(map_image_);
 
   wxMemoryDC dc;
   dc.SelectObject(rendered_);
 
+  wxGCDC gcdc(dc);
+
+  std::map<std::string, std::string> painting_mapping = AP_GetPaintingMapping();
+
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     ItemDrawType draw_type = ItemDrawType::kNone;
     const wxBrush *brush_color = wxGREY_BRUSH;
-    std::optional<wxColour> shade_color;
+    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
+
+    if (AP_HasEarlyColorHallways() &&
+        subway_item.special == "early_color_hallways") {
+      draw_type = ItemDrawType::kOwl;
+      brush_color = wxGREEN_BRUSH;
+    } else if (subway_item.special == "starting_room_overhead") {
+      // Do not draw.
+    } else if (AP_IsColorShuffle() && subway_item.special &&
+               subway_item.special->starts_with("color_")) {
+      std::string color_name = subway_item.special->substr(6);
+      LingoColor lingo_color = GetLingoColorForString(color_name);
+      int color_item_id = GD_GetItemIdForColor(lingo_color);
 
-    if (subway_item.door) {
       draw_type = ItemDrawType::kBox;
-
-      if (IsDoorOpen(*subway_item.door)) {
-        if (!subway_item.paintings.empty()) {
-          draw_type = ItemDrawType::kOwl;
-        } else {
+      if (AP_HasItemSafe(color_item_id)) {
+        brush_color = wxGREEN_BRUSH;
+      } else {
+        brush_color = wxRED_BRUSH;
+      }
+    } else if (subway_item.special == "sun_painting") {
+      if (!AP_IsPilgrimageEnabled()) {
+        draw_type = ItemDrawType::kOwl;
+        if (IsDoorOpen(*subway_item.door)) {
           brush_color = wxGREEN_BRUSH;
+        } else {
+          brush_color = wxRED_BRUSH;
         }
+      }
+    } else if (subway_item.sunwarp &&
+               subway_item.sunwarp->type == SubwaySunwarpType::kFinal &&
+               AP_IsPilgrimageEnabled()) {
+      draw_type = ItemDrawType::kBox;
+
+      if (IsPilgrimageDoable()) {
+        brush_color = wxGREEN_BRUSH;
       } else {
         brush_color = wxRED_BRUSH;
       }
-    } else if (!subway_item.paintings.empty()) {
-      if (AP_IsPaintingShuffle()) {
-        bool has_checked_painting = false;
-        bool has_unchecked_painting = false;
-        bool has_mapped_painting = false;
-
-        for (const std::string &painting_id : subway_item.paintings) {
-          if (checked_paintings_.count(painting_id)) {
-            has_checked_painting = true;
-
-            if (AP_GetPaintingMapping().count(painting_id)) {
-              has_mapped_painting = true;
-            }
-          } else {
-            has_unchecked_painting = true;
-          }
+    } else if (subway_item.painting) {
+      if (subway_door && !IsDoorOpen(*subway_door)) {
+        draw_type = ItemDrawType::kOwl;
+        brush_color = wxRED_BRUSH;
+      } else if (AP_IsPaintingShuffle()) {
+        if (!checked_paintings_.count(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwl;
+          brush_color = wxBLUE_BRUSH;
+        } else if (painting_mapping.count(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwl;
+          brush_color = wxGREEN_BRUSH;
+        } else if (AP_IsPaintingMappedTo(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwlExit;
+          brush_color = wxGREEN_BRUSH;
         }
-
-        if (has_unchecked_painting || has_mapped_painting) {
+      } else if (subway_item.HasWarps()) {
+        brush_color = wxGREEN_BRUSH;
+        if (!subway_item.exits.empty()) {
+          draw_type = ItemDrawType::kOwlExit;
+        } else {
           draw_type = ItemDrawType::kOwl;
-
-          if (has_unchecked_painting) {
-            if (has_checked_painting) {
-              shade_color = wxColour(255, 255, 0, 100);
-            } else {
-              shade_color = wxColour(100, 100, 100, 100);
-            }
-          }
         }
-      } else if (!subway_item.tags.empty()) {
-        draw_type = ItemDrawType::kOwl;
+      }
+    } else if (subway_door) {
+      draw_type = ItemDrawType::kBox;
+
+      if (IsDoorOpen(*subway_door)) {
+        brush_color = wxGREEN_BRUSH;
+      } else {
+        brush_color = wxRED_BRUSH;
       }
     }
 
-    int real_area_x =
-        render_x_ + subway_item.x * render_width_ / image_size.GetWidth();
-    int real_area_y =
-        render_y_ + subway_item.y * render_width_ / image_size.GetWidth();
+    wxPoint real_area_pos = {subway_item.x, subway_item.y};
 
     int real_area_size =
-        render_width_ *
-        (draw_type == ItemDrawType::kOwl ? OWL_ACTUAL_SIZE : AREA_ACTUAL_SIZE) /
-        image_size.GetWidth();
-    if (real_area_size == 0) {
-      real_area_size = 1;
-    }
+        (draw_type == ItemDrawType::kOwl ? OWL_ACTUAL_SIZE : AREA_ACTUAL_SIZE);
 
     if (draw_type == ItemDrawType::kBox) {
-      dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 1));
-      dc.SetBrush(*brush_color);
-      dc.DrawRectangle({real_area_x, real_area_y},
-                       {real_area_size, real_area_size});
-    } else if (draw_type == ItemDrawType::kOwl) {
-      wxBitmap owl_bitmap = wxBitmap(
-          owl_image_.Scale(real_area_size, real_area_size,
-                           wxIMAGE_QUALITY_BILINEAR));
-      dc.DrawBitmap(owl_bitmap, {real_area_x, real_area_y});
+      gcdc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 1));
+      gcdc.SetBrush(*brush_color);
+
+      if (subway_item.tilted) {
+        constexpr int AREA_TILTED_SIDE =
+            static_cast<int>(AREA_ACTUAL_SIZE / 1.41421356237);
+        const wxPoint poly_points[] = {{AREA_TILTED_SIDE, 0},
+                                       {2 * AREA_TILTED_SIDE, AREA_TILTED_SIDE},
+                                       {AREA_TILTED_SIDE, 2 * AREA_TILTED_SIDE},
+                                       {0, AREA_TILTED_SIDE}};
+        gcdc.DrawPolygon(4, poly_points, subway_item.x, subway_item.y);
+      } else {
+        gcdc.DrawRectangle(real_area_pos, {real_area_size, real_area_size});
+      }
+    } else if (draw_type == ItemDrawType::kOwl || draw_type == ItemDrawType::kOwlExit) {
+      gcdc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 1));
+      gcdc.SetBrush(*brush_color);
+      gcdc.DrawCircle(real_area_pos, PAINTING_RADIUS);
+
+      if (draw_type == ItemDrawType::kOwlExit) {
+        gcdc.DrawLine(subway_item.x - PAINTING_EXIT_RADIUS,
+                      subway_item.y - PAINTING_EXIT_RADIUS,
+                      subway_item.x + PAINTING_EXIT_RADIUS,
+                      subway_item.y + PAINTING_EXIT_RADIUS);
+        gcdc.DrawLine(subway_item.x + PAINTING_EXIT_RADIUS,
+                      subway_item.y - PAINTING_EXIT_RADIUS,
+                      subway_item.x - PAINTING_EXIT_RADIUS,
+                      subway_item.y + PAINTING_EXIT_RADIUS);
+      }
     }
   }
 }
 
-quadtree::Box<float> SubwayMap::GetItemBox::operator()(const int& id) const {
+void SubwayMap::SetUpHelpButton() {
+  help_button_->SetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord,
+                        wxDefaultCoord, wxSIZE_AUTO);
+  help_button_->SetPosition({
+      GetSize().GetWidth() - help_button_->GetSize().GetWidth() - 15,
+      15,
+  });
+}
+
+void SubwayMap::EvaluateScroll(wxPoint pos) {
+  int scroll_x;
+  int scroll_y;
+  if (pos.x < GetSize().GetWidth() / 9) {
+    scroll_x = 20;
+  } else if (pos.x < GetSize().GetWidth() / 6) {
+    scroll_x = 5;
+  } else if (pos.x > 8 * GetSize().GetWidth() / 9) {
+    scroll_x = -20;
+  } else if (pos.x > 5 * GetSize().GetWidth() / 6) {
+    scroll_x = -5;
+  } else {
+    scroll_x = 0;
+  }
+  if (pos.y < GetSize().GetHeight() / 9) {
+    scroll_y = 20;
+  } else if (pos.y < GetSize().GetHeight() / 6) {
+    scroll_y = 5;
+  } else if (pos.y > 8 * GetSize().GetHeight() / 9) {
+    scroll_y = -20;
+  } else if (pos.y > 5 * GetSize().GetHeight() / 6) {
+    scroll_y = -5;
+  } else {
+    scroll_y = 0;
+  }
+
+  SetScrollSpeed(scroll_x, scroll_y);
+}
+
+void SubwayMap::EvaluateHover() {
+  hovered_item_ = actual_hover_;
+
+  if (hovered_item_) {
+    // Note that these requirements are duplicated on OnMouseClick so that it
+    // knows when an item has a hover effect.
+    const SubwayItem &subway_item = GD_GetSubwayItem(*hovered_item_);
+    std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
+
+    if (subway_door && !GetDoorRequirements(*subway_door).empty()) {
+      report_popup_->SetDoorId(*subway_door);
+
+      wxPoint popupPos =
+          MapPosToRenderPos({subway_item.x + AREA_ACTUAL_SIZE / 2,
+                             subway_item.y + AREA_ACTUAL_SIZE / 2});
+
+      report_popup_->SetClientSize(
+          report_popup_->GetVirtualSize().GetWidth(),
+          std::min(GetSize().GetHeight(),
+                   report_popup_->GetVirtualSize().GetHeight()));
+
+      if (popupPos.x + report_popup_->GetSize().GetWidth() >
+          GetSize().GetWidth()) {
+        popupPos.x = GetSize().GetWidth() - report_popup_->GetSize().GetWidth();
+      }
+      if (popupPos.y + report_popup_->GetSize().GetHeight() >
+          GetSize().GetHeight()) {
+        popupPos.y =
+            GetSize().GetHeight() - report_popup_->GetSize().GetHeight();
+      }
+      report_popup_->SetPosition(popupPos);
+
+      report_popup_->Show();
+    } else {
+      report_popup_->Reset();
+      report_popup_->Hide();
+    }
+  } else {
+    report_popup_->Reset();
+    report_popup_->Hide();
+  }
+
+  Refresh();
+}
+
+wxPoint SubwayMap::MapPosToRenderPos(wxPoint pos) const {
+  return {static_cast<int>(pos.x * render_width_ * zoom_ /
+                               map_image_.GetSize().GetWidth() +
+                           zoom_x_),
+          static_cast<int>(pos.y * render_width_ * zoom_ /
+                               map_image_.GetSize().GetWidth() +
+                           zoom_y_)};
+}
+
+wxPoint SubwayMap::MapPosToVirtualPos(wxPoint pos) const {
+  return {static_cast<int>(pos.x * render_width_ * zoom_ /
+                           map_image_.GetSize().GetWidth()),
+          static_cast<int>(pos.y * render_width_ * zoom_ /
+                           map_image_.GetSize().GetWidth())};
+}
+
+wxPoint SubwayMap::RenderPosToMapPos(wxPoint pos) const {
+  return {
+      std::clamp(static_cast<int>((pos.x - zoom_x_) * map_image_.GetWidth() /
+                                  render_width_ / zoom_),
+                 0, map_image_.GetWidth() - 1),
+      std::clamp(static_cast<int>((pos.y - zoom_y_) * map_image_.GetWidth() /
+                                  render_width_ / zoom_),
+                 0, map_image_.GetHeight() - 1)};
+}
+
+void SubwayMap::SetZoomPos(wxPoint pos) {
+  if (render_width_ * zoom_ <= GetSize().GetWidth()) {
+    zoom_x_ = (GetSize().GetWidth() - render_width_ * zoom_) / 2;
+  } else {
+    zoom_x_ = std::clamp(
+        pos.x, GetSize().GetWidth() - static_cast<int>(render_width_ * zoom_),
+        0);
+  }
+  if (render_height_ * zoom_ <= GetSize().GetHeight()) {
+    zoom_y_ = (GetSize().GetHeight() - render_height_ * zoom_) / 2;
+  } else {
+    zoom_y_ = std::clamp(
+        pos.y, GetSize().GetHeight() - static_cast<int>(render_height_ * zoom_),
+        0);
+  }
+}
+
+void SubwayMap::SetScrollSpeed(int scroll_x, int scroll_y) {
+  bool should_timer = (scroll_x != 0 || scroll_y != 0);
+  if (should_timer != scroll_timer_->IsRunning()) {
+    if (should_timer) {
+      scroll_timer_->Start(1000 / 60);
+    } else {
+      scroll_timer_->Stop();
+    }
+  }
+
+  scroll_x_ = scroll_x;
+  scroll_y_ = scroll_y;
+}
+
+void SubwayMap::SetZoom(double zoom, wxPoint static_point) {
+  wxPoint map_pos = RenderPosToMapPos(static_point);
+  zoom_ = zoom;
+
+  wxPoint virtual_pos = MapPosToVirtualPos(map_pos);
+  SetZoomPos(-(virtual_pos - static_point));
+
+  Refresh();
+
+  zoom_slider_->SetValue((zoom - 1.0) / 0.25);
+}
+
+std::optional<int> SubwayMap::GetRealSubwayDoor(const SubwayItem subway_item) {
+  if (AP_IsSunwarpShuffle() && subway_item.sunwarp &&
+      subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
+    int sunwarp_index = subway_item.sunwarp->dots - 1;
+    if (subway_item.sunwarp->type == SubwaySunwarpType::kExit) {
+      sunwarp_index += 6;
+    }
+
+    for (const auto &[start_index, mapping] : sunwarp_mapping_) {
+      if (start_index == sunwarp_index || mapping.exit_index == sunwarp_index) {
+        return GD_GetSunwarpDoors().at(mapping.dots - 1);
+      }
+    }
+  }
+
+  return subway_item.door;
+}
+
+quadtree::Box<float> SubwayMap::GetItemBox::operator()(const int &id) const {
   const SubwayItem &subway_item = GD_GetSubwayItem(id);
-  return {static_cast<float>(subway_item.x), static_cast<float>(subway_item.y),
-          AREA_ACTUAL_SIZE, AREA_ACTUAL_SIZE};
+  if (subway_item.painting) {
+    return {static_cast<float>(subway_item.x) - PAINTING_RADIUS,
+            static_cast<float>(subway_item.y) - PAINTING_RADIUS,
+            PAINTING_RADIUS * 2, PAINTING_RADIUS * 2};
+  } else {
+    return {static_cast<float>(subway_item.x),
+            static_cast<float>(subway_item.y), AREA_ACTUAL_SIZE,
+            AREA_ACTUAL_SIZE};
+  }
 }