1 files changed, 99 insertions, 107 deletions

@@ -9,7 +9,6 @@
 #include "area_popup.h"
 #include "game_data.h"
 #include "global.h"
-#include "godot_variant.h"
 #include "ipc_state.h"
 #include "tracker_config.h"
 #include "tracker_state.h"
@@ -44,58 +43,46 @@ TrackerPanel::TrackerPanel(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
     areas_.push_back(area);
   }
 
+  Resize();
   Redraw();
 
   Bind(wxEVT_PAINT, &TrackerPanel::OnPaint, this);
   Bind(wxEVT_MOTION, &TrackerPanel::OnMouseMove, this);
 }
 
-void TrackerPanel::UpdateIndicators() {
-  if (panels_mode_ && !savedata_path_) {
-    solved_panels_ = IPC_GetSolvedPanels();
-  }
-
-  for (AreaIndicator &area : areas_) {
-    area.popup->UpdateIndicators();
-  }
-
-  Redraw();
-}
-
-void TrackerPanel::SetPanelsMode() { panels_mode_ = true; }
-
-void TrackerPanel::SetSavedataPath(std::string savedata_path) {
-  if (!savedata_path_) {
-    wxButton *refresh_button =
-        new wxButton(this, wxID_ANY, "Refresh", {15, 15});
-    refresh_button->Bind(wxEVT_BUTTON, &TrackerPanel::OnRefreshSavedata, this);
-  }
-
-  savedata_path_ = savedata_path;
-  panels_mode_ = true;
-
-  RefreshSavedata();
-}
+void TrackerPanel::UpdateIndicators(bool reset) {
+  if (reset) {
+    for (AreaIndicator &area : areas_) {
+      const MapArea &map_area = GD_GetMapArea(area.area_id);
+
+      if ((!AP_IsLocationVisible(map_area.classification) ||
+           IsAreaPostgame(area.area_id)) &&
+          !(map_area.hunt &&
+            GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) &&
+          !(map_area.has_single_panel &&
+            GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS) &&
+          !(AP_IsPaintingShuffle() && !map_area.paintings.empty())) {
+        area.active = false;
+      } else {
+        area.active = true;
+      }
 
-void TrackerPanel::RefreshSavedata() {
-  solved_panels_.clear();
+      area.popup->ResetIndicators();
+    }
 
-  GodotVariant godot_variant = ParseGodotFile(*savedata_path_);
-  for (const GodotVariant &panel_node : godot_variant.AsArray()) {
-    const std::vector<GodotVariant> &fields = panel_node.AsArray();
-    if (fields[1].AsBool()) {
-      const std::vector<std::string> &nodepath = fields[0].AsNodePath();
-      std::string key = fmt::format("{}/{}", nodepath[3], nodepath[4]);
-      solved_panels_.insert(key);
+    Resize();
+  } else {
+    for (AreaIndicator &area : areas_) {
+      area.popup->UpdateIndicators();
     }
   }
 
-  UpdateIndicators();
-  Refresh();
+  Redraw();
 }
 
 void TrackerPanel::OnPaint(wxPaintEvent &event) {
   if (GetSize() != rendered_.GetSize()) {
+    Resize();
     Redraw();
   }
 
@@ -103,10 +90,13 @@ void TrackerPanel::OnPaint(wxPaintEvent &event) {
   dc.DrawBitmap(rendered_, 0, 0);
 
   std::optional<std::tuple<int, int>> player_position;
-  if (IPC_IsConnected()) {
-    player_position = IPC_GetPlayerPosition();
-  } else {
-    player_position = AP_GetPlayerPosition();
+  if (GetTrackerConfig().track_position)
+  {
+    if (IPC_IsConnected()) {
+      player_position = IPC_GetPlayerPosition();
+    } else {
+      player_position = AP_GetPlayerPosition();
+    }
   }
 
   if (player_position.has_value()) {
@@ -142,12 +132,8 @@ void TrackerPanel::OnMouseMove(wxMouseEvent &event) {
   event.Skip();
 }
 
-void TrackerPanel::OnRefreshSavedata(wxCommandEvent &event) {
-  RefreshSavedata();
-}
-
-void TrackerPanel::Redraw() {
-  wxSize panel_size = GetSize();
+void TrackerPanel::Resize() {
+  wxSize panel_size = GetClientSize();
   wxSize image_size = map_image_.GetSize();
 
   int final_x = 0;
@@ -166,7 +152,7 @@ void TrackerPanel::Redraw() {
     final_x = (panel_size.GetWidth() - final_width) / 2;
   }
 
-  rendered_ = wxBitmap(
+  scaled_map_ = wxBitmap(
       map_image_.Scale(final_width, final_height, wxIMAGE_QUALITY_NORMAL)
           .Size(panel_size, {final_x, final_y}, 0, 0, 0));
 
@@ -181,30 +167,61 @@ void TrackerPanel::Redraw() {
       wxBitmap(player_image_.Scale(player_width > 0 ? player_width : 1,
                                    player_height > 0 ? player_height : 1));
 
+  real_area_size_ = final_width * AREA_EFFECTIVE_SIZE / image_size.GetWidth();
+
+  for (AreaIndicator &area : areas_) {
+    const MapArea &map_area = GD_GetMapArea(area.area_id);
+
+    int real_area_x = final_x + (map_area.map_x - (AREA_EFFECTIVE_SIZE / 2)) *
+                                    final_width / image_size.GetWidth();
+    int real_area_y = final_y + (map_area.map_y - (AREA_EFFECTIVE_SIZE / 2)) *
+                                    final_width / image_size.GetWidth();
+
+    area.real_x1 = real_area_x;
+    area.real_x2 = real_area_x + real_area_size_;
+    area.real_y1 = real_area_y;
+    area.real_y2 = real_area_y + real_area_size_;
+
+    int popup_x =
+        final_x + map_area.map_x * final_width / image_size.GetWidth();
+    int popup_y =
+        final_y + map_area.map_y * final_width / image_size.GetWidth();
+
+    area.popup->SetClientSize(
+        area.popup->GetFullWidth(),
+        std::min(panel_size.GetHeight(), area.popup->GetFullHeight()));
+
+    if (area.popup->GetSize().GetHeight() > panel_size.GetHeight()) {
+      area.popup->SetSize(area.popup->GetSize().GetWidth(),
+                          panel_size.GetHeight());
+    } 
+
+    if (popup_x + area.popup->GetSize().GetWidth() > panel_size.GetWidth()) {
+      popup_x = panel_size.GetWidth() - area.popup->GetSize().GetWidth();
+    }
+    if (popup_y + area.popup->GetSize().GetHeight() > panel_size.GetHeight()) {
+      popup_y = panel_size.GetHeight() - area.popup->GetSize().GetHeight();
+    }
+    area.popup->SetPosition({popup_x, popup_y});
+  }
+}
+
+void TrackerPanel::Redraw() {
+  rendered_ = scaled_map_;
+
   wxMemoryDC dc;
   dc.SelectObject(rendered_);
 
-  int real_area_size =
-      final_width * AREA_EFFECTIVE_SIZE / image_size.GetWidth();
   int actual_border_size =
-      real_area_size * AREA_BORDER_SIZE / AREA_EFFECTIVE_SIZE;
+      real_area_size_ * AREA_BORDER_SIZE / AREA_EFFECTIVE_SIZE;
   const wxPoint upper_left_triangle[] = {
-      {0, 0}, {0, real_area_size}, {real_area_size, 0}};
-  const wxPoint lower_right_triangle[] = {{0, real_area_size - 1},
-                                          {real_area_size - 1, 0},
-                                          {real_area_size, real_area_size}};
+      {0, 0}, {0, real_area_size_}, {real_area_size_, 0}};
+  const wxPoint lower_right_triangle[] = {{0, real_area_size_ - 1},
+                                          {real_area_size_ - 1, 0},
+                                          {real_area_size_, real_area_size_}};
 
   for (AreaIndicator &area : areas_) {
     const MapArea &map_area = GD_GetMapArea(area.area_id);
-    if (panels_mode_) {
-      area.active = map_area.has_single_panel;
-    } else if (!AP_IsLocationVisible(map_area.classification) &&
-               !(map_area.hunt && GetTrackerConfig().show_hunt_panels) &&
-               !(AP_IsPaintingShuffle() && !map_area.paintings.empty())) {
-      area.active = false;
-    } else {
-      area.active = true;
-    }
 
     if (!area.active) {
       continue;
@@ -216,19 +233,15 @@ void TrackerPanel::Redraw() {
       bool has_unchecked = false;
       if (IsLocationWinCondition(section)) {
         has_unchecked = !AP_HasReachedGoal();
-      } else if (panels_mode_) {
-        if (section.single_panel) {
-          const Panel &panel = GD_GetPanel(*section.single_panel);
-          if (panel.non_counting) {
-            has_unchecked = !AP_HasCheckedGameLocation(section.ap_location_id);
-          } else {
-            has_unchecked = !GetSolvedPanels().contains(panel.nodepath);
-          }
-        }
-      } else if (AP_IsLocationVisible(section.classification)) {
+      } else if (AP_IsLocationVisible(section.classification) &&
+                 !IsLocationPostgame(section.ap_location_id)) {
         has_unchecked = !AP_HasCheckedGameLocation(section.ap_location_id);
-      } else if (section.hunt && GetTrackerConfig().show_hunt_panels) {
-        has_unchecked = !AP_HasCheckedHuntPanel(section.ap_location_id);
+      } else if ((section.hunt && GetTrackerConfig().visible_panels ==
+                                      TrackerConfig::kHUNT_PANELS) ||
+                 (section.single_panel && GetTrackerConfig().visible_panels ==
+                                              TrackerConfig::kALL_PANELS)) {
+        has_unchecked =
+            !AP_IsPanelSolved(GD_GetPanel(*section.single_panel).solve_index);
       }
 
       if (has_unchecked) {
@@ -240,8 +253,12 @@ void TrackerPanel::Redraw() {
       }
     }
 
-    if (AP_IsPaintingShuffle() && !panels_mode_) {
+    if (AP_IsPaintingShuffle()) {
       for (int painting_id : map_area.paintings) {
+        if (IsPaintingPostgame(painting_id)) {
+          continue;
+        }
+
         const PaintingExit &painting = GD_GetPaintingExit(painting_id);
         bool reachable = IsPaintingReachable(painting_id);
         if (!reachable || !AP_IsPaintingChecked(painting.internal_id)) {
@@ -254,10 +271,8 @@ void TrackerPanel::Redraw() {
       }
     }
 
-    int real_area_x = final_x + (map_area.map_x - (AREA_EFFECTIVE_SIZE / 2)) *
-                                    final_width / image_size.GetWidth();
-    int real_area_y = final_y + (map_area.map_y - (AREA_EFFECTIVE_SIZE / 2)) *
-                                    final_width / image_size.GetWidth();
+    int real_area_x = area.real_x1;
+    int real_area_y = area.real_y1;
 
     if (has_reachable_unchecked && has_unreachable_unchecked &&
         GetTrackerConfig().hybrid_areas) {
@@ -271,7 +286,7 @@ void TrackerPanel::Redraw() {
       dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, actual_border_size));
       dc.SetBrush(*wxTRANSPARENT_BRUSH);
       dc.DrawRectangle({real_area_x, real_area_y},
-                       {real_area_size, real_area_size});
+                       {real_area_size_, real_area_size_});
 
     } else {
       const wxBrush *brush_color = wxGREY_BRUSH;
@@ -286,30 +301,7 @@ void TrackerPanel::Redraw() {
       dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, actual_border_size));
       dc.SetBrush(*brush_color);
       dc.DrawRectangle({real_area_x, real_area_y},
-                       {real_area_size, real_area_size});
+                       {real_area_size_, real_area_size_});
     }
-
-    area.real_x1 = real_area_x;
-    area.real_x2 = real_area_x + real_area_size;
-    area.real_y1 = real_area_y;
-    area.real_y2 = real_area_y + real_area_size;
-
-    int popup_x =
-        final_x + map_area.map_x * final_width / image_size.GetWidth();
-    int popup_y =
-        final_y + map_area.map_y * final_width / image_size.GetWidth();
-
-    area.popup->SetClientSize(
-        area.popup->GetVirtualSize().GetWidth(),
-        std::min(panel_size.GetHeight(),
-                 area.popup->GetVirtualSize().GetHeight()));
-
-    if (popup_x + area.popup->GetSize().GetWidth() > panel_size.GetWidth()) {
-      popup_x = panel_size.GetWidth() - area.popup->GetSize().GetWidth();
-    }
-    if (popup_y + area.popup->GetSize().GetHeight() > panel_size.GetHeight()) {
-      popup_y = panel_size.GetHeight() - area.popup->GetSize().GetHeight();
-    }
-    area.popup->SetPosition({popup_x, popup_y});
   }
 }