61 files changed, 2700 insertions, 1174 deletions

@@ -16,3 +16,6 @@
 [submodule "vendor/vcpkg"]
         path = vendor/vcpkg
         url = https://github.com/Microsoft/vcpkg.git
+[submodule "vendor/websocketpp"]
+        path = vendor/websocketpp
+        url = https://github.com/zaphoyd/websocketpp
@@ -1,5 +1,90 @@
 # lingo-ap-tracker Releases
 
+## v2.0.2 - 2025-05-24
+
+- Fixed issue connecting to the Archipelago 0.6.2 RC server.
+
+Download:
+[lingo-ap-tracker-v2.0.2-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.2-win64.zip)<br/>
+Source: [v2.0.2](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v2.0.2)
+
+## v2.0.1 - 2025-04-06
+
+- The tracker now assumes postgame shuffle is enabled when the flag is not
+  present in slot data (as is the case with Archipelago 0.6.1 and earlier).
+  Players who have postgame shuffle disabled will unfortunately see locations
+  that are not in their world, until this problem can be fixed.
+
+Download:
+[lingo-ap-tracker-v2.0.1-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.1-win64.zip)<br/>
+Source: [v2.0.1](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v2.0.1)
+
+## v2.0.0 - 2025-04-01
+
+- Compatibility update for Archipelago 0.6.0.
+
+Download:
+[lingo-ap-tracker-v2.0.0-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.0-win64.zip)<br/>
+Source: [v2.0.0](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v2.0.0)
+
+## v1.0.0 - 2025-03-21
+
+After almost two years of development, we have finally hit version 1!
+
+- The subway map now uses Kinrah's updated map image, including fully separated
+  paintings for places like The Wondrous and Orange Tower Sixth Floor, as well
+  as indicators for the color items.
+- Paintings have friendly names now instead of the internal game IDs. They are
+  also distinguished from regular checks by using an owl icon instead of an eye.
+- The tracker is now able to read your solved panel state from the multiworld
+  (requires v5.3.0 of the client). This obsoletes save file parsing and
+  receiving panel solves by connecting to the game.
+- Numerous optimizations to reachability detection and rendering.
+- Added a pane that shows all items received, similar to the web tracker.
+- Added a pane that shows your currently revealed painting mapping, as well as a
+  button that reveals it all immediately.
+- Added a pane that shows your slot options.
+- Postgame shuffle being disabled is handled properly now, and removed locations
+  are no longer shown.
+- Improved support for high-DPI screens. The tracker should no longer appear
+  "blurry" on a high-DPI screen, and should also be able to react properly to
+  being moved between screens with different DPIs.
+- The update checker is now able to download and install tracker updates in
+  place.
+
+Download:
+[lingo-ap-tracker-v1.0.0-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v1.0.0-win64.zip)<br/>
+Source: [v1.0.0](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v1.0.0)
+
+## v0.12.3 - 2025-03-03
+
+- Fixed issue with non-ASCII connection details.
+
+Download:
+[lingo-ap-tracker-v0.12.3-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.12.3-win64.zip)<br/>
+Source: [v0.12.3](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.12.3)
+
+## v0.12.2 - 2025-02-10
+
+- Added a scrollbar to the subway map access requirement popups.
+- Fixed an issue with a small number of doors having too-strict access
+  requirements in vanilla or panels mode door shuffle.
+
+Download:
+[lingo-ap-tracker-v0.12.2-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.12.2-win64.zip)<br/>
+Source: [v0.12.2](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.12.2)
+
+## v0.12.1 - 2025-01-27
+
+- Fixed sunwarp mapping not showing up on metro map when sunwarp shuffle is
+  enabled.
+- Fixed metro map door requirements sometimes saying you cannot reach areas when
+  you really can.
+
+Download:
+[lingo-ap-tracker-v0.12.1-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.12.1-win64.zip)<br/>
+Source: [v0.12.1](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.12.1)
+
 ## v0.12.0 - 2024-12-20
 
 - The tracker can now connect to a game of Lingo that is running the Archipelago
@@ -1,15 +1,15 @@
-cmake_minimum_required (VERSION 3.1)
+cmake_minimum_required (VERSION 3.20)
 project (lingo_ap_tracker)
 
 if (MSVC)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
 set(CMAKE_WIN32_EXECUTABLE true)
+set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
 endif(MSVC)
 
 find_package(wxWidgets CONFIG REQUIRED)
 find_package(OpenSSL REQUIRED)
 find_package(yaml-cpp REQUIRED)
-find_package(websocketpp REQUIRED)
 find_package(fmt REQUIRED)
 
 include_directories(
@@ -18,7 +18,7 @@ include_directories(
   vendor/asio/asio/include
   vendor/nlohmann
   vendor/valijson/include
-  ${websocketpp_INCLUDE_DIRS}
+  vendor/websocketpp
   vendor/wswrap/include
   ${yaml-cpp_INCLUDE_DIRS}
   ${OpenSSL_INCLUDE_DIRS}
@@ -32,7 +32,7 @@ include_directories(${SYSTEM_INCLUDE_DIR})
 
 link_directories(${openssl_LIBRARY_DIRS})
 
-add_executable(lingo_ap_tracker
+set(SOURCE_FILES
   "src/main.cpp"
   "src/tracker_frame.cpp"
   "src/tracker_panel.cpp"
@@ -48,14 +48,26 @@ add_executable(lingo_ap_tracker
   "src/subway_map.cpp"
   "src/network_set.cpp"
   "src/logger.cpp"
-  "src/godot_variant.cpp"
   "src/ipc_state.cpp"
   "src/ipc_dialog.cpp"
+  "src/report_popup.cpp"
+  "src/updater.cpp"
+  "src/icons.cpp"
+  "src/paintings_pane.cpp"
+  "src/items_pane.cpp"
+  "src/options_pane.cpp"
+  "src/log_dialog.cpp"
   "vendor/whereami/whereami.c"
 )
+
+if (MSVC)
+list(APPEND SOURCE_FILES "src/windows.rc")
+endif(MSVC)
+
+add_executable(lingo_ap_tracker ${SOURCE_FILES})
 set_property(TARGET lingo_ap_tracker PROPERTY CXX_STANDARD 20)
 set_property(TARGET lingo_ap_tracker PROPERTY CXX_STANDARD_REQUIRED ON)
-target_link_libraries(lingo_ap_tracker PRIVATE fmt::fmt OpenSSL::SSL OpenSSL::Crypto websocketpp::websocketpp wx::core wx::base wx::net yaml-cpp::yaml-cpp)
+target_link_libraries(lingo_ap_tracker PRIVATE fmt::fmt OpenSSL::SSL OpenSSL::Crypto wx::core wx::base wx::net yaml-cpp::yaml-cpp)
 
 set(SRC_DIR "${CMAKE_SOURCE_DIR}/assets")
 set(DST_DIR "${CMAKE_BINARY_DIR}/$<CONFIG>/assets")
@@ -25,3 +25,7 @@ To build the app:
 6. (Optional) Build the application in release mode: `cmake --build --preset=x64-release-preset`
 
 LL1.yaml and ids.yaml sometimes receive breaking changes that need to be kept in sync with the tracker. If the application crashes with an unknown error, try making sure that you are using the right versions of those files. In general, the main branch of the tracker will require config files from the latest Archipelago release. Branches may require config files from Archipelago main, or from pending pull requests.
+
+### Using Visual Studio
+
+If you're using Visual Studio on Windows, you can simplify the above process. You can clone the repository directly from Visual Studio, and it will automatically download the submodules as well as configure cmake and build the vcpkg packages. You will still have to do steps 2 and 3 manually. Then, look for the dropdown next to the green arrow and select `lingo_ap_tracker.exe` so that you can build it. You can build in release mode by choosing it from the preset dropdown.
@@ -1 +1 @@
-v0.12.0
\ No newline at end of file
+v2.0.2
\ No newline at end of file
@@ -0,0 +1,31 @@
+version: v2.0.2
+packages:
+  win64:
+    url: "https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v2.0.2-win64.zip"
+    checksum: "dfb2fce2f5b14c09f4af7e7fcf6478e420a070db9fb23f9f9ad196f2db4b7518"
+    files:
+      - fmt.dll
+      - jpeg62.dll
+      - libcrypto-3-x64.dll
+      - liblzma.dll
+      - libpng16.dll
+      - libssl-3-x64.dll
+      - lingo_ap_tracker.exe
+      - pcre2-16.dll
+      - tiff.dll
+      - wxbase32u_net_vc_custom.dll
+      - wxbase32u_vc_custom.dll
+      - wxmsw32u_core_vc_custom.dll
+      - yaml-cpp.dll
+      - zlib1.dll
+      - assets/areas.yaml
+      - assets/checked.png
+      - assets/checked_owl.png
+      - assets/ids.yaml
+      - assets/lingo_map.png
+      - assets/LL1.yaml
+      - assets/owl.png
+      - assets/player.png
+      - assets/subway.png
+      - assets/subway.yaml
+      - assets/unchecked.png
@@ -1,123 +1,117 @@
 ---
-- pos: [1050, 954]
+- pos: [1051, 954]
   room: Starting Room
   door: Back Right Door
 - pos: [986, 1034]
   room: Starting Room
   door: Rhyme Room Entrance
-- pos: [990, 956]
-  special: starting_room_paintings # Early Color Hallways painting is a hardcoded special case
-  paintings:
-    - arrows_painting
-- pos: [905, 841]
+- pos: [996, 964]
+  special: starting_room_overhead
+  painting: arrows_painting
+- pos: [1044, 1012]
+  special: early_color_hallways
+  painting: color_hallways
+- pos: [915, 851]
   room: Hedge Maze
   door: Painting Shortcut
-  paintings:
-    - garden_painting_tower2
+  painting: garden_painting_tower2
   entrances:
     - garden_starting
-- pos: [1066, 841]
+- pos: [1076, 851]
   room: Courtyard
   door: Painting Shortcut
-  paintings:
-    - flower_painting_8
+  painting: flower_painting_8
   entrances:
     - flower_starting
-- pos: [905, 895]
+- pos: [915, 905]
   room: The Wondrous (Doorknob)
   door: Painting Shortcut
-  paintings:
-    - symmetry_painting_a_starter
+  painting: symmetry_painting_a_starter
   entrances:
     - symmetry_starting
-- pos: [1066, 868]
+- pos: [1076, 905]
   room: Outside The Bold
   door: Painting Shortcut
-  paintings:
-    - pencil_painting6
+  painting: pencil_painting6
   entrances:
     - pencil_starting
-- pos: [1066, 895]
+- pos: [1076, 878]
   room: Outside The Undeterred
   door: Painting Shortcut
-  paintings:
-    - blueman_painting_3
+  painting: blueman_painting_3
   entrances:
     - blueman_starting
-- pos: [905, 868]
+- pos: [915, 878]
   room: Outside The Agreeable
   door: Painting Shortcut
-  paintings:
-    - eyes_yellow_painting2
+  painting: eyes_yellow_painting2
   entrances:
     - street_starting
 - pos: [1211, 879]
   room: Hidden Room
   door: Dead End Door
-- pos: [1291, 906]
+- pos: [1292, 906]
   room: Hidden Room
   door: Knight Night Entrance
-- pos: [1103, 980]
+- pos: [1104, 981]
   room: Hidden Room
   door: Seeker Entrance
-- pos: [1173, 980]
+- pos: [1174, 981]
   room: Hidden Room
   door: Rhyme Room Entrance
-- pos: [1116, 939]
-  paintings:
-    - owl_painting
+- pos: [1114, 937]
+  painting: owl_painting
   entrances:
     - owl_hidden
 - pos: [986, 793]
   room: Second Room
   door: Exit Door
-- pos: [798, 584]
+- pos: [799, 584]
   room: Hub Room
   door: Crossroads Entrance
-- pos: [932, 665]
+- pos: [933, 665]
   room: Hub Room
   door: Tenacious Entrance
-- pos: [1361, 578]
+- pos: [1361, 579]
   room: Hub Room
   door: Shortcut to Hedge Maze
-- pos: [1312, 841]
+- pos: [1313, 842]
   room: Hub Room
   door: Near RAT Door
-- pos: [1371, 729]
+- pos: [1372, 729]
   room: Hub Room
   door: Traveled Entrance
-- pos: [1313, 686]
-  paintings:
-    - maze_painting
+- pos: [1312, 696]
+  painting: maze_painting
   exits:
     - green_owl
     - green_numbers
-- pos: [1172, 760]
+- pos: [1174, 761]
   sunwarp:
     dots: 1
     type: enter
 - pos: [1302, 638]
   room: Outside The Undeterred
   door: Fours
-- pos: [1243, 819]
+- pos: [1243, 820]
   room: Outside The Undeterred
   door: Fours
-- pos: [1276, 819]
+- pos: [1276, 820]
   room: Number Hunt
   door: Eights
-- pos: [1263, 867]
-  paintings:
-    - smile_painting_6
+- pos: [1253, 889]
+  painting: smile_painting_6
   entrances:
     - smiley_deadend
-- pos: [1012, 1086]
+- pos: [1013, 1087]
   sunwarp:
     dots: 6
     type: final
-- pos: [938, 1002]
+- pos: [948, 1012]
   room: Pilgrim Antechamber
   door: Sun Painting
   special: sun_painting
+  painting: pilgrim_painting2
 - pos: [1053, 1090]
   invisible: true
   special: sun_painting_exit
@@ -136,7 +130,7 @@
 - pos: [932, 477]
   room: Crossroads
   door: Tenacious Entrance
-- pos: [638, 477]
+- pos: [509, 477]
   room: Crossroads
   door: Discerning Entrance
 - pos: [905, 290]
@@ -145,15 +139,14 @@
 - pos: [894, 423]
   room: Crossroads
   door: Words Sword Door
-- pos: [632, 643]
+- pos: [718, 557]
   room: Crossroads
   door: Eye Wall
-- pos: [638, 520]
+- pos: [509, 434]
   room: Crossroads
   door: Roof Access
-- pos: [756, 400]
-  paintings:
-    - smile_painting_4
+- pos: [712, 514]
+  painting: smile_painting_4
   entrances:
     - smiley_crossroads
 - pos: [878, 509]
@@ -168,13 +161,12 @@
   door: Exit
 - pos: [986, 290]
   room: Number Hunt
-  door: Eights
+  door: Nines
 - pos: [954, 247]
   room: Amen Name Area
   door: Exit
-- pos: [954, 222]
-  paintings:
-    - west_afar
+- pos: [985, 235]
+  painting: west_afar
 - pos: [986, 697]
   room: The Tenacious
   door: Shortcut to Hub Room
@@ -205,21 +197,19 @@
 - pos: [1216, 525]
   room: Outside The Agreeable
   door: Agreeable Entrance
-- pos: [1138, 287]
-  paintings:
-    - eyes_yellow_painting
+- pos: [1156, 299]
+  painting: eyes_yellow_painting
   exits:
     - street_starting
 - pos: [1088, 385]
   sunwarp:
     dots: 6
     type: enter
-- pos: [1195, 450]
+- pos: [1195, 445]
   room: Compass Room
   door: Lookout Entrance
-- pos: [1214, 457]
-  paintings:
-    - pencil_painting7
+- pos: [1226, 481]
+  painting: pencil_painting7
   entrances:
     - pencil_compass
 - pos: [1196, 417]
@@ -248,9 +238,8 @@
 - pos: [1714, 434]
   room: Hedge Maze
   door: Observant Entrance
-- pos: [1477, 343]
-  paintings:
-    - garden_painting_tower
+- pos: [1526, 401]
+  painting: garden_painting_tower
   exits:
     - garden_starting
 - pos: [1565, 311]
@@ -262,45 +251,48 @@
 - pos: [1414, 209]
   room: The Observant
   door: Backside Door
-- pos: [1624, 188]
+- pos: [1592, 188]
   room: The Observant
   door: Stairs
-- pos: [1667, 686]
+- pos: [1694, 659]
   room: The Incomparable
   door: Eight Door
-- pos: [1784, 569]
-  paintings:
-    - crown_painting
+- pos: [1799, 583]
+  painting: crown_painting
   exits:
     - crown_tower6
-- pos: [1653, 717]
-  paintings:
-    - eight_painting2
+- pos: [1644, 685]
+  painting: eight_painting2
   entrances:
     - eight_alcove
-- pos: [1653, 662]
-  paintings:
-    - eight_painting
+- pos: [1660, 664]
+  painting: eight_painting
   exits:
     - eight_alcove
-- pos: [697, 1471]
+- pos: [695, 1471]
   room: Orange Tower
   door: Second Floor
-- pos: [633, 1406]
+  tilted: true
+- pos: [631, 1406]
   room: Orange Tower
   door: Third Floor
-- pos: [570, 1343]
+  tilted: true
+- pos: [567, 1341]
   room: Orange Tower
   door: Fourth Floor
-- pos: [504, 1279]
+  tilted: true
+- pos: [502, 1277]
   room: Orange Tower
   door: Fifth Floor
-- pos: [440, 1215]
+  tilted: true
+- pos: [438, 1213]
   room: Orange Tower
   door: Sixth Floor
-- pos: [379, 1153]
+  tilted: true
+- pos: [378, 1152]
   room: Orange Tower
   door: Seventh Floor
+  tilted: true
 - pos: [905, 793]
   room: Orange Tower First Floor
   door: Shortcut to Hub Room
@@ -320,7 +312,7 @@
 - pos: [722, 1439]
   tags:
     - tower2_undeterred
-- pos: [533, 1375]
+- pos: [549, 1375]
   tags:
     - tower3_tower3
 - pos: [662, 1375]
@@ -377,10 +369,10 @@
 - pos: [1173, 1248]
   room: Orange Tower Third Floor
   door: Rhyme Room Entrance
-- pos: [1270, 1231]
-  paintings:
-    - arrows_painting_6
-    - flower_painting_5
+- pos: [1274, 1253]
+  painting: arrows_painting_6
+- pos: [1293, 1234]
+  painting: flower_painting_5
 - pos: [1216, 1216]
   sunwarp:
     dots: 2
@@ -396,77 +388,82 @@
   sunwarp:
     dots: 5
     type: enter
-- pos: [877, 155]
+- pos: [878, 155]
   room: Number Hunt
   door: Eights
-- pos: [844, 134]
-  paintings:
-    - smile_painting_8
+- pos: [862, 144]
+  painting: smile_painting_8
   entrances:
     - smiley_hotcrusts
-- pos: [797, 155]
+- pos: [798, 155]
   sunwarp:
     dots: 2
     type: enter
-- pos: [679, 985]
+- pos: [680, 986]
   room: Number Hunt
   door: Nines
 - pos: [723, 953]
   room: Orange Tower Fifth Floor
   door: Welcome Back
-- pos: [683, 944]
-  paintings:
-    - east_afar
-- pos: [548, 1221]
-  paintings:
-    - hi_solved_painting3
-- pos: [1574, 1425]
-  paintings:
-    - hi_solved_painting2
-- pos: [411, 1186]
-  paintings:
-    - arrows_painting_10
-    - owl_painting_3
-    - clock_painting
-    - scenery_painting_5d_2
-    - symmetry_painting_b_7
-    - panda_painting_2
-    - crown_painting2
-    - colors_painting2
-    - cherry_painting2
-    - hi_solved_painting
+- pos: [690, 937]
+  painting: east_afar
+- pos: [535, 1205]
+  painting: hi_solved_painting3
+- pos: [1574, 1424]
+  painting: hi_solved_painting2
+- pos: [316, 1269]
+  painting: arrows_painting_10
+- pos: [332, 1253]
+  painting: scenery_painting_5d_2
+- pos: [347, 1237]
+  painting: panda_painting_2
   entrances:
-    - owl_tower6
-    - clock_tower6
     - panda_tower6
-    - crown_tower6
-    - apple_tower6
+- pos: [363, 1221]
+  painting: colors_painting2
+- pos: [380, 1205]
+  painting: clock_painting
+  entrances:
+    - clock_tower6
+- pos: [396, 1221]
+  painting: hi_solved_painting
   exits:
     - hi_scientific
-- pos: [349, 1124]
-  paintings:
-    - map_painting2
+- pos: [380, 1237]
+  painting: crown_painting2
+  entrances:
+    - crown_tower6
+- pos: [363, 1253]
+  painting: owl_painting_3
+  entrances:
+    - owl_tower6
+- pos: [347, 1269]
+  painting: symmetry_painting_b_7
+- pos: [332, 1285]
+  painting: cherry_painting2
+  entrances:
+    - apple_tower6
+- pos: [360, 1135]
+  # TODO: there isn't really a spot for this one
+  painting: map_painting2
 - pos: [436, 1159]
   room: Orange Tower Seventh Floor
   door: Mastery
-- pos: [544, 1159]
-  paintings:
-    - arrows_painting_11
+- pos: [535, 1146]
+  painting: arrows_painting_11
 - pos: [498, 284]
   room: Courtyard
   door: Green Barrier
-- pos: [556, 233]
-  paintings:
-    - flower_painting_7
+- pos: [589, 230]
+  painting: flower_painting_7
   exits:
     - flower_starting
     - flower_arrow
 - pos: [600, 332]
   room: Number Hunt
   door: Nines
-- pos: [579, 350]
-  paintings:
-    - blueman_painting
+- pos: [589, 369]
+  painting: blueman_painting
   entrances:
     - blueman_courtyard
 - pos: [530, 310]
@@ -502,9 +499,8 @@
 - pos: [922, 107]
   room: The Colorful (Gray)
   door: Progress Door
-- pos: [967, 107]
-  paintings:
-    - arrows_painting_12
+- pos: [969, 96]
+  painting: arrows_painting_12
 - pos: [878, 954]
   room: Welcome Back Area
   door: Shortcut to Starting Room
@@ -537,10 +533,10 @@
 - pos: [1737, 1053]
   entrances:
     - gallery_wb
-- pos: [1690, 268]
+- pos: [1784, 395]
   entrances:
     - observant_wb
-- pos: [250, 604]
+- pos: [122, 350]
   entrances:
     - scientific_wb
 - pos: [1553, 1467]
@@ -549,17 +545,19 @@
 - pos: [1478, 498]
   room: Owl Hallway
   door: Shortcut to Hedge Maze
-- pos: [1480, 551]
-  paintings:
-    - arrows_painting_8
-    - maze_painting_2
-    - owl_painting_2
-    - clock_painting_4
+- pos: [1467, 535]
+  painting: arrows_painting_8
+- pos: [1467, 562]
+  painting: maze_painting_2
   entrances:
     - green_owl
+- pos: [1510, 535]
+  painting: owl_painting_2
   exits:
     - owl_hidden
     - owl_tower6
+- pos: [1510, 562]
+  painting: clock_painting_4
 - pos: [1478, 938]
   room: Number Hunt
   door: Sevens
@@ -584,40 +582,38 @@
 - pos: [1511, 841]
   room: Outside The Initiated
   door: Initiated Entrance
-- pos: [1141, 1441]
+- pos: [1071, 1441]
   room: Orange Tower Third Floor
   door: Orange Barrier
-- pos: [1173, 1441]
+- pos: [1104, 1441]
   room: Outside The Initiated
   door: Green Barrier
-- pos: [1206, 1441]
+- pos: [1137, 1441]
   room: Outside The Initiated
   door: Purple Barrier
-- pos: [1189, 1355]
+- pos: [1120, 1355]
   room: Outside The Initiated
   door: Entrance
 - pos: [1580, 729]
   room: The Incomparable
   door: "Eight Door (Outside The Initiated)"
-- pos: [1530, 938]
-  paintings:
-    - clock_painting_5
+- pos: [1548, 948]
+  painting: clock_painting_5
   entrances:
     - clock_initiated
-- pos: [1546, 938]
-  paintings:
-    - clock_painting_2
-    - arrows_painting_2
+- pos: [1575, 969]
+  painting: arrows_painting_2
+- pos: [1575, 926]
+  painting: clock_painting_2
   exits:
     - clock_tower6
     - clock_initiated
-- pos: [1579, 813]
+- pos: [1580, 814]
   sunwarp:
     dots: 3
     type: exit
-- pos: [1444, 896]
-  paintings:
-    - smile_painting_1
+- pos: [1462, 915]
+  painting: smile_painting_1
   entrances:
     - smiley_initiated
 - pos: [1430, 691]
@@ -626,18 +622,25 @@
 - pos: [1468, 728]
   room: The Traveled
   door: Color Hallways Entrance
-- pos: [1533, 707]
+- pos: [1535, 644]
   tags:
     - red_ch
+- pos: [1535, 667]
+  tags:
     - blue_ch
+- pos: [1535, 689]
+  tags:
     - yellow_ch
+- pos: [1535, 711]
+  tags:
     - green_ch
+- pos: [1499, 678]
   exits:
     - early_ch
 - pos: [1567, 1264]
   tags:
     - red_ch
-- pos: [150, 808]
+- pos: [150, 748]
   tags:
     - blue_ch
 - pos: [626, 371]
@@ -655,21 +658,21 @@
 - pos: [1468, 1377]
   room: Outside The Bold
   door: Bold Entrance
-- pos: [1425, 1358]
-  paintings:
-    - pencil_painting2
-    - north_missing2
+- pos: [1446, 1344]
+  painting: pencil_painting2
   exits:
     - pencil_compass
     - pencil_starting
     - pencil_directional
+- pos: [1580, 1344]
+  painting: north_missing2
 - pos: [1334, 1419]
   room: Outside The Bold
   door: Steady Entrance
 - pos: [445, 1048]
   exits:
     - undeterred_artistic
-- pos: [279, 1071]
+- pos: [273, 1071]
   room: Number Hunt
   door: Zero Door
 - pos: [338, 1071]
@@ -684,17 +687,15 @@
 - pos: [242, 1071]
   room: Outside The Undeterred
   door: Undeterred Entrance
-- pos: [60, 1017]
-  paintings:
-    - blueman_painting_2
+- pos: [149, 937]
+  painting: blueman_painting_2
   exits:
     - blueman_courtyard
     - blueman_starting
-- pos: [402, 1012]
+- pos: [412, 1017]
   room: Outside The Undeterred
   door: Green Painting
-  paintings:
-    - maze_painting_3
+  painting: maze_painting_3
   entrances:
     - green_numbers
 - pos: [134, 1007]
@@ -704,7 +705,7 @@
 - pos: [719, 1039]
   room: Outside The Undeterred
   door: Challenge Entrance
-- pos: [483, 1039]
+- pos: [456, 1039]
   room: Outside The Undeterred
   door: Number Hunt
 - pos: [563, 1071]
@@ -725,11 +726,10 @@
 - pos: [525, 1002]
   room: Number Hunt
   door: Door to Directional Gallery
-- pos: [659, 1014]
+- pos: [572, 1017]
   room: Number Hunt
   door: Eights
-  paintings:
-    - smile_painting_5
+  painting: smile_painting_5
   entrances:
     - smiley_numbers
 - pos: [557, 953]
@@ -747,87 +747,67 @@
 - pos: [268, 825]
   room: Directional Gallery
   door: Yellow Barrier
-- pos: [231, 681]
+- pos: [214, 563]
   room: Number Hunt
   door: Sixes
 - pos: [242, 980]
   room: Directional Gallery
   door: Shortcut to The Undeterred
-- pos: [351, 927]
-  paintings:
-    - boxes_painting
+- pos: [364, 942]
+  painting: boxes_painting
   entrances:
     - lattice_directional
-- pos: [272, 927]
-  paintings:
-    - smile_painting_7
+- pos: [278, 942]
+  painting: smile_painting_7
   entrances:
     - smiley_directional
-- pos: [214, 822]
-  paintings:
-    - cherry_painting
+- pos: [278, 803]
+  painting: cherry_painting
   entrances:
     - apple_directional
-- pos: [266, 735]
+- pos: [262, 573]
   room: Number Hunt
   door: Sixes
-  paintings:
-    - pencil_painting3
+  painting: pencil_painting3
   entrances:
     - pencil_directional
-- pos: [215, 735]
-  paintings:
-    - flower_painting_4
+- pos: [278, 685]
+  painting: flower_painting_4
 - pos: [626, 851]
   sunwarp:
     dots: 6
     type: exit
-- pos: [1141, 1441]
-  room: Orange Tower Third Floor
-  door: Orange Barrier
-- pos: [1174, 1441]
-  room: Outside The Initiated
-  door: Green Barrier
-- pos: [1205, 1441]
-  room: Outside The Initiated
-  door: Purple Barrier
 - pos: [1334, 1377]
   room: Color Hunt
   door: Shortcut to The Steady
-- pos: [1280, 1375]
-  paintings:
-    - arrows_painting_7
-- pos: [1233, 1321]
+- pos: [1312, 1333]
+  painting: arrows_painting_7
+- pos: [1226, 1333]
   room: Outside The Initiated
   door: Entrance
-  paintings:
-    - fruitbowl_painting3
-- pos: [1290, 1323]
+  painting: fruitbowl_painting3
+- pos: [1260, 1323]
   sunwarp:
     dots: 5
     type: exit
-- pos: [1189, 1356]
-  room: Outside The Initiated
-  door: Entrance
-- pos: [1154, 1332]
-  paintings:
-    - colors_painting
+- pos: [1092, 1333]
+  painting: colors_painting
 - pos: [1640, 1260]
   room: The Bearer
   door: Backside Door
 - pos: [1468, 1287]
   room: The Bearer
   door: Entrance
-- pos: [1430, 1232]
+- pos: [1431, 1233]
   room: Number Hunt
   door: Sixes
 - pos: [1388, 1152]
   room: Bearer Side Area
   door: Shortcut to Tower
-- pos: [1273, 1442]
-  paintings:
-    - pencil_painting5
-    - pencil_painting4
+- pos: [1264, 1430]
+  painting: pencil_painting5
+- pos: [1291, 1430]
+  painting: pencil_painting4
 - pos: [1355, 1092]
   room: Knight Night (Final)
   door: Exit
@@ -838,9 +818,8 @@
   # Complex case, because this is also blocked by Knight Night (Final) - Exit
   room: Number Hunt
   door: Sevens
-- pos: [1653, 101]
-  paintings:
-    - smile_painting_9
+- pos: [1687, 117]
+  painting: smile_painting_9
   exits:
     - smiley_crossroads
     - smiley_deadend
@@ -850,88 +829,113 @@
     - smiley_initiated
     - smiley_gallery
     - smiley_theysee
-- pos: [1656, 139]
+- pos: [1677, 161]
   room: The Artistic (Smiley)
   door: Door to Panda
 - pos: [1711, 140]
   entrances:
     - undeterred_artistic
-- pos: [1653, 169]
-  paintings:
-    - panda_painting_3
+- pos: [1687, 224]
+  painting: panda_painting_3
   exits:
     - panda_tower6
     - panda_hallway
-- pos: [1708, 171]
+- pos: [1731, 215]
   room: The Artistic (Panda)
   door: Door to Lattice
-- pos: [1761, 169]
-  paintings:
-    - boxes_painting2
+- pos: [1794, 224]
+  painting: boxes_painting2
   exits:
     - lattice_directional
-- pos: [1762, 139]
+- pos: [1785, 161]
   room: The Artistic (Lattice)
   door: Door to Apple
-- pos: [1761, 101]
-  paintings:
-    - cherry_painting3
+- pos: [1794, 117]
+  painting: cherry_painting3
   exits:
     - apple_tower6
     - apple_directional
-- pos: [1708, 107]
+- pos: [1731, 107]
   room: The Artistic (Apple)
   door: Door to Smiley
-- pos: [370, 681]
+- pos: [370, 563]
   room: Number Hunt
   door: Eights
-- pos: [411, 685]
-  paintings:
-    - eye_painting_2
-    - smile_painting_2
+- pos: [637, 605]
+  painting: eye_painting
+  entrances:
+    - crossroads_eyewall
+- pos: [610, 605]
+  exits:
+    - crossroads_eyewall
+- pos: [417, 573]
+  painting: eye_painting_2
+  exits:
+    - crossroads_eyewall
+- pos: [342, 573]
+  painting: smile_painting_2
   entrances:
     - smiley_theysee
-- pos: [310, 750]
+- pos: [311, 750]
   room: The Eyes They See
   door: Exit
-- pos: [334, 798]
-  paintings:
-    - arrows_painting_5
-- pos: [370, 792]
+- pos: [348, 803]
+  painting: arrows_painting_5
+- pos: [370, 751]
   room: Outside The Wondrous
   door: Wondrous Entrance
-- pos: [367, 752]
-  paintings:
-    - symmetry_painting_a_1
-    - symmetry_painting_b_1
-    - symmetry_painting_a_3
-    - symmetry_painting_a_5
-    - symmetry_painting_b_4
-    - symmetry_painting_a_2
-    - symmetry_painting_b_2
-    - symmetry_painting_a_6
-    - symmetry_painting_b_6
+- pos: [428, 696]
+  painting: symmetry_painting_a_1
   exits:
     - symmetry_starting
-- pos: [407, 755]
+    - symmetry_a_chandelier
+    - symmetry_a_table
+- pos: [428, 749]
+  painting: symmetry_painting_b_1
+  entrances:
+    - symmetry_b_table
+- pos: [471, 696]
+  painting: symmetry_painting_a_3
+- pos: [538, 699]
+  painting: symmetry_painting_a_5
+  entrances:
+    - symmetry_a_chandelier
+- pos: [562, 728]
+  painting: symmetry_painting_b_4
+- pos: [422, 647]
+  painting: symmetry_painting_a_2
+  entrances:
+    - symmetry_a_table
+- pos: [364, 648]
+  painting: symmetry_painting_b_2
+  exits:
+    - symmetry_b_table
+    - symmetry_b_fire
+- pos: [449, 647]
+  painting: symmetry_painting_a_6
+- pos: [508, 647]
+  painting: symmetry_painting_b_6
+  entrances:
+    - symmetry_b_fire
+- pos: [558, 665]
+  room: The Wondrous
+  door: Exit
+- pos: [535, 647]
   room: The Wondrous
   door: Exit
-  paintings:
-    - arrows_painting_9
-- pos: [449, 755]
-  paintings:
-    - flower_painting_6
+  painting: arrows_painting_9
+- pos: [610, 674]
+  painting: flower_painting_6
   entrances:
     - flower_arrow
-- pos: [1101, 222]
-  paintings:
-    - panda_painting
+- pos: [1156, 262]
+  painting: panda_painting
   entrances:
     - panda_hallway
 - pos: [1152, 209]
   room: Hallway Room (1)
   door: Exit
-- pos: [1189, 170]
+- pos: [1190, 171]
   room: Hallway Room (2)
   door: Exit
 - pos: [1238, 124]
@@ -946,16 +950,17 @@
 - pos: [1415, 140]
   room: Number Hunt
   door: Nines
-- pos: [1458, 133]
-  paintings:
-    - south_afar
+- pos: [1424, 85]
+  painting: south_afar
 - pos: [826, 1452]
   room: Outside The Wanderer
   door: Wanderer Entrance
+  tilted: true
 - pos: [763, 1465]
   room: Outside The Wanderer
   door: Tower Entrance
-- pos: [1655, 1151]
+  tilted: true
+- pos: [1656, 1152]
   room: Number Hunt
   door: Eights
 - pos: [1623, 1044]
@@ -973,15 +978,18 @@
 - pos: [1511, 1119]
   room: Art Gallery
   door: Exit
-- pos: [1654, 1116]
-  paintings:
-    - smile_painting_3
-    - flower_painting_2
-    - scenery_painting_0a
-    - map_painting
-    - fruitbowl_painting4
+- pos: [1730, 1162]
+  painting: flower_painting_2
+- pos: [1730, 1189]
+  painting: map_painting
+- pos: [1698, 1189]
+  painting: smile_painting_3
   entrances:
     - smiley_gallery
+- pos: [1714, 1215]
+  painting: fruitbowl_painting4
+- pos: [1714, 1242]
+  painting: scenery_painting_0a
 - pos: [1120, 1286]
   room: Rhyme Room (Smiley)
   door: Door to Target
@@ -1000,9 +1008,8 @@
 - pos: [1120, 1195]
   room: Rhyme Room (Circle)
   door: Door to Smiley
-- pos: [1118, 1137]
-  paintings:
-    - arrows_painting_3
+- pos: [1130, 1124]
+  painting: arrows_painting_3
 - pos: [1050, 1142]
   room: Rhyme Room (Looped Square)
   door: Door to Circle
@@ -1015,26 +1022,41 @@
 - pos: [852, 1200]
   room: Rhyme Room (Target)
   door: Door to Cross
-- pos: [850, 1138]
-  paintings:
-    - arrows_painting_4
+- pos: [862, 1124]
+  painting: arrows_painting_4
 - pos: [1592, 1442]
   room: Room Room
   door: Cellar Exit
-- pos: [1570, 938]
+- pos: [1623, 938]
   room: Outside The Wise
   door: Wise Entrance
-- pos: [1653, 935]
-  paintings:
-    - clock_painting_3
-- pos: [369, 605]
+- pos: [1665, 920]
+  painting: clock_painting_3
+- pos: [241, 348]
   room: Outside The Scientific
   door: Scientific Entrance
-- pos: [294, 602]
-  paintings:
-    - hi_solved_painting4
+- pos: [176, 326]
+  painting: hi_solved_painting4
   entrances:
     - hi_scientific
-- pos: [814, 1001]
+- pos: [815, 1002]
   room: Challenge Room
   door: Welcome Door
+- pos: [104, 1208]
+  special: color_black
+- pos: [104, 1249]
+  special: color_red
+- pos: [104, 1290]
+  special: color_yellow
+- pos: [104, 1330]
+  special: color_blue
+- pos: [104, 1371]
+  special: color_purple
+- pos: [104, 1411]
+  special: color_orange
+- pos: [104, 1451]
+  special: color_green
+- pos: [104, 1491]
+  special: color_brown
+- pos: [104, 1531]
+  special: color_gray
@@ -8,23 +8,24 @@ AchievementsPane::AchievementsPane(wxWindow* parent)
   AppendColumn("Achievement");
 
   for (int panel_id : GD_GetAchievementPanels()) {
-    achievement_names_.push_back(GD_GetPanel(panel_id).achievement_name);
+    const Panel& panel = GD_GetPanel(panel_id);
+    achievements_.emplace_back(panel.achievement_name, panel.solve_index);
   }
 
-  std::sort(std::begin(achievement_names_), std::end(achievement_names_));
+  std::sort(std::begin(achievements_), std::end(achievements_));
 
-  for (int i = 0; i < achievement_names_.size(); i++) {
-    InsertItem(i, achievement_names_.at(i));
+  for (int i = 0; i < achievements_.size(); i++) {
+    InsertItem(i, std::get<0>(achievements_.at(i)));
   }
 
-  SetColumnWidth(0, wxLIST_AUTOSIZE);
+  SetColumnWidth(0, wxLIST_AUTOSIZE_USEHEADER);
 
   UpdateIndicators();
 }
 
 void AchievementsPane::UpdateIndicators() {
-  for (int i = 0; i < achievement_names_.size(); i++) {
-    if (AP_HasAchievement(achievement_names_.at(i))) {
+  for (int i = 0; i < achievements_.size(); i++) {
+    if (AP_IsPanelSolved(std::get<1>(achievements_.at(i)))) {
       SetItemTextColour(i, *wxBLACK);
     } else {
       SetItemTextColour(i, *wxRED);
@@ -9,6 +9,10 @@
 
 #include <wx/listctrl.h>
 
+#include <string>
+#include <tuple>
+#include <vector>
+
 class AchievementsPane : public wxListView {
  public:
   explicit AchievementsPane(wxWindow* parent);
@@ -16,7 +20,7 @@ class AchievementsPane : public wxListView {
   void UpdateIndicators();
 
  private:
-  std::vector<std::string> achievement_names_;
+  std::vector<std::tuple<std::string, int>> achievements_; // name, solve index
 };
 
 #endif /* end of include guard: ACHIEVEMENTS_PANE_H_C320D0B8 */
\ No newline at end of file
@@ -10,6 +10,7 @@
 #include <any>
 #include <apclient.hpp>
 #include <apuuid.hpp>
+#include <bitset>
 #include <chrono>
 #include <exception>
 #include <filesystem>
@@ -28,8 +29,8 @@
 #include "tracker_state.h"
 
 constexpr int AP_MAJOR = 0;
-constexpr int AP_MINOR = 4;
-constexpr int AP_REVISION = 5;
+constexpr int AP_MINOR = 6;
+constexpr int AP_REVISION = 1;
 
 constexpr const char* CERT_STORE_PATH = "cacert.pem";
 constexpr int ITEM_HANDLING = 7;  // <- all
@@ -37,8 +38,24 @@ constexpr int ITEM_HANDLING = 7;  // <- all
 constexpr int CONNECTION_TIMEOUT = 50000;  // 50 seconds
 constexpr int CONNECTION_BACKOFF_INTERVAL = 100;
 
+constexpr int PANEL_COUNT = 803;
+constexpr int PANEL_BITFIELD_LENGTH = 48;
+constexpr int PANEL_BITFIELDS = 17;
+
 namespace {
 
+const std::set<long> kNonProgressionItems = {
+    444409,  // :)
+    444575,  // The Feeling of Being Lost
+    444576,  // Wanderlust
+    444577,  // Empty White Hallways
+    444410,  // Slowness Trap
+    444411,  // Iceland Trap
+    444412,  // Atbash Trap
+    444413,  // Puzzle Skip
+    444680,  // Speed Boost
+};
+
 struct APState {
   // Initialized on main thread
   bool initialized = false;
@@ -67,10 +84,12 @@ struct APState {
   std::set<int64_t> checked_locations;
   std::map<std::string, std::any> data_storage;
   std::optional<std::tuple<int, int>> player_pos;
+  std::bitset<PANEL_COUNT> solved_panels;
 
   DoorShuffleMode door_shuffle_mode = kNO_DOORS;
   bool group_doors = false;
   bool color_shuffle = false;
+  PanelShuffleMode panel_shuffle_mode = kNO_PANELS;
   bool painting_shuffle = false;
   int mastery_requirement = 21;
   int level_2_requirement = 223;
@@ -82,6 +101,7 @@ struct APState {
   bool pilgrimage_allows_paintings = false;
   SunwarpAccess sunwarp_access = kSUNWARP_ACCESS_NORMAL;
   bool sunwarp_shuffle = false;
+  bool postgame_shuffle = true;
 
   std::map<std::string, std::string> painting_mapping;
   std::set<std::string> painting_codomain;
@@ -128,10 +148,12 @@ struct APState {
         checked_locations.clear();
         data_storage.clear();
         player_pos = std::nullopt;
+        solved_panels.reset();
         victory_data_storage_key.clear();
         door_shuffle_mode = kNO_DOORS;
         group_doors = false;
         color_shuffle = false;
+        panel_shuffle_mode = kNO_PANELS;
         painting_shuffle = false;
         painting_mapping.clear();
         painting_codomain.clear();
@@ -146,6 +168,7 @@ struct APState {
         sunwarp_access = kSUNWARP_ACCESS_NORMAL;
         sunwarp_shuffle = false;
         sunwarp_mapping.clear();
+        postgame_shuffle = true;
       }
 
       apclient->set_room_info_handler(
@@ -200,24 +223,13 @@ struct APState {
     return checked_locations.count(location_id);
   }
 
-  bool HasCheckedHuntPanel(int location_id) {
-    std::lock_guard state_guard(state_mutex);
-
-    std::string key =
-        fmt::format("{}Hunt|{}", data_storage_prefix, location_id);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
-  }
-
   bool HasItem(int item_id, int quantity) {
     return inventory.count(item_id) && inventory.at(item_id) >= quantity;
   }
 
-  bool HasAchievement(const std::string& name) {
+  bool HasItemSafe(int item_id, int quantity) {
     std::lock_guard state_guard(state_mutex);
-
-    std::string key =
-        fmt::format("{}Achievement|{}", data_storage_prefix, name);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
+    return HasItem(item_id, quantity);
   }
 
   const std::set<std::string>& GetCheckedPaintings() {
@@ -241,7 +253,21 @@ struct APState {
             checked_paintings.count(painting_mapping.at(painting_id)));
   }
 
-  std::string GetItemName(int id) { return apclient->get_item_name(id); }
+  void RevealPaintings() {
+    std::lock_guard state_guard(state_mutex);
+
+    std::vector<std::string> paintings;
+    for (const PaintingExit& painting : GD_GetPaintings()) {
+      paintings.push_back(painting.internal_id);
+    }
+
+    APClient::DataStorageOperation operation;
+    operation.operation = "replace";
+    operation.value = paintings;
+
+    apclient->Set(fmt::format("{}Paintings", data_storage_prefix), "", true,
+                  {operation});
+  }
 
   bool HasReachedGoal() {
     std::lock_guard state_guard(state_mutex);
@@ -251,6 +277,12 @@ struct APState {
                30;  // CLIENT_GOAL
   }
 
+  bool IsPanelSolved(int solve_index) {
+    std::lock_guard state_guard(state_mutex);
+
+    return solved_panels.test(solve_index);
+  }
+
  private:
   void Initialize() {
     if (!initialized) {
@@ -258,16 +290,8 @@ struct APState {
 
       std::thread([this]() { Thread(); }).detach();
 
-      for (int panel_id : GD_GetAchievementPanels()) {
-        tracked_data_storage_keys.push_back(fmt::format(
-            "Achievement|{}", GD_GetPanel(panel_id).achievement_name));
-      }
-
-      for (const MapArea& map_area : GD_GetMapAreas()) {
-        for (const Location& location : map_area.locations) {
-          tracked_data_storage_keys.push_back(
-              fmt::format("Hunt|{}", location.ap_location_id));
-        }
+      for (int i = 0; i < PANEL_BITFIELDS; i++) {
+        tracked_data_storage_keys.push_back(fmt::format("Panels_{}", i));
       }
 
       tracked_data_storage_keys.push_back("PlayerPos");
@@ -351,7 +375,7 @@ struct APState {
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(StateUpdate{.cleared_locations = true});
   }
 
   void OnSlotDisconnected() {
@@ -373,37 +397,59 @@ struct APState {
   }
 
   void OnItemsReceived(const std::list<APClient::NetworkItem>& items) {
+    std::vector<ItemState> item_states;
+    bool progression_items = false;
+
     {
       std::lock_guard state_guard(state_mutex);
 
+      std::map<int64_t, int> index_by_item;
+
       for (const APClient::NetworkItem& item : items) {
         inventory[item.item]++;
         TrackerLog(fmt::format("Item: {}", item.item));
+
+        index_by_item[item.item] = item.index;
+
+        if (!kNonProgressionItems.count(item.item)) {
+          progression_items = true;
+        }
+      }
+
+      for (const auto& [item_id, item_index] : index_by_item) {
+        item_states.push_back(ItemState{.name = GD_GetItemName(item_id),
+                                        .amount = inventory[item_id],
+                                        .index = item_index});
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(StateUpdate{.items = item_states,
+                               .progression_items = progression_items});
   }
 
   void OnRetrieved(const std::map<std::string, nlohmann::json>& data) {
+    StateUpdate state_update;
+
     {
       std::lock_guard state_guard(state_mutex);
 
       for (const auto& [key, value] : data) {
-        HandleDataStorage(key, value);
+        HandleDataStorage(key, value, state_update);
       }
     }
 
-    RefreshTracker(false);
+    RefreshTracker(state_update);
   }
 
   void OnSetReply(const std::string& key, const nlohmann::json& value) {
+    StateUpdate state_update;
+
     {
       std::lock_guard state_guard(state_mutex);
-      HandleDataStorage(key, value);
+      HandleDataStorage(key, value, state_update);
     }
 
-    RefreshTracker(false);
+    RefreshTracker(state_update);
   }
 
   void OnSlotConnected(std::string player, std::string server,
@@ -435,6 +481,7 @@ struct APState {
         }
       }
       color_shuffle = slot_data["shuffle_colors"].get<int>() == 1;
+      panel_shuffle_mode = slot_data["shuffle_panels"].get<PanelShuffleMode>();
       painting_shuffle = slot_data["shuffle_paintings"].get<int>() == 1;
       mastery_requirement = slot_data["mastery_achievements"].get<int>();
       level_2_requirement = slot_data["level_2_requirement"].get<int>();
@@ -456,6 +503,9 @@ struct APState {
                            : kSUNWARP_ACCESS_NORMAL;
       sunwarp_shuffle = slot_data.contains("shuffle_sunwarps") &&
                         slot_data["shuffle_sunwarps"].get<int>() == 1;
+      postgame_shuffle = slot_data.contains("shuffle_postgame")
+                             ? (slot_data["shuffle_postgame"].get<int>() == 1)
+                             : true;
 
       if (painting_shuffle && slot_data.contains("painting_entrance_to_exit")) {
         painting_mapping.clear();
@@ -497,7 +547,7 @@ struct APState {
     }
 
     ResetReachabilityRequirements();
-    RefreshTracker(true);
+    RefreshTracker(std::nullopt);
   }
 
   void OnSlotRefused(const std::list<std::string>& errors) {
@@ -540,19 +590,40 @@ struct APState {
   }
 
   // Assumes state mutex is locked.
-  void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
+  void HandleDataStorage(const std::string& key, const nlohmann::json& value, StateUpdate& state_update) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
       TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
                              (value.get<bool>() ? "true" : "false")));
+
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
       TrackerLog(fmt::format("Data storage {} retrieved as {}", key,
                              value.get<int>()));
+
+      if (key == victory_data_storage_key) {
+        state_update.cleared_locations = true;
+      } else if (key.find("Panels_") != std::string::npos) {
+        int bitfield_num =
+            std::stoi(key.substr(data_storage_prefix.size() + 7));
+        uint64_t bitfield_value = value.get<uint64_t>();
+        for (int i = 0; i < PANEL_BITFIELD_LENGTH; i++) {
+          if ((bitfield_value & (1LL << i)) != 0) {
+            int solve_index = bitfield_num * PANEL_BITFIELD_LENGTH + i;
+            
+            if (!solved_panels.test(solve_index)) {
+              state_update.panels.insert(solve_index);
+            }
+            
+            solved_panels.set(solve_index);
+          }
+        }
+      }
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
         player_pos = std::tuple<int, int>(map_value["x"], map_value["z"]);
+        state_update.player_position = true;
       } else {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
@@ -561,6 +632,7 @@ struct APState {
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
+        state_update.player_position = true;
       } else {
         data_storage.erase(key);
       }
@@ -572,6 +644,8 @@ struct APState {
       if (key.ends_with("Paintings")) {
         data_storage[key] =
             std::set<std::string>(list_value.begin(), list_value.end());
+        state_update.paintings =
+            std::vector<std::string>(list_value.begin(), list_value.end());
       } else {
         data_storage[key] = list_value;
       }
@@ -582,29 +656,34 @@ struct APState {
   }
 
   // State mutex should NOT be locked.
-  void RefreshTracker(bool reset) {
+  // nullopt state_update indicates a reset.
+  void RefreshTracker(std::optional<StateUpdate> state_update) {
     TrackerLog("Refreshing display...");
 
-    std::string prev_msg;
-    {
-      std::lock_guard state_guard(state_mutex);
+    if (!state_update || state_update->progression_items ||
+        !state_update->paintings.empty()) {
+      std::string prev_msg;
+      {
+        std::lock_guard state_guard(state_mutex);
 
-      prev_msg = status_message;
-      SetStatusMessage(fmt::format("{} Recalculating...", status_message));
-    }
+        prev_msg = status_message;
+        SetStatusMessage(fmt::format("{} Recalculating...", status_message));
+      }
 
-    RecalculateReachability();
+      RecalculateReachability();
 
-    if (reset) {
-      tracker_frame->ResetIndicators();
-    } else {
-      tracker_frame->UpdateIndicators();
-    }
+      {
+        std::lock_guard state_guard(state_mutex);
 
-    {
-      std::lock_guard state_guard(state_mutex);
+        SetStatusMessage(prev_msg);
+      }
+    }
+    
 
-      SetStatusMessage(prev_msg);
+    if (!state_update) {
+      tracker_frame->ResetIndicators();
+    } else {
+      tracker_frame->UpdateIndicators(*state_update);
     }
   }
 
@@ -639,16 +718,12 @@ bool AP_HasCheckedGameLocation(int location_id) {
   return GetState().HasCheckedGameLocation(location_id);
 }
 
-bool AP_HasCheckedHuntPanel(int location_id) {
-  return GetState().HasCheckedHuntPanel(location_id);
-}
-
 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);
+bool AP_HasItemSafe(int item_id, int quantity) {
+  return GetState().HasItemSafe(item_id, quantity);
 }
 
 DoorShuffleMode AP_GetDoorShuffleMode() {
@@ -695,6 +770,8 @@ bool AP_IsPaintingChecked(const std::string& painting_id) {
   return GetState().IsPaintingChecked(painting_id);
 }
 
+void AP_RevealPaintings() { GetState().RevealPaintings(); }
+
 int AP_GetMasteryRequirement() {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -707,6 +784,12 @@ int AP_GetLevel2Requirement() {
   return GetState().level_2_requirement;
 }
 
+LocationChecks AP_GetLocationsChecks() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().location_checks;
+}
+
 bool AP_IsLocationVisible(int classification) {
   std::lock_guard state_guard(GetState().state_mutex);
 
@@ -734,14 +817,16 @@ bool AP_IsLocationVisible(int classification) {
   return (world_state & classification);
 }
 
-VictoryCondition AP_GetVictoryCondition() {
+PanelShuffleMode AP_GetPanelShuffleMode() {
   std::lock_guard state_guard(GetState().state_mutex);
 
-  return GetState().victory_condition;
+  return GetState().panel_shuffle_mode;
 }
 
-bool AP_HasAchievement(const std::string& achievement_name) {
-  return GetState().HasAchievement(achievement_name);
+VictoryCondition AP_GetVictoryCondition() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().victory_condition;
 }
 
 bool AP_HasEarlyColorHallways() {
@@ -784,6 +869,8 @@ std::map<int, SunwarpMapping> AP_GetSunwarpMapping() {
   return GetState().sunwarp_mapping;
 }
 
+bool AP_IsPostgameShuffle() { return GetState().postgame_shuffle; }
+
 bool AP_HasReachedGoal() { return GetState().HasReachedGoal(); }
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
@@ -791,3 +878,7 @@ std::optional<std::tuple<int, int>> AP_GetPlayerPosition() {
 
   return GetState().player_pos;
 }
+
+bool AP_IsPanelSolved(int solve_index) {
+  return GetState().IsPanelSolved(solve_index);
+}
@@ -26,6 +26,8 @@ enum LocationChecks {
   kPANELSANITY = 2
 };
 
+enum PanelShuffleMode { kNO_PANELS = 0, kREARRANGE_PANELS = 1 };
+
 enum SunwarpAccess {
   kSUNWARP_ACCESS_NORMAL = 0,
   kSUNWARP_ACCESS_DISABLED = 1,
@@ -39,6 +41,12 @@ struct SunwarpMapping {
   int exit_index;
 };
 
+struct ItemState {
+  std::string name;
+  int amount = 0;
+  int index = 0;
+};
+
 void AP_SetTrackerFrame(TrackerFrame* tracker_frame);
 
 void AP_Connect(std::string server, std::string player, std::string password);
@@ -49,16 +57,11 @@ std::string AP_GetSaveName();
 
 bool AP_HasCheckedGameLocation(int location_id);
 
-bool AP_HasCheckedHuntPanel(int location_id);
-
 // This doesn't lock the state mutex, for speed, so it must ONLY be called from
 // RecalculateReachability, which is only called from the APState thread anyway.
 bool AP_HasItem(int item_id, int quantity = 1);
 
-// This doesn't lock the client mutex because it is ONLY to be called from
-// RecalculateReachability, which is only called from within a client callback
-// anyway.
-std::string AP_GetItemName(int item_id);
+bool AP_HasItemSafe(int item_id, int quantity = 1);
 
 DoorShuffleMode AP_GetDoorShuffleMode();
 
@@ -76,15 +79,19 @@ std::set<std::string> AP_GetCheckedPaintings();
 
 bool AP_IsPaintingChecked(const std::string& painting_id);
 
+void AP_RevealPaintings();
+
 int AP_GetMasteryRequirement();
 
 int AP_GetLevel2Requirement();
 
+LocationChecks AP_GetLocationsChecks();
+
 bool AP_IsLocationVisible(int classification);
 
-VictoryCondition AP_GetVictoryCondition();
+PanelShuffleMode AP_GetPanelShuffleMode();
 
-bool AP_HasAchievement(const std::string& achievement_name);
+VictoryCondition AP_GetVictoryCondition();
 
 bool AP_HasEarlyColorHallways();
 
@@ -100,8 +107,12 @@ bool AP_IsSunwarpShuffle();
 
 std::map<int, SunwarpMapping> AP_GetSunwarpMapping();
 
+bool AP_IsPostgameShuffle();
+
 bool AP_HasReachedGoal();
 
 std::optional<std::tuple<int, int>> AP_GetPlayerPosition();
 
+bool AP_IsPanelSolved(int solve_index);
+
 #endif /* end of include guard: AP_STATE_H_664A4180 */
@@ -7,6 +7,7 @@
 #include "ap_state.h"
 #include "game_data.h"
 #include "global.h"
+#include "icons.h"
 #include "tracker_config.h"
 #include "tracker_panel.h"
 #include "tracker_state.h"
@@ -15,60 +16,54 @@ AreaPopup::AreaPopup(wxWindow* parent, int area_id)
     : wxScrolledCanvas(parent, wxID_ANY), area_id_(area_id) {
   SetBackgroundStyle(wxBG_STYLE_PAINT);
 
-  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));
+  LoadIcons();
 
+  // TODO: This is slow on high-DPI screens.
   SetScrollRate(5, 5);
 
   SetBackgroundColour(*wxBLACK);
   Hide();
 
   Bind(wxEVT_PAINT, &AreaPopup::OnPaint, this);
+  Bind(wxEVT_DPI_CHANGED, &AreaPopup::OnDPIChanged, this);
 
-  UpdateIndicators();
+  ResetIndicators();
 }
 
-void AreaPopup::UpdateIndicators() {
+void AreaPopup::ResetIndicators() {
+  indicators_.clear();
+
   const MapArea& map_area = GD_GetMapArea(area_id_);
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  TrackerPanel* tracker_panel = dynamic_cast<TrackerPanel*>(GetParent());
 
   // Start calculating extents.
   wxMemoryDC mem_dc;
-  mem_dc.SetFont(GetFont().Bold());
-  wxSize header_extent = mem_dc.GetTextExtent(map_area.name);
+  mem_dc.SetFont(the_font.Bold());
+  header_extent_ = mem_dc.GetTextExtent(map_area.name);
 
-  int acc_height = header_extent.GetHeight() + 20;
+  int acc_height = header_extent_.GetHeight() + FromDIP(20);
   int col_width = 0;
 
-  mem_dc.SetFont(GetFont());
-
-  TrackerPanel* tracker_panel = dynamic_cast<TrackerPanel*>(GetParent());
-
-  std::vector<int> real_locations;
+  mem_dc.SetFont(the_font);
 
   for (int section_id = 0; section_id < map_area.locations.size();
        section_id++) {
     const Location& location = map_area.locations.at(section_id);
-
-    if (tracker_panel->IsPanelsMode()) {
-      if (!location.single_panel) {
-        continue;
-      }
-    } else {
-      if (!AP_IsLocationVisible(location.classification) &&
-          !(location.hunt && GetTrackerConfig().show_hunt_panels)) {
-        continue;
-      }
+    if ((!AP_IsLocationVisible(location.classification) ||
+         IsLocationPostgame(location.ap_location_id)) &&
+        !(location.hunt &&
+          GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) &&
+        !(location.single_panel &&
+          GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS)) {
+      continue;
     }
 
-    real_locations.push_back(section_id);
+    indicators_.emplace_back(section_id, kLOCATION, acc_height);
 
     wxSize item_extent = mem_dc.GetTextExtent(location.name);
-    int item_height = std::max(32, item_extent.GetHeight()) + 10;
+    int item_height =
+        std::max(FromDIP(32), item_extent.GetHeight()) + FromDIP(10);
     acc_height += item_height;
 
     if (item_extent.GetWidth() > col_width) {
@@ -76,11 +71,18 @@ void AreaPopup::UpdateIndicators() {
     }
   }
 
-  if (AP_IsPaintingShuffle() && !tracker_panel->IsPanelsMode()) {
+  if (AP_IsPaintingShuffle()) {
     for (int painting_id : map_area.paintings) {
+      if (IsPaintingPostgame(painting_id)) {
+        continue;
+      }
+
+      indicators_.emplace_back(painting_id, kPAINTING, acc_height);
+
       const PaintingExit& painting = GD_GetPaintingExit(painting_id);
-      wxSize item_extent = mem_dc.GetTextExtent(painting.internal_id);  // TODO: Replace with a friendly name.
-      int item_height = std::max(32, item_extent.GetHeight()) + 10;
+      wxSize item_extent = mem_dc.GetTextExtent(painting.display_name);
+      int item_height =
+          std::max(FromDIP(32), item_extent.GetHeight()) + FromDIP(10);
       acc_height += item_height;
 
       if (item_extent.GetWidth() > col_width) {
@@ -89,80 +91,86 @@ void AreaPopup::UpdateIndicators() {
     }
   }
 
-  int item_width = col_width + 10 + 32;
-  int full_width = std::max(header_extent.GetWidth(), item_width) + 20;
+  int item_width = col_width + FromDIP(10 + 32);
+  full_width_ = std::max(header_extent_.GetWidth(), item_width) + FromDIP(20);
+  full_height_ = acc_height;
 
   Fit();
-  SetVirtualSize(full_width, acc_height);
+  SetVirtualSize(full_width_, full_height_);
+
+  UpdateIndicators();
+}
+
+void AreaPopup::UpdateIndicators() {
+  const MapArea& map_area = GD_GetMapArea(area_id_);
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  TrackerPanel* tracker_panel = dynamic_cast<TrackerPanel*>(GetParent());
+
+  rendered_ = wxBitmap(full_width_, full_height_);
 
-  rendered_ = wxBitmap(full_width, acc_height);
+  wxMemoryDC mem_dc;
   mem_dc.SelectObject(rendered_);
   mem_dc.SetPen(*wxTRANSPARENT_PEN);
   mem_dc.SetBrush(*wxBLACK_BRUSH);
-  mem_dc.DrawRectangle({0, 0}, {full_width, acc_height});
+  mem_dc.DrawRectangle({0, 0}, {full_width_, full_height_});
 
-  mem_dc.SetFont(GetFont().Bold());
+  mem_dc.SetFont(the_font.Bold());
   mem_dc.SetTextForeground(*wxWHITE);
   mem_dc.DrawText(map_area.name,
-                  {(full_width - header_extent.GetWidth()) / 2, 10});
+                  {(full_width_ - header_extent_.GetWidth()) / 2, FromDIP(10)});
 
-  int cur_height = header_extent.GetHeight() + 20;
+  mem_dc.SetFont(the_font);
 
-  mem_dc.SetFont(GetFont());
+  for (const IndicatorInfo& indicator : indicators_) {
+    switch (indicator.type) {
+      case kLOCATION: {
+        const Location& location = map_area.locations.at(indicator.id);
 
-  for (int section_id : real_locations) {
-    const Location& location = map_area.locations.at(section_id);
+        bool checked = false;
+        if (IsLocationWinCondition(location)) {
+          checked = AP_HasReachedGoal();
+        } else {
+          checked = AP_HasCheckedGameLocation(location.ap_location_id) ||
+                    (location.single_panel &&
+                     AP_IsPanelSolved(
+                         GD_GetPanel(*location.single_panel).solve_index));
+        }
 
-    bool checked = false;
-    if (IsLocationWinCondition(location)) {
-      checked = AP_HasReachedGoal();
-    } else if (tracker_panel->IsPanelsMode()) {
-      const Panel& panel = GD_GetPanel(*location.single_panel);
-      if (panel.non_counting) {
-        checked = AP_HasCheckedGameLocation(location.ap_location_id);
-      } else {
-        checked = tracker_panel->GetSolvedPanels().contains(panel.nodepath);
-      }
-    } else {
-      checked =
-          AP_HasCheckedGameLocation(location.ap_location_id) ||
-          (location.hunt && AP_HasCheckedHuntPanel(location.ap_location_id));
-    }
-
-    wxBitmap* eye_ptr = checked ? &checked_eye_ : &unchecked_eye_;
+        const wxBitmap* eye_ptr = checked ? checked_eye_ : unchecked_eye_;
 
-    mem_dc.DrawBitmap(*eye_ptr, {10, cur_height});
+        mem_dc.DrawBitmap(*eye_ptr, {FromDIP(10), indicator.y});
 
-    bool reachable = IsLocationReachable(location.ap_location_id);
-    const wxColour* text_color = reachable ? wxWHITE : wxRED;
-    mem_dc.SetTextForeground(*text_color);
+        bool reachable = IsLocationReachable(location.ap_location_id);
+        const wxColour* text_color = reachable ? wxWHITE : wxRED;
+        mem_dc.SetTextForeground(*text_color);
 
-    wxSize item_extent = mem_dc.GetTextExtent(location.name);
-    mem_dc.DrawText(
-        location.name,
-        {10 + 32 + 10, cur_height + (32 - mem_dc.GetFontMetrics().height) / 2});
-
-    cur_height += 10 + 32;
-  }
+        wxSize item_extent = mem_dc.GetTextExtent(location.name);
+        mem_dc.DrawText(
+            location.name,
+            {FromDIP(10 + 32 + 10),
+             indicator.y + (FromDIP(32) - mem_dc.GetFontMetrics().height) / 2});
 
-  if (AP_IsPaintingShuffle() && !tracker_panel->IsPanelsMode()) {
-    for (int painting_id : map_area.paintings) {
-      const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+        break;
+      }
+      case kPAINTING: {
+        const PaintingExit& painting = GD_GetPaintingExit(indicator.id);
 
-      bool reachable = IsPaintingReachable(painting_id);
-      const wxColour* text_color = reachable ? wxWHITE : wxRED;
-      mem_dc.SetTextForeground(*text_color);
+        bool reachable = IsPaintingReachable(indicator.id);
+        const wxColour* text_color = reachable ? wxWHITE : wxRED;
+        mem_dc.SetTextForeground(*text_color);
 
-      bool checked = reachable && AP_IsPaintingChecked(painting.internal_id);
-      wxBitmap* eye_ptr = checked ? &checked_eye_ : &unchecked_eye_;
-      mem_dc.DrawBitmap(*eye_ptr, {10, cur_height});
+        bool checked = reachable && AP_IsPaintingChecked(painting.internal_id);
+        const wxBitmap* eye_ptr = checked ? checked_owl_ : unchecked_owl_;
+        mem_dc.DrawBitmap(*eye_ptr, {FromDIP(10), indicator.y});
 
-      wxSize item_extent = mem_dc.GetTextExtent(painting.internal_id);  // TODO: Replace with friendly name.
-      mem_dc.DrawText(painting.internal_id,
-                      {10 + 32 + 10,
-                       cur_height + (32 - mem_dc.GetFontMetrics().height) / 2});
+        wxSize item_extent = mem_dc.GetTextExtent(painting.display_name);
+        mem_dc.DrawText(
+            painting.display_name,
+            {FromDIP(10 + 32 + 10),
+             indicator.y + (FromDIP(32) - mem_dc.GetFontMetrics().height) / 2});
 
-      cur_height += 10 + 32;
+        break;
+      }
     }
   }
 }
@@ -174,3 +182,21 @@ void AreaPopup::OnPaint(wxPaintEvent& event) {
 
   event.Skip();
 }
+
+void AreaPopup::OnDPIChanged(wxDPIChangedEvent& event) {
+  LoadIcons();
+  ResetIndicators();
+
+  event.Skip();
+}
+
+void AreaPopup::LoadIcons() {
+  unchecked_eye_ = GetTheIconCache().GetIcon("assets/unchecked.png",
+                                             FromDIP(wxSize{32, 32}));
+  checked_eye_ =
+      GetTheIconCache().GetIcon("assets/checked.png", FromDIP(wxSize{32, 32}));
+  unchecked_owl_ =
+      GetTheIconCache().GetIcon("assets/owl.png", FromDIP(wxSize{32, 32}));
+  checked_owl_ = GetTheIconCache().GetIcon("assets/checked_owl.png",
+                                           FromDIP(wxSize{32, 32}));
+}
@@ -7,19 +7,53 @@
 #include <wx/wx.h>
 #endif
 
+#include <vector>
+
 class AreaPopup : public wxScrolledCanvas {
  public:
   AreaPopup(wxWindow* parent, int area_id);
 
+  void ResetIndicators();
   void UpdateIndicators();
 
+  int GetFullWidth() const { return full_width_; }
+  int GetFullHeight() const { return full_height_; }
+
  private:
+  enum IndicatorType {
+    kLOCATION,
+    kPAINTING,
+  };
+
+  struct IndicatorInfo {
+    // For locations, the id is an index into the map area's locations list.
+    // For paintings, it is a real painting id.
+    int id;
+    IndicatorType type;
+    int y;
+
+    IndicatorInfo(int id, IndicatorType type, int y)
+        : id(id), type(type), y(y) {}
+  };
+
   void OnPaint(wxPaintEvent& event);
+  void OnDPIChanged(wxDPIChangedEvent& event);
+
+  void LoadIcons();
 
   int area_id_;
 
-  wxBitmap unchecked_eye_;
-  wxBitmap checked_eye_;
+  const wxBitmap* unchecked_eye_;
+  const wxBitmap* checked_eye_;
+  const wxBitmap* unchecked_owl_;
+  const wxBitmap* checked_owl_;
+
+  int full_width_ = 0;
+  int full_height_ = 0;
+  wxSize header_extent_;
+
+  std::vector<IndicatorInfo> indicators_;
+
   wxBitmap rendered_;
 };
 
@@ -4,17 +4,21 @@
 
 ConnectionDialog::ConnectionDialog()
     : wxDialog(nullptr, wxID_ANY, "Connect to Archipelago") {
-  server_box_ =
-      new wxTextCtrl(this, -1, GetTrackerConfig().connection_details.ap_server,
-                     wxDefaultPosition, {300, -1});
-  player_box_ =
-      new wxTextCtrl(this, -1, GetTrackerConfig().connection_details.ap_player,
-                     wxDefaultPosition, {300, -1});
+  server_box_ = new wxTextCtrl(
+      this, -1,
+      wxString::FromUTF8(GetTrackerConfig().connection_details.ap_server),
+      wxDefaultPosition, FromDIP(wxSize{300, -1}));
+  player_box_ = new wxTextCtrl(
+      this, -1,
+      wxString::FromUTF8(GetTrackerConfig().connection_details.ap_player),
+      wxDefaultPosition, FromDIP(wxSize{300, -1}));
   password_box_ = new wxTextCtrl(
-      this, -1, GetTrackerConfig().connection_details.ap_password,
-      wxDefaultPosition, {300, -1});
+      this, -1,
+      wxString::FromUTF8(GetTrackerConfig().connection_details.ap_password),
+      wxDefaultPosition, FromDIP(wxSize{300, -1}));
 
-  wxFlexGridSizer* form_sizer = new wxFlexGridSizer(2, 10, 10);
+  wxFlexGridSizer* form_sizer =
+      new wxFlexGridSizer(2, FromDIP(10), FromDIP(10));
 
   form_sizer->Add(
       new wxStaticText(this, -1, "Server:"),
@@ -30,17 +34,19 @@ ConnectionDialog::ConnectionDialog()
   form_sizer->Add(password_box_, wxSizerFlags().Expand());
 
   history_list_ = new wxListBox(this, -1);
-  for (const ConnectionDetails& details : GetTrackerConfig().connection_history) {
+  for (const ConnectionDetails& details :
+       GetTrackerConfig().connection_history) {
     wxString display_text;
-    display_text << details.ap_player;
+    display_text << wxString::FromUTF8(details.ap_player);
     display_text << " (";
-    display_text << details.ap_server;
+    display_text << wxString::FromUTF8(details.ap_server);
     display_text << ")";
 
     history_list_->Append(display_text);
   }
 
-  history_list_->Bind(wxEVT_LISTBOX, &ConnectionDialog::OnOldConnectionChosen, this);
+  history_list_->Bind(wxEVT_LISTBOX, &ConnectionDialog::OnOldConnectionChosen,
+                      this);
 
   wxBoxSizer* mid_sizer = new wxBoxSizer(wxHORIZONTAL);
   mid_sizer->Add(form_sizer, wxSizerFlags().Proportion(3).Expand());
@@ -52,7 +58,8 @@ ConnectionDialog::ConnectionDialog()
                      this, -1, "Enter the details to connect to Archipelago."),
                  wxSizerFlags().Align(wxALIGN_LEFT).DoubleBorder());
   top_sizer->Add(mid_sizer, wxSizerFlags().DoubleBorder().Expand());
-  top_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), wxSizerFlags().Border().Center());
+  top_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL),
+                 wxSizerFlags().Border().Center());
 
   SetSizerAndFit(top_sizer);
 
@@ -62,9 +69,10 @@ ConnectionDialog::ConnectionDialog()
 
 void ConnectionDialog::OnOldConnectionChosen(wxCommandEvent& e) {
   if (e.IsSelection()) {
-    const ConnectionDetails& details = GetTrackerConfig().connection_history.at(e.GetSelection());
-    server_box_->SetValue(details.ap_server);
-    player_box_->SetValue(details.ap_player);
-    password_box_->SetValue(details.ap_password);
+    const ConnectionDetails& details =
+        GetTrackerConfig().connection_history.at(e.GetSelection());
+    server_box_->SetValue(wxString::FromUTF8(details.ap_server));
+    player_box_->SetValue(wxString::FromUTF8(details.ap_player));
+    password_box_->SetValue(wxString::FromUTF8(details.ap_password));
   }
 }
@@ -14,12 +14,12 @@ class ConnectionDialog : public wxDialog {
  public:
   ConnectionDialog();
 
-  std::string GetServerValue() { return server_box_->GetValue().ToStdString(); }
+  std::string GetServerValue() { return server_box_->GetValue().utf8_string(); }
 
-  std::string GetPlayerValue() { return player_box_->GetValue().ToStdString(); }
+  std::string GetPlayerValue() { return player_box_->GetValue().utf8_string(); }
 
   std::string GetPasswordValue() {
-    return password_box_->GetValue().ToStdString();
+    return password_box_->GetValue().utf8_string();
   }
 
  private:
@@ -12,32 +12,6 @@
 
 namespace {
 
-LingoColor GetColorForString(const std::string &str) {
-  if (str == "black") {
-    return LingoColor::kBlack;
-  } else if (str == "red") {
-    return LingoColor::kRed;
-  } else if (str == "blue") {
-    return LingoColor::kBlue;
-  } else if (str == "yellow") {
-    return LingoColor::kYellow;
-  } else if (str == "orange") {
-    return LingoColor::kOrange;
-  } else if (str == "green") {
-    return LingoColor::kGreen;
-  } else if (str == "gray") {
-    return LingoColor::kGray;
-  } else if (str == "brown") {
-    return LingoColor::kBrown;
-  } else if (str == "purple") {
-    return LingoColor::kPurple;
-  } else {
-    TrackerLog(fmt::format("Invalid color: {}", str));
-
-    return LingoColor::kNone;
-  }
-}
-
 struct GameData {
   std::vector<Room> rooms_;
   std::vector<Door> doors_;
@@ -55,10 +29,10 @@ struct GameData {
   std::map<std::string, int> painting_by_id_;
 
   std::vector<int> door_definition_order_;
-  std::vector<int> room_definition_order_;
 
   std::map<std::string, int> room_by_painting_;
   std::map<int, int> room_by_sunwarp_;
+  std::map<int, int> panel_by_solve_index_;
 
   std::vector<int> achievement_panels_;
 
@@ -69,6 +43,8 @@ struct GameData {
   std::map<std::string, int> subway_item_by_painting_;
   std::map<SubwaySunwarp, int> subway_item_by_sunwarp_;
 
+  std::map<int, std::string> item_by_ap_id_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -84,7 +60,7 @@ struct GameData {
           ids_config["special_items"][color_name]) {
         std::string input_name = color_name;
         input_name[0] = std::tolower(input_name[0]);
-        ap_id_by_color_[GetColorForString(input_name)] =
+        ap_id_by_color_[GetLingoColorForString(input_name)] =
             ids_config["special_items"][color_name].as<int>();
       } else {
         TrackerLog(fmt::format("Missing AP item ID for color {}", color_name));
@@ -101,11 +77,20 @@ struct GameData {
     init_color_id("Brown");
     init_color_id("Gray");
 
+    if (ids_config["special_items"]) {
+      for (const auto& special_item_it : ids_config["special_items"])
+      {
+        item_by_ap_id_[special_item_it.second.as<int>()] =
+            special_item_it.first.as<std::string>();
+      }
+    }
+
     rooms_.reserve(lingo_config.size() * 2);
 
+    std::vector<int> panel_location_ids;
+
     for (const auto &room_it : lingo_config) {
       int room_id = AddOrGetRoom(room_it.first.as<std::string>());
-      room_definition_order_.push_back(room_id);
 
       for (const auto &entrance_it : room_it.second["entrances"]) {
         int from_room_id = AddOrGetRoom(entrance_it.first.as<std::string>());
@@ -181,12 +166,12 @@ struct GameData {
 
           if (panel_it.second["colors"]) {
             if (panel_it.second["colors"].IsScalar()) {
-              panels_[panel_id].colors.push_back(GetColorForString(
+              panels_[panel_id].colors.push_back(GetLingoColorForString(
                   panel_it.second["colors"].as<std::string>()));
             } else {
               for (const auto &color_node : panel_it.second["colors"]) {
                 panels_[panel_id].colors.push_back(
-                    GetColorForString(color_node.as<std::string>()));
+                    GetLingoColorForString(color_node.as<std::string>()));
               }
             }
           }
@@ -292,10 +277,11 @@ struct GameData {
               ids_config["panels"][rooms_[room_id].name] &&
               ids_config["panels"][rooms_[room_id].name]
                         [panels_[panel_id].name]) {
-            panels_[panel_id].ap_location_id =
-                ids_config["panels"][rooms_[room_id].name]
-                          [panels_[panel_id].name]
-                              .as<int>();
+            int location_id = ids_config["panels"][rooms_[room_id].name]
+                                        [panels_[panel_id].name]
+                                            .as<int>();
+            panels_[panel_id].ap_location_id = location_id;
+            panel_location_ids.push_back(location_id);
           } else {
             TrackerLog(fmt::format("Missing AP location ID for panel {} - {}",
                                    rooms_[room_id].name,
@@ -361,6 +347,9 @@ struct GameData {
                   ids_config["doors"][rooms_[room_id].name]
                             [doors_[door_id].name]["item"]
                                 .as<int>();
+
+              item_by_ap_id_[doors_[door_id].ap_item_id] =
+                  doors_[door_id].item_name;
             } else {
               TrackerLog(fmt::format("Missing AP item ID for door {} - {}",
                                      rooms_[room_id].name,
@@ -377,6 +366,9 @@ struct GameData {
               doors_[door_id].group_ap_item_id =
                   ids_config["door_groups"][doors_[door_id].group_name]
                       .as<int>();
+
+              item_by_ap_id_[doors_[door_id].group_ap_item_id] =
+                  doors_[door_id].group_name;
             } else {
               TrackerLog(fmt::format("Missing AP item ID for door group {}",
                                      doors_[door_id].group_name));
@@ -440,21 +432,50 @@ struct GameData {
           int panel_door_id =
               AddOrGetPanelDoor(rooms_[room_id].name, panel_door_name);
 
+          std::map<std::string, std::vector<std::string>> panel_per_room;
+          int num_panels = 0;
           for (const auto &panel_node : panel_door_it.second["panels"]) {
+            num_panels++;
+
             int panel_id = -1;
 
             if (panel_node.IsScalar()) {
               panel_id = AddOrGetPanel(rooms_[room_id].name,
                                        panel_node.as<std::string>());
+              
+              panel_per_room[rooms_[room_id].name].push_back(
+                  panel_node.as<std::string>());
             } else {
               panel_id = AddOrGetPanel(panel_node["room"].as<std::string>(),
                                        panel_node["panel"].as<std::string>());
+
+              panel_per_room[panel_node["room"].as<std::string>()].push_back(
+                  panel_node["panel"].as<std::string>());
             }
 
             Panel &panel = panels_[panel_id];
             panel.panel_door = panel_door_id;
           }
 
+          if (panel_door_it.second["item_name"]) {
+            panel_doors_[panel_door_id].item_name =
+                panel_door_it.second["item_name"].as<std::string>();
+          } else {
+            std::vector<std::string> room_strs;
+            for (const auto &[room_str, panels_str] : panel_per_room) {
+              room_strs.push_back(fmt::format(
+                  "{} - {}", room_str, hatkirby::implode(panels_str, ", ")));
+            }
+
+            if (num_panels == 1) {
+              panel_doors_[panel_door_id].item_name =
+                  fmt::format("{} (Panel)", room_strs[0]);
+            } else {
+              panel_doors_[panel_door_id].item_name = fmt::format(
+                  "{} (Panels)", hatkirby::implode(room_strs, " and "));
+            }
+          }
+
           if (ids_config["panel_doors"] &&
               ids_config["panel_doors"][rooms_[room_id].name] &&
               ids_config["panel_doors"][rooms_[room_id].name]
@@ -462,6 +483,9 @@ struct GameData {
             panel_doors_[panel_door_id].ap_item_id =
                 ids_config["panel_doors"][rooms_[room_id].name][panel_door_name]
                     .as<int>();
+
+            item_by_ap_id_[panel_doors_[panel_door_id].ap_item_id] =
+                panel_doors_[panel_door_id].item_name;
           } else {
             TrackerLog(fmt::format("Missing AP item ID for panel door {} - {}",
                                    rooms_[room_id].name, panel_door_name));
@@ -475,6 +499,9 @@ struct GameData {
                 ids_config["panel_groups"][panel_group]) {
               panel_doors_[panel_door_id].group_ap_item_id =
                   ids_config["panel_groups"][panel_group].as<int>();
+
+              item_by_ap_id_[panel_doors_[panel_door_id].group_ap_item_id] =
+                  panel_group;
             } else {
               TrackerLog(fmt::format(
                   "Missing AP item ID for panel door group {}", panel_group));
@@ -490,6 +517,13 @@ struct GameData {
           PaintingExit &painting_exit = paintings_[painting_id];
           painting_exit.room = room_id;
 
+          if (painting["display_name"]) {
+            painting_exit.display_name =
+                painting["display_name"].as<std::string>();
+          } else {
+            painting_exit.display_name = painting_exit.internal_id;
+          }
+
           if ((!painting["exit_only"] || !painting["exit_only"].as<bool>()) &&
               (!painting["disable"] || !painting["disable"].as<bool>())) {
             painting_exit.entrance = true;
@@ -531,6 +565,8 @@ struct GameData {
               ids_config["progression"][progressive_item_name]) {
             progressive_item_id =
                 ids_config["progression"][progressive_item_name].as<int>();
+
+            item_by_ap_id_[progressive_item_id] = progressive_item_name;
           } else {
             TrackerLog(fmt::format("Missing AP item ID for progressive item {}",
                                    progressive_item_name));
@@ -582,6 +618,21 @@ struct GameData {
       }
     }
 
+    // Determine the panel solve indices from the sorted location IDs.
+    std::sort(panel_location_ids.begin(), panel_location_ids.end());
+
+    std::map<int, int> solve_index_by_location_id;
+    for (int i = 0; i < panel_location_ids.size(); i++) {
+      solve_index_by_location_id[panel_location_ids[i]] = i;
+    }
+
+    for (Panel &panel : panels_) {
+      if (panel.ap_location_id != -1) {
+        panel.solve_index = solve_index_by_location_id[panel.ap_location_id];
+        panel_by_solve_index_[panel.solve_index] = panel.id;
+      }
+    }
+
     map_areas_.reserve(areas_config.size());
 
     std::map<std::string, int> fold_areas;
@@ -602,7 +653,7 @@ struct GameData {
     // Only locations for the panels are kept here.
     std::map<std::string, std::tuple<int, int>> locations_by_name;
 
-    for (const Panel &panel : panels_) {
+    for (Panel &panel : panels_) {
       int room_id = panel.room;
       std::string room_name = rooms_[room_id].name;
 
@@ -618,6 +669,8 @@ struct GameData {
           area_name = location_name.substr(0, divider_pos);
           section_name = location_name.substr(divider_pos + 3);
         }
+      } else {
+        panel.location_name = location_name;
       }
 
       if (fold_areas.count(area_name)) {
@@ -716,7 +769,8 @@ struct GameData {
         MapArea &map_area = map_areas_[area_id];
 
         for (int painting_id : room.paintings) {
-          const PaintingExit &painting_obj = paintings_.at(painting_id);
+          PaintingExit &painting_obj = paintings_.at(painting_id);
+          painting_obj.map_area = area_id;
           if (painting_obj.entrance) {
             map_area.paintings.push_back(painting_id);
           }
@@ -724,31 +778,6 @@ struct GameData {
       }
     }
 
-    // As a workaround for a generator bug in 0.5.1, we are going to remove the
-    // panel door requirement on panels that are defined earlier in the file than
-    // the panel door is. This results in logic that matches the generator, even
-    // if it is not true to how the game should work. This will be reverted once
-    // the logic bug is fixed and released.
-    // See: https://github.com/ArchipelagoMW/Archipelago/pull/4342
-    for (Panel& panel : panels_) {
-      if (panel.panel_door == -1) {
-        continue;
-      }
-      const PanelDoor &panel_door = panel_doors_[panel.panel_door];
-      for (int room_id : room_definition_order_) {
-        if (room_id == panel_door.room) {
-          // The panel door was defined first (or at the same time as the panel),
-          // so we're good.
-          break;
-        } else if (room_id == panel.room) {
-          // The panel was defined first, so we have to pretend the panel door is
-          // not required for this panel.
-          panel.panel_door = -1;
-          break;
-        }
-      }
-    }
-
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
       TrackerLog(fmt::format("Area data not found for: {}", area));
@@ -768,13 +797,10 @@ struct GameData {
                                         subway_it["door"].as<std::string>());
       }
 
-      if (subway_it["paintings"]) {
-        for (const auto &painting_it : subway_it["paintings"]) {
-          std::string painting_id = painting_it.as<std::string>();
-
-          subway_item.paintings.push_back(painting_id);
-          subway_item_by_painting_[painting_id] = subway_item.id;
-        }
+      if (subway_it["painting"]) {
+        std::string painting_id = subway_it["painting"].as<std::string>();
+        subway_item.painting = painting_id;
+        subway_item_by_painting_[painting_id] = subway_item.id;
       }
 
       if (subway_it["tags"]) {
@@ -821,6 +847,10 @@ struct GameData {
         subway_item.special = subway_it["special"].as<std::string>();
       }
 
+      if (subway_it["tilted"]) {
+        subway_item.tilted = subway_it["tilted"].as<bool>();
+      }
+
       subway_items_.push_back(subway_item);
     }
 
@@ -880,7 +910,7 @@ struct GameData {
     if (!panel_doors_by_id_.count(full_name)) {
       int panel_door_id = panel_doors_.size();
       panel_doors_by_id_[full_name] = panel_door_id;
-      panel_doors_.push_back({.room = AddOrGetRoom(room)});
+      panel_doors_.push_back({});
     }
 
     return panel_doors_by_id_[full_name];
@@ -953,6 +983,14 @@ const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
 
+int GD_GetPanelBySolveIndex(int solve_index) {
+  return GetState().panel_by_solve_index_.at(solve_index);
+}
+
+const std::vector<PaintingExit> &GD_GetPaintings() {
+  return GetState().paintings_;
+}
+
 const PaintingExit &GD_GetPaintingExit(int painting_id) {
   return GetState().paintings_.at(painting_id);
 }
@@ -995,3 +1033,38 @@ std::optional<int> GD_GetSubwayItemForPainting(const std::string &painting_id) {
 int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
   return GetState().subway_item_by_sunwarp_.at(sunwarp);
 }
+
+std::string GD_GetItemName(int id) {
+  auto it = GetState().item_by_ap_id_.find(id);
+  if (it != GetState().item_by_ap_id_.end()) {
+    return it->second;
+  } else {
+    return "Unknown";
+  }
+}
+
+LingoColor GetLingoColorForString(const std::string &str) {
+  if (str == "black") {
+    return LingoColor::kBlack;
+  } else if (str == "red") {
+    return LingoColor::kRed;
+  } else if (str == "blue") {
+    return LingoColor::kBlue;
+  } else if (str == "yellow") {
+    return LingoColor::kYellow;
+  } else if (str == "orange") {
+    return LingoColor::kOrange;
+  } else if (str == "green") {
+    return LingoColor::kGreen;
+  } else if (str == "gray") {
+    return LingoColor::kGray;
+  } else if (str == "brown") {
+    return LingoColor::kBrown;
+  } else if (str == "purple") {
+    return LingoColor::kPurple;
+  } else {
+    TrackerLog(fmt::format("Invalid color: {}", str));
+
+    return LingoColor::kNone;
+  }
+}
@@ -57,6 +57,7 @@ struct Panel {
   int ap_location_id = -1;
   bool hunt = false;
   int panel_door = -1;
+  int solve_index = -1;
 };
 
 struct ProgressiveRequirement {
@@ -85,10 +86,10 @@ struct Door {
 };
 
 struct PanelDoor {
-  int room;
   int ap_item_id = -1;
   int group_ap_item_id = -1;
   std::vector<ProgressiveRequirement> progressives;
+  std::string item_name;
 };
 
 struct Exit {
@@ -102,8 +103,10 @@ struct PaintingExit {
   int id;
   int room;
   std::string internal_id;
+  std::string display_name;
   std::optional<int> door;
   bool entrance = false;
+  int map_area;
 };
 
 struct Room {
@@ -154,8 +157,9 @@ struct SubwayItem {
   int id;
   int x;
   int y;
+  bool tilted = false;
   std::optional<int> door;
-  std::vector<std::string> paintings;
+  std::optional<std::string> painting;
   std::vector<std::string> tags; // 2-way teleports
   std::vector<std::string> entrances; // teleport entrances
   std::vector<std::string> exits; // teleport exits
@@ -173,7 +177,9 @@ 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_GetPanelBySolveIndex(int solve_index);
 const PanelDoor& GD_GetPanelDoor(int panel_door_id);
+const std::vector<PaintingExit>& GD_GetPaintings();
 const PaintingExit& GD_GetPaintingExit(int painting_id);
 int GD_GetPaintingByName(const std::string& name);
 const std::vector<int>& GD_GetAchievementPanels();
@@ -184,5 +190,8 @@ const std::vector<SubwayItem>& GD_GetSubwayItems();
 const SubwayItem& GD_GetSubwayItem(int id);
 std::optional<int> GD_GetSubwayItemForPainting(const std::string& painting_id);
 int GD_GetSubwayItemForSunwarp(const SubwaySunwarp& sunwarp);
+std::string GD_GetItemName(int id);
+
+LingoColor GetLingoColorForString(const std::string& str);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -26,17 +26,19 @@ std::string GetAbsolutePath(std::string_view path) {
   return (GetExecutableDirectory() / path).string();
 }
 
-bool IsLocationWinCondition(const Location& location) {
+std::string GetWinCondition() {
   switch (AP_GetVictoryCondition()) {
     case kTHE_END:
-      return location.ap_location_name ==
-             "Orange Tower Seventh Floor - THE END";
+      return "Orange Tower Seventh Floor - THE END";
     case kTHE_MASTER:
-      return location.ap_location_name ==
-             "Orange Tower Seventh Floor - THE MASTER";
+      return "Orange Tower Seventh Floor - THE MASTER";
     case kLEVEL_2:
-      return location.ap_location_name == "Second Room - LEVEL 2";
+      return "Second Room - LEVEL 2";
     case kPILGRIMAGE:
-      return location.ap_location_name == "Pilgrim Antechamber - PILGRIM";
+      return "Pilgrim Antechamber - PILGRIM";
   }
 }
+
+bool IsLocationWinCondition(const Location& location) {
+  return location.ap_location_name == GetWinCondition();
+}
@@ -10,6 +10,8 @@ const std::filesystem::path& GetExecutableDirectory();
 
 std::string GetAbsolutePath(std::string_view path);
 
+std::string GetWinCondition();
+
 bool IsLocationWinCondition(const Location& location);
 
 #endif /* end of include guard: GLOBAL_H_44945DBA */
@@ -1,84 +0,0 @@
-// Godot save decoder algorithm by Chris Souvey.
-
-#include "godot_variant.h"
-
-#include <algorithm>
-#include <charconv>
-#include <cstddef>
-#include <cstdint>
-#include <fstream>
-#include <string>
-#include <tuple>
-#include <variant>
-#include <vector>
-
-namespace {
-
-uint16_t ReadUint16(std::basic_istream<char>& stream) {
-  uint16_t result;
-  stream.read(reinterpret_cast<char*>(&result), 2);
-  return result;
-}
-
-uint32_t ReadUint32(std::basic_istream<char>& stream) {
-  uint32_t result;
-  stream.read(reinterpret_cast<char*>(&result), 4);
-  return result;
-}
-
-GodotVariant ParseVariant(std::basic_istream<char>& stream) {
-  uint16_t type = ReadUint16(stream);
-  stream.ignore(2);
-
-  switch (type) {
-    case 1: {
-      // bool
-      bool boolval = (ReadUint32(stream) == 1);
-      return {boolval};
-    }
-    case 15: {
-      // nodepath
-      uint32_t name_length = ReadUint32(stream) & 0x7fffffff;
-      uint32_t subname_length = ReadUint32(stream) & 0x7fffffff;
-      uint32_t flags = ReadUint32(stream);
-
-      std::vector<std::string> result;
-      for (size_t i = 0; i < name_length + subname_length; i++) {
-        uint32_t char_length = ReadUint32(stream);
-        uint32_t padded_length = (char_length % 4 == 0)
-                                     ? char_length
-                                     : (char_length + 4 - (char_length % 4));
-        std::vector<char> next_bytes(padded_length);
-        stream.read(next_bytes.data(), padded_length);
-        std::string next_piece;
-        std::copy(next_bytes.begin(),
-                  std::next(next_bytes.begin(), char_length),
-                  std::back_inserter(next_piece));
-        result.push_back(next_piece);
-      }
-
-      return {result};
-    }
-    case 19: {
-      // array
-      uint32_t length = ReadUint32(stream) & 0x7fffffff;
-      std::vector<GodotVariant> result;
-      for (size_t i = 0; i < length; i++) {
-        result.push_back(ParseVariant(stream));
-      }
-      return {result};
-    }
-    default: {
-      // eh
-      return {std::monostate{}};
-    }
-  }
-}
-
-}  // namespace
-
-GodotVariant ParseGodotFile(std::string filename) {
-  std::ifstream file_stream(filename, std::ios_base::binary);
-  file_stream.ignore(4);
-  return ParseVariant(file_stream);
-}
@@ -1,28 +0,0 @@
-#ifndef GODOT_VARIANT_H_ED7F2EB6
-#define GODOT_VARIANT_H_ED7F2EB6
-
-#include <string>
-#include <variant>
-#include <vector>
-
-struct GodotVariant {
-  using value_type = std::variant<std::monostate, bool, std::vector<std::string>, std::vector<GodotVariant>>;
-
-  value_type value;
-
-  GodotVariant(value_type v) : value(v) {}
-
-  bool AsBool() const { return std::get<bool>(value); }
-
-  const std::vector<std::string>& AsNodePath() const {
-    return std::get<std::vector<std::string>>(value);
-  }
-
-  const std::vector<GodotVariant>& AsArray() const {
-    return std::get<std::vector<GodotVariant>>(value);
-  }
-};
-
-GodotVariant ParseGodotFile(std::string filename);
-
-#endif /* end of include guard: GODOT_VARIANT_H_ED7F2EB6 */
@@ -0,0 +1,22 @@
+#include "icons.h"
+
+#include "global.h"
+
+const wxBitmap* IconCache::GetIcon(const std::string& filename, wxSize size) {
+  std::tuple<std::string, int, int> key = {filename, size.x, size.y};
+
+  if (!icons_.count(key)) {
+    icons_[key] =
+        wxBitmap(wxImage(GetAbsolutePath(filename).c_str(),
+                         wxBITMAP_TYPE_PNG)
+                     .Scale(size.x, size.y));
+  }
+
+  return &icons_.at(key);
+}
+
+static IconCache* ICON_CACHE_INSTANCE = nullptr;
+
+void SetTheIconCache(IconCache* instance) { ICON_CACHE_INSTANCE = instance; }
+
+IconCache& GetTheIconCache() { return *ICON_CACHE_INSTANCE; }
@@ -0,0 +1,25 @@
+#ifndef ICONS_H_B95159A6
+#define ICONS_H_B95159A6
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <map>
+#include <string>
+#include <tuple>
+
+class IconCache {
+ public:
+  const wxBitmap* GetIcon(const std::string& filename, wxSize size);
+
+ private:
+  std::map<std::tuple<std::string, int, int>, wxBitmap> icons_;
+};
+
+void SetTheIconCache(IconCache* instance);
+IconCache& GetTheIconCache();
+
+#endif /* end of include guard: ICONS_H_B95159A6 */
@@ -12,13 +12,14 @@ IpcDialog::IpcDialog() : wxDialog(nullptr, wxID_ANY, "Connect to game") {
     address_value = GetTrackerConfig().ipc_address;
   }
 
-  address_box_ =
-      new wxTextCtrl(this, -1, address_value, wxDefaultPosition, {300, -1});
+  address_box_ = new wxTextCtrl(this, -1, wxString::FromUTF8(address_value),
+                                wxDefaultPosition, FromDIP(wxSize{300, -1}));
 
   wxButton* reset_button = new wxButton(this, -1, "Use Default");
   reset_button->Bind(wxEVT_BUTTON, &IpcDialog::OnResetClicked, this);
 
-  wxFlexGridSizer* form_sizer = new wxFlexGridSizer(3, 10, 10);
+  wxFlexGridSizer* form_sizer =
+      new wxFlexGridSizer(3, FromDIP(10), FromDIP(10));
   form_sizer->Add(
       new wxStaticText(this, -1, "Address:"),
       wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
@@ -13,7 +13,7 @@ class IpcDialog : public wxDialog {
  public:
   IpcDialog();
 
-  std::string GetIpcAddress() { return address_box_->GetValue().ToStdString(); }
+  std::string GetIpcAddress() { return address_box_->GetValue().utf8_string(); }
 
  private:
   void OnResetClicked(wxCommandEvent& event);
@@ -39,7 +39,6 @@ struct IPCState {
   std::string game_ap_user;
 
   std::optional<std::tuple<int, int>> player_position;
-  std::set<std::string> solved_panels;
 
   // Thread state
   std::unique_ptr<wswrap::WS> ws;
@@ -103,12 +102,6 @@ struct IPCState {
     return player_position;
   }
 
-  std::set<std::string> GetSolvedPanels() {
-    std::lock_guard state_guard(state_mutex);
-
-    return solved_panels;
-  }
-
  private:
   void Thread() {
     for (;;) {
@@ -134,7 +127,6 @@ struct IPCState {
         game_ap_user.clear();
 
         player_position = std::nullopt;
-        solved_panels.clear();
 
         if (address.empty()) {
           initialized = false;
@@ -273,7 +265,6 @@ struct IPCState {
 
       slot_matches = false;
       player_position = std::nullopt;
-      solved_panels.clear();
     }
   }
 
@@ -313,15 +304,7 @@ struct IPCState {
       player_position =
           std::make_tuple<int, int>(msg["position"]["x"], msg["position"]["z"]);
 
-      tracker_frame->RedrawPosition();
-    } else if (msg["cmd"] == "SolvePanels") {
-      std::lock_guard state_guard(state_mutex);
-
-      for (std::string panel : msg["panels"]) {
-        solved_panels.insert(std::move(panel));
-      }
-
-      tracker_frame->UpdateIndicators(kUPDATE_ONLY_PANELS);
+      tracker_frame->UpdateIndicators(StateUpdate{.player_position = true});
     }
   }
 
@@ -382,7 +365,3 @@ bool IPC_IsConnected() { return GetState().IsConnected(); }
 std::optional<std::tuple<int, int>> IPC_GetPlayerPosition() {
   return GetState().GetPlayerPosition();
 }
-
-std::set<std::string> IPC_GetSolvedPanels() {
-  return GetState().GetSolvedPanels();
-}
@@ -20,6 +20,4 @@ bool IPC_IsConnected();
 
 std::optional<std::tuple<int, int>> IPC_GetPlayerPosition();
 
-std::set<std::string> IPC_GetSolvedPanels();
-
 #endif /* end of include guard: IPC_STATE_H_6B3B0958 */
@@ -0,0 +1,145 @@
+#include "items_pane.h"
+
+#include <map>
+
+namespace {
+
+enum SortInstruction {
+  SI_NONE = 0,
+  SI_ASC = 1 << 0,
+  SI_DESC = 1 << 1,
+  SI_NAME = 1 << 2,
+  SI_AMOUNT = 1 << 3,
+  SI_ORDER = 1 << 4,
+};
+
+inline SortInstruction operator|(SortInstruction lhs, SortInstruction rhs) {
+  return static_cast<SortInstruction>(static_cast<int>(lhs) |
+                                      static_cast<int>(rhs));
+}
+
+template <typename T>
+int ItemCompare(const T& lhs, const T& rhs, bool ascending) {
+  if (lhs < rhs) {
+    return ascending ? -1 : 1;
+  } else if (lhs > rhs) {
+    return ascending ? 1 : -1;
+  } else {
+    return 0;
+  }
+}
+
+int wxCALLBACK RowCompare(wxIntPtr item1, wxIntPtr item2, wxIntPtr sortData) {
+  const ItemState& lhs = *reinterpret_cast<const ItemState*>(item1);
+  const ItemState& rhs = *reinterpret_cast<const ItemState*>(item2);
+  SortInstruction instruction = static_cast<SortInstruction>(sortData);
+
+  bool ascending = (instruction & SI_ASC) != 0;
+  if ((instruction & SI_NAME) != 0) {
+    return ItemCompare(lhs.name, rhs.name, ascending);
+  } else if ((instruction & SI_AMOUNT) != 0) {
+    return ItemCompare(lhs.amount, rhs.amount, ascending);
+  } else if ((instruction & SI_ORDER) != 0) {
+    return ItemCompare(lhs.index, rhs.index, ascending);
+  } else {
+    return 0;
+  }
+}
+
+}  // namespace
+
+ItemsPane::ItemsPane(wxWindow* parent)
+    : wxListView(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                 wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_HRULES) {
+  AppendColumn("Item", wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER);
+  AppendColumn("Amount", wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER);
+  AppendColumn("Order", wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER);
+
+  Bind(wxEVT_LIST_COL_CLICK, &ItemsPane::OnColClick, this);
+  Bind(wxEVT_DPI_CHANGED, &ItemsPane::OnDPIChanged, this);
+}
+
+void ItemsPane::ResetIndicators() {
+  DeleteAllItems();
+  items_.clear();
+}
+
+void ItemsPane::UpdateIndicators(const std::vector<ItemState>& items) {
+  std::map<std::string, ItemState> items_by_name;
+
+  for (const ItemState& item : items) {
+    items_by_name[item.name] = item;
+  }
+
+  for (int i = 0; i < GetItemCount(); i++) {
+    std::string item_name = GetItemText(i).utf8_string();
+    auto it = items_by_name.find(item_name);
+
+    if (it != items_by_name.end()) {
+      SetItem(i, 1, std::to_string(it->second.amount));
+      SetItem(i, 2, std::to_string(it->second.index));
+
+      *reinterpret_cast<ItemState*>(GetItemData(i)) = it->second;
+
+      items_by_name.erase(item_name);
+    }
+  }
+
+  for (const auto& [name, item] : items_by_name) {
+    int i = InsertItem(GetItemCount(), name);
+    SetItem(i, 1, std::to_string(item.amount));
+    SetItem(i, 2, std::to_string(item.index));
+
+    auto item_ptr = std::make_unique<ItemState>(item);
+    SetItemPtrData(i, reinterpret_cast<wxUIntPtr>(item_ptr.get()));
+    items_.push_back(std::move(item_ptr));
+  }
+
+  SetColumnWidth(0, wxLIST_AUTOSIZE);
+  SetColumnWidth(1, wxLIST_AUTOSIZE_USEHEADER);
+  SetColumnWidth(2, wxLIST_AUTOSIZE_USEHEADER);
+
+  if (GetSortIndicator() != -1) {
+    DoSort(GetSortIndicator(), IsAscendingSortIndicator());
+  }
+}
+
+void ItemsPane::OnColClick(wxListEvent& event) {
+  int col = event.GetColumn();
+  if (col == -1) {
+    return;
+  }
+
+  bool ascending = GetUpdatedAscendingSortIndicator(col);
+
+  DoSort(col, ascending);
+}
+
+void ItemsPane::OnDPIChanged(wxDPIChangedEvent& event) {
+  SetColumnWidth(0, wxLIST_AUTOSIZE);
+  SetColumnWidth(1, wxLIST_AUTOSIZE_USEHEADER);
+  SetColumnWidth(2, wxLIST_AUTOSIZE_USEHEADER);
+
+  event.Skip();
+}
+
+void ItemsPane::DoSort(int col, bool ascending) {
+  SortInstruction instruction = SI_NONE;
+  if (ascending) {
+    instruction = instruction | SI_ASC;
+  } else {
+    instruction = instruction | SI_DESC;
+  }
+
+  if (col == 0) {
+    instruction = instruction | SI_NAME;
+  } else if (col == 1) {
+    instruction = instruction | SI_AMOUNT;
+  } else if (col == 2) {
+    instruction = instruction | SI_ORDER;
+  }
+
+  if (SortItems(RowCompare, instruction)) {
+    ShowSortIndicator(col, ascending);
+  }
+}
@@ -0,0 +1,33 @@
+#ifndef ITEMS_PANE_H_EB637EE3
+#define ITEMS_PANE_H_EB637EE3
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <wx/listctrl.h>
+
+#include <memory>
+#include <vector>
+
+#include "ap_state.h"
+
+class ItemsPane : public wxListView {
+ public:
+  explicit ItemsPane(wxWindow* parent);
+
+  void ResetIndicators();
+  void UpdateIndicators(const std::vector<ItemState>& items);
+
+ private:
+  void OnColClick(wxListEvent& event);
+  void OnDPIChanged(wxDPIChangedEvent& event);
+
+  void DoSort(int col, bool ascending);
+
+  std::vector<std::unique_ptr<ItemState>> items_;
+};
+
+#endif /* end of include guard: ITEMS_PANE_H_EB637EE3 */
@@ -0,0 +1,37 @@
+#include "log_dialog.h"
+
+#include "logger.h"
+
+wxDEFINE_EVENT(LOG_MESSAGE, wxCommandEvent);
+
+LogDialog::LogDialog(wxWindow* parent)
+    : wxDialog(parent, wxID_ANY, "Debug Log", wxDefaultPosition, wxDefaultSize,
+               wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER) {
+  SetSize(FromDIP(wxSize{512, 280}));
+
+  text_area_ =
+      new wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize,
+                     wxTE_MULTILINE | wxTE_READONLY | wxTE_DONTWRAP);
+  text_area_->SetValue(TrackerReadPastLog());
+
+  wxBoxSizer* top_sizer = new wxBoxSizer(wxVERTICAL);
+  top_sizer->Add(text_area_,
+                 wxSizerFlags().DoubleBorder().Expand().Proportion(1));
+
+  SetSizer(top_sizer);
+
+  Bind(LOG_MESSAGE, &LogDialog::OnLogMessage, this);
+}
+
+void LogDialog::LogMessage(const std::string& message) {
+  wxCommandEvent* event = new wxCommandEvent(LOG_MESSAGE);
+  event->SetString(message);
+  QueueEvent(event);
+}
+
+void LogDialog::OnLogMessage(wxCommandEvent& event) {
+  if (!text_area_->IsEmpty()) {
+    text_area_->AppendText("\n");
+  }
+  text_area_->AppendText(event.GetString());
+}
@@ -0,0 +1,24 @@
+#ifndef LOG_DIALOG_H_EEFD45B6
+#define LOG_DIALOG_H_EEFD45B6
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+wxDECLARE_EVENT(LOG_MESSAGE, wxCommandEvent);
+
+class LogDialog : public wxDialog {
+ public:
+  explicit LogDialog(wxWindow* parent);
+
+  void LogMessage(const std::string& message);
+
+ private:
+  void OnLogMessage(wxCommandEvent& event);
+
+  wxTextCtrl* text_area_;
+};
+
+#endif /* end of include guard: LOG_DIALOG_H_EEFD45B6 */
@@ -3,8 +3,10 @@
 #include <chrono>
 #include <fstream>
 #include <mutex>
+#include <sstream>
 
 #include "global.h"
+#include "log_dialog.h"
 
 namespace {
 
@@ -14,19 +16,49 @@ class Logger {
 
   void LogLine(const std::string& text) {
     std::lock_guard guard(file_mutex_);
-    logfile_ << "[" << std::chrono::system_clock::now() << "] " << text
-             << std::endl;
+    std::ostringstream line;
+    line << "[" << std::chrono::system_clock::now() << "] " << text;
+
+    logfile_ << line.str() << std::endl;
     logfile_.flush();
+
+    if (log_dialog_ != nullptr) {
+      log_dialog_->LogMessage(line.str());
+    }
+  }
+
+  std::string GetContents() {
+    std::lock_guard guard(file_mutex_);
+
+    std::ifstream file_in(GetAbsolutePath("debug.log"));
+    std::ostringstream buffer;
+    buffer << file_in.rdbuf();
+
+    return buffer.str();
+  }
+
+  void SetLogDialog(LogDialog* log_dialog) {
+    std::lock_guard guard(file_mutex_);
+    log_dialog_ = log_dialog;
   }
 
  private:
   std::ofstream logfile_;
   std::mutex file_mutex_;
+  LogDialog* log_dialog_ = nullptr;
 };
 
+Logger& GetLogger() {
+  static Logger* instance = new Logger();
+  return *instance;
+}
+
 }  // namespace
 
-void TrackerLog(std::string text) {
-  static Logger* instance = new Logger();
-  instance->LogLine(text);
+void TrackerLog(std::string text) { GetLogger().LogLine(text); }
+
+std::string TrackerReadPastLog() { return GetLogger().GetContents(); }
+
+void TrackerSetLogDialog(LogDialog* log_dialog) {
+  GetLogger().SetLogDialog(log_dialog);
 }
@@ -3,6 +3,12 @@
 
 #include <string>
 
+class LogDialog;
+
 void TrackerLog(std::string message);
 
+std::string TrackerReadPastLog();
+
+void TrackerSetLogDialog(LogDialog* log_dialog);
+
 #endif /* end of include guard: LOGGER_H_9BDD07EA */
@@ -10,7 +10,7 @@
 
 class TrackerApp : public wxApp {
  public:
-  virtual bool OnInit() {
+  virtual bool OnInit() override {
     GetTrackerConfig().Load();
 
     TrackerFrame *frame = new TrackerFrame();
@@ -0,0 +1,71 @@
+#include "options_pane.h"
+
+#include "ap_state.h"
+
+namespace {
+
+const char* kDoorShuffleLabels[] = {"None", "Panels", "Doors"};
+const char* kLocationChecksLabels[] = {"Normal", "Reduced", "Insanity"};
+const char* kPanelShuffleLabels[] = {"None", "Rearrange"};
+const char* kVictoryConditionLabels[] = {"The End", "The Master", "Level 2",
+                                         "Pilgrimage"};
+const char* kSunwarpAccessLabels[] = {"Normal", "Disabled", "Unlock",
+                                      "Individual", "Progressive"};
+
+void AddRow(wxDataViewListCtrl* list, const std::string& text) {
+  wxVector<wxVariant> data;
+  data.push_back(wxVariant{text + ": "});
+  data.push_back(wxVariant{""});
+  list->AppendItem(data);
+}
+
+}  // namespace
+
+OptionsPane::OptionsPane(wxWindow* parent)
+    : wxDataViewListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                         wxDV_ROW_LINES) {
+  AppendTextColumn("Name", wxDATAVIEW_CELL_INERT, wxCOL_WIDTH_AUTOSIZE);
+  AppendTextColumn("Value");
+  AddRow(this, "Shuffle Doors");
+  AddRow(this, "Group Doors");
+  AddRow(this, "Location Checks");
+  AddRow(this, "Shuffle Colors");
+  AddRow(this, "Shuffle Panels");
+  AddRow(this, "Shuffle Paintings");
+  AddRow(this, "Victory Condition");
+  AddRow(this, "Early Color Hallways");
+  AddRow(this, "Shuffle Postgame");
+  AddRow(this, "Enable Pilgrimage");
+  AddRow(this, "Pilgrimage Roof Access");
+  AddRow(this, "Pilgrimage Paintings");
+  AddRow(this, "Sunwarp Access");
+  AddRow(this, "Shuffle Sunwarps");
+  AddRow(this, "Mastery Achievements");
+  AddRow(this, "Level 2 Requirement");
+}
+
+void OptionsPane::OnConnect() {
+  SetTextValue(kDoorShuffleLabels[static_cast<size_t>(AP_GetDoorShuffleMode())],
+               0, 1);
+  SetTextValue(AP_AreDoorsGrouped() ? "Yes" : "No", 1, 1);
+  SetTextValue(
+      kLocationChecksLabels[static_cast<size_t>(AP_GetLocationsChecks())], 2,
+      1);
+  SetTextValue(AP_IsColorShuffle() ? "Yes" : "No", 3, 1);
+  SetTextValue(
+      kPanelShuffleLabels[static_cast<size_t>(AP_GetPanelShuffleMode())], 4, 1);
+  SetTextValue(AP_IsPaintingShuffle() ? "Yes" : "No", 5, 1);
+  SetTextValue(
+      kVictoryConditionLabels[static_cast<size_t>(AP_GetVictoryCondition())], 6,
+      1);
+  SetTextValue(AP_HasEarlyColorHallways() ? "Yes" : "No", 7, 1);
+  SetTextValue(AP_IsPostgameShuffle() ? "Yes" : "No", 8, 1);
+  SetTextValue(AP_IsPilgrimageEnabled() ? "Yes" : "No", 9, 1);
+  SetTextValue(AP_DoesPilgrimageAllowRoofAccess() ? "Yes" : "No", 10, 1);
+  SetTextValue(AP_DoesPilgrimageAllowPaintings() ? "Yes" : "No", 11, 1);
+  SetTextValue(kSunwarpAccessLabels[static_cast<size_t>(AP_GetSunwarpAccess())],
+               12, 1);
+  SetTextValue(AP_IsSunwarpShuffle() ? "Yes" : "No", 13, 1);
+  SetTextValue(std::to_string(AP_GetMasteryRequirement()), 14, 1);
+  SetTextValue(std::to_string(AP_GetLevel2Requirement()), 15, 1);
+}
@@ -0,0 +1,19 @@
+#ifndef OPTIONS_PANE_H_026A0EC0
+#define OPTIONS_PANE_H_026A0EC0
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <wx/dataview.h>
+
+class OptionsPane : public wxDataViewListCtrl {
+ public:
+  explicit OptionsPane(wxWindow* parent);
+
+  void OnConnect();
+};
+
+#endif /* end of include guard: OPTIONS_PANE_H_026A0EC0 */
@@ -0,0 +1,86 @@
+#include "paintings_pane.h"
+
+#include <fmt/core.h>
+#include <wx/dataview.h>
+
+#include <map>
+#include <set>
+
+#include "ap_state.h"
+#include "game_data.h"
+#include "tracker_state.h"
+
+namespace {
+
+std::string GetPaintingDisplayName(const std::string& id) {
+  const PaintingExit& painting = GD_GetPaintingExit(GD_GetPaintingByName(id));
+  const MapArea& map_area = GD_GetMapArea(painting.map_area);
+
+  return fmt::format("{} - {}", map_area.name, painting.display_name);
+}
+
+}  // namespace
+
+PaintingsPane::PaintingsPane(wxWindow* parent) : wxPanel(parent, wxID_ANY) {
+  wxStaticText* label = new wxStaticText(
+      this, wxID_ANY, "Shuffled paintings grouped by destination:");
+  tree_ctrl_ = new wxDataViewTreeCtrl(this, wxID_ANY);
+
+  reveal_btn_ = new wxButton(this, wxID_ANY, "Reveal shuffled paintings");
+  reveal_btn_->Disable();
+
+  wxBoxSizer* top_sizer = new wxBoxSizer(wxVERTICAL);
+  top_sizer->Add(label, wxSizerFlags().Border());
+  top_sizer->Add(tree_ctrl_, wxSizerFlags().Expand().Proportion(1));
+  top_sizer->Add(reveal_btn_, wxSizerFlags().Border().Expand());
+
+  SetSizerAndFit(top_sizer);
+
+  tree_ctrl_->Bind(wxEVT_DATAVIEW_ITEM_START_EDITING,
+                   &PaintingsPane::OnStartEditingCell, this);
+  reveal_btn_->Bind(wxEVT_BUTTON, &PaintingsPane::OnClickRevealPaintings, this);
+}
+
+void PaintingsPane::ResetIndicators() {
+  tree_ctrl_->DeleteAllItems();
+  reveal_btn_->Enable(AP_IsPaintingShuffle());
+}
+
+void PaintingsPane::UpdateIndicators(const std::vector<std::string>&) {
+  // TODO: Optimize this by using the paintings delta.
+
+  tree_ctrl_->DeleteAllItems();
+
+  std::map<std::string, std::set<std::string>> grouped_paintings;
+
+  for (const auto& [from, to] : AP_GetPaintingMapping()) {
+    if (IsPaintingReachable(GD_GetPaintingByName(from)) &&
+        AP_IsPaintingChecked(from)) {
+      grouped_paintings[GetPaintingDisplayName(to)].insert(
+          GetPaintingDisplayName(from));
+    }
+  }
+
+  for (const auto& [to, froms] : grouped_paintings) {
+    wxDataViewItem tree_branch =
+        tree_ctrl_->AppendContainer(wxDataViewItem(0), to);
+
+    for (const std::string& from : froms) {
+      tree_ctrl_->AppendItem(tree_branch, from);
+    }
+  }
+}
+
+void PaintingsPane::OnClickRevealPaintings(wxCommandEvent& event) {
+  if (wxMessageBox("Clicking yes will reveal the mapping between all shuffled "
+                   "paintings. This is usually considered a spoiler, and is "
+                   "likely not allowed during competitions. This action is not "
+                   "reversible. Are you sure you want to proceed?",
+                   "Warning", wxYES_NO | wxICON_WARNING) == wxNO) {
+    return;
+  }
+
+  AP_RevealPaintings();
+}
+
+void PaintingsPane::OnStartEditingCell(wxDataViewEvent& event) { event.Veto(); }
@@ -0,0 +1,28 @@
+#ifndef PAINTINGS_PANE_H_815370D2
+#define PAINTINGS_PANE_H_815370D2
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+class wxDataViewEvent;
+class wxDataViewTreeCtrl;
+
+class PaintingsPane : public wxPanel {
+ public:
+  explicit PaintingsPane(wxWindow* parent);
+
+  void ResetIndicators();
+  void UpdateIndicators(const std::vector<std::string>& paintings);
+
+ private:
+  void OnClickRevealPaintings(wxCommandEvent& event);
+  void OnStartEditingCell(wxDataViewEvent& event);
+
+  wxDataViewTreeCtrl* tree_ctrl_;
+  wxButton* reveal_btn_;
+};
+
+#endif /* end of include guard: PAINTINGS_PANE_H_815370D2 */
@@ -0,0 +1,131 @@
+#include "report_popup.h"
+
+#include <wx/dcbuffer.h>
+
+#include <map>
+#include <string>
+
+#include "global.h"
+#include "icons.h"
+#include "tracker_state.h"
+
+ReportPopup::ReportPopup(wxWindow* parent)
+    : wxScrolledCanvas(parent, wxID_ANY) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
+  LoadIcons();
+
+  // TODO: This is slow on high-DPI screens.
+  SetScrollRate(5, 5);
+
+  SetBackgroundColour(*wxBLACK);
+  Hide();
+
+  Bind(wxEVT_PAINT, &ReportPopup::OnPaint, this);
+  Bind(wxEVT_DPI_CHANGED, &ReportPopup::OnDPIChanged, this);
+}
+
+void ReportPopup::SetDoorId(int door_id) {
+  door_id_ = door_id;
+
+  ResetIndicators();
+}
+
+void ReportPopup::Reset() {
+  door_id_ = -1;
+}
+
+void ReportPopup::ResetIndicators() {
+  if (door_id_ == -1) {
+    return;
+  }
+
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  const std::map<std::string, bool>& report = GetDoorRequirements(door_id_);
+
+  wxMemoryDC mem_dc;
+  mem_dc.SetFont(the_font);
+
+  int acc_height = FromDIP(10);
+  int col_width = 0;
+
+  for (const auto& [text, obtained] : report) {
+    wxSize item_extent = mem_dc.GetTextExtent(text);
+    int item_height =
+        std::max(FromDIP(32), item_extent.GetHeight()) + FromDIP(10);
+    acc_height += item_height;
+
+    if (item_extent.GetWidth() > col_width) {
+      col_width = item_extent.GetWidth();
+    }
+  }
+
+  int item_width = col_width + FromDIP(10 + 32);
+  full_width_ = item_width + FromDIP(20);
+  full_height_ = acc_height;
+
+  Fit();
+  SetVirtualSize(full_width_, full_height_);
+
+  UpdateIndicators();
+}
+
+void ReportPopup::UpdateIndicators() {
+  if (door_id_ == -1) {
+    return;
+  }
+
+  wxFont the_font = GetFont().Scale(GetDPIScaleFactor());
+  const std::map<std::string, bool>& report = GetDoorRequirements(door_id_);
+
+  rendered_ = wxBitmap(full_width_, full_height_);
+
+  wxMemoryDC mem_dc;
+  mem_dc.SelectObject(rendered_);
+  mem_dc.SetPen(*wxTRANSPARENT_PEN);
+  mem_dc.SetBrush(*wxBLACK_BRUSH);
+  mem_dc.DrawRectangle({0, 0}, {full_width_, full_height_});
+
+  mem_dc.SetFont(the_font);
+
+  int cur_height = FromDIP(10);
+
+  for (const auto& [text, obtained] : report) {
+    const wxBitmap* eye_ptr = obtained ? checked_eye_ : unchecked_eye_;
+
+    mem_dc.DrawBitmap(*eye_ptr, wxPoint{FromDIP(10), cur_height});
+
+    mem_dc.SetTextForeground(obtained ? *wxWHITE : *wxRED);
+    wxSize item_extent = mem_dc.GetTextExtent(text);
+    mem_dc.DrawText(
+        text, wxPoint{FromDIP(10 + 32 + 10),
+                      cur_height +
+                          (FromDIP(32) - mem_dc.GetFontMetrics().height) / 2});
+
+    cur_height += FromDIP(10 + 32);
+  }
+}
+
+void ReportPopup::OnPaint(wxPaintEvent& event) {
+  if (door_id_ != -1) {
+    wxBufferedPaintDC dc(this);
+    PrepareDC(dc);
+    dc.DrawBitmap(rendered_, 0, 0);
+  }
+
+  event.Skip();
+}
+
+void ReportPopup::OnDPIChanged(wxDPIChangedEvent& event) {
+  LoadIcons();
+  ResetIndicators();
+
+  event.Skip();
+}
+
+void ReportPopup::LoadIcons() {
+  unchecked_eye_ = GetTheIconCache().GetIcon("assets/unchecked.png",
+                                             FromDIP(wxSize{32, 32}));
+  checked_eye_ =
+      GetTheIconCache().GetIcon("assets/checked.png", FromDIP(wxSize{32, 32}));
+}
@@ -0,0 +1,38 @@
+#ifndef REPORT_POPUP_H_E065BED4
+#define REPORT_POPUP_H_E065BED4
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+class ReportPopup : public wxScrolledCanvas {
+ public:
+  explicit ReportPopup(wxWindow* parent);
+
+  void SetDoorId(int door_id);
+
+  void Reset();
+
+  void ResetIndicators();
+  void UpdateIndicators();
+
+ private:
+  void OnPaint(wxPaintEvent& event);
+  void OnDPIChanged(wxDPIChangedEvent& event);
+
+  void LoadIcons();
+
+  int door_id_ = -1;
+
+  const wxBitmap* unchecked_eye_;
+  const wxBitmap* checked_eye_;
+
+  int full_width_ = 0;
+  int full_height_ = 0;
+
+  wxBitmap rendered_;
+};
+
+#endif /* end of include guard: REPORT_POPUP_H_E065BED4 */
@@ -3,30 +3,43 @@
 #include "tracker_config.h"
 
 SettingsDialog::SettingsDialog() : wxDialog(nullptr, wxID_ANY, "Settings") {
-  should_check_for_updates_box_ = new wxCheckBox(
-      this, wxID_ANY, "Check for updates when the tracker opens");
+  wxStaticBoxSizer* main_box =
+      new wxStaticBoxSizer(wxVERTICAL, this, "General settings");
+
+  should_check_for_updates_box_ =
+      new wxCheckBox(main_box->GetStaticBox(), wxID_ANY,
+                     "Check for updates when the tracker opens");
   hybrid_areas_box_ = new wxCheckBox(
-      this, wxID_ANY,
+      main_box->GetStaticBox(), wxID_ANY,
       "Use two colors to show that an area has partial availability");
-  show_hunt_panels_box_ = new wxCheckBox(this, wxID_ANY, "Show hunt panels");
+  track_position_box_ = new wxCheckBox(main_box->GetStaticBox(), wxID_ANY,
+                                       "Track player position");
 
   should_check_for_updates_box_->SetValue(
       GetTrackerConfig().should_check_for_updates);
   hybrid_areas_box_->SetValue(GetTrackerConfig().hybrid_areas);
-  show_hunt_panels_box_->SetValue(GetTrackerConfig().show_hunt_panels);
+  track_position_box_->SetValue(GetTrackerConfig().track_position);
+
+  main_box->Add(should_check_for_updates_box_, wxSizerFlags().Border());
+  main_box->AddSpacer(2);
+  main_box->Add(hybrid_areas_box_, wxSizerFlags().Border());
+  main_box->AddSpacer(2);
+  main_box->Add(track_position_box_, wxSizerFlags().Border());
+
+  const wxString visible_panels_choices[] = {"Only show locations",
+                                             "Show locations and hunt panels",
+                                             "Show all panels"};
+  visible_panels_box_ =
+      new wxRadioBox(this, wxID_ANY, "Visible panels", wxDefaultPosition,
+                     wxDefaultSize, 3, visible_panels_choices, 1);
+  visible_panels_box_->SetSelection(
+      static_cast<int>(GetTrackerConfig().visible_panels));
 
   wxBoxSizer* form_sizer = new wxBoxSizer(wxVERTICAL);
-
-  form_sizer->Add(should_check_for_updates_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(hybrid_areas_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(show_hunt_panels_box_, wxSizerFlags().HorzBorder());
-  form_sizer->AddSpacer(2);
-
-  form_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), wxSizerFlags().Center());
+  form_sizer->Add(main_box, wxSizerFlags().Border().Expand());
+  form_sizer->Add(visible_panels_box_, wxSizerFlags().Border().Expand());
+  form_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL),
+                  wxSizerFlags().Center().Border());
 
   SetSizerAndFit(form_sizer);
 
@@ -7,6 +7,10 @@
 #include <wx/wx.h>
 #endif
 
+#include <wx/radiobox.h>
+
+#include "tracker_config.h"
+
 class SettingsDialog : public wxDialog {
  public:
   SettingsDialog();
@@ -15,12 +19,17 @@ class SettingsDialog : public wxDialog {
     return should_check_for_updates_box_->GetValue();
   }
   bool GetHybridAreas() const { return hybrid_areas_box_->GetValue(); }
-  bool GetShowHuntPanels() const { return show_hunt_panels_box_->GetValue(); }
+  TrackerConfig::VisiblePanels GetVisiblePanels() const {
+    return static_cast<TrackerConfig::VisiblePanels>(
+        visible_panels_box_->GetSelection());
+  }
+  bool GetTrackPosition() const { return track_position_box_->GetValue(); }
 
  private:
   wxCheckBox* should_check_for_updates_box_;
   wxCheckBox* hybrid_areas_box_;
-  wxCheckBox* show_hunt_panels_box_;
+  wxRadioBox* visible_panels_box_;
+  wxCheckBox* track_position_box_;
 };
 
 #endif /* end of include guard: SETTINGS_DIALOG_H_D8635719 */
@@ -9,12 +9,28 @@
 #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);
@@ -31,14 +47,6 @@ 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())});
@@ -57,12 +65,14 @@ SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
   Bind(wxEVT_LEFT_DOWN, &SubwayMap::OnMouseClick, this);
   Bind(wxEVT_TIMER, &SubwayMap::OnTimer, this);
 
-  zoom_slider_ = new wxSlider(this, wxID_ANY, 0, 0, 8, {15, 15});
+  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() {
@@ -73,11 +83,11 @@ void SubwayMap::OnConnect() {
   std::map<std::string, std::vector<int>> exits;
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     if (AP_HasEarlyColorHallways() &&
-        subway_item.special == "starting_room_paintings") {
+        subway_item.special == "early_color_hallways") {
       entrances["early_ch"].push_back(subway_item.id);
     }
 
-    if (AP_IsPaintingShuffle() && !subway_item.paintings.empty()) {
+    if (AP_IsPaintingShuffle() && subway_item.painting) {
       continue;
     }
 
@@ -174,6 +184,8 @@ void SubwayMap::OnConnect() {
   }
 
   checked_paintings_.clear();
+
+  UpdateIndicators();
 }
 
 void SubwayMap::UpdateIndicators() {
@@ -202,6 +214,8 @@ void SubwayMap::UpdateIndicators() {
     }
   }
 
+  report_popup_->UpdateIndicators();
+
   Redraw();
 }
 
@@ -255,6 +269,9 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
     SetZoomPos({zoom_x_, zoom_y_});
 
     SetUpHelpButton();
+
+    zoom_slider_->SetSize(FromDIP(15), FromDIP(15), wxDefaultCoord,
+                          wxDefaultCoord, wxSIZE_AUTO);
   }
 
   wxBufferedPaintDC dc(this);
@@ -310,67 +327,6 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
   }
 
   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()) {
-      const std::map<std::string, bool> &report =
-          GetDoorRequirements(*subway_door);
-
-      int acc_height = 10;
-      int col_width = 0;
-
-      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;
-
-        if (item_extent.GetWidth() > col_width) {
-          col_width = item_extent.GetWidth();
-        }
-      }
-
-      int item_width = col_width + 10 + 32;
-      int full_width = item_width + 20;
-
-      wxPoint popup_pos =
-          MapPosToRenderPos({subway_item.x + AREA_ACTUAL_SIZE / 2,
-                             subway_item.y + AREA_ACTUAL_SIZE / 2});
-
-      if (popup_pos.x + full_width > GetSize().GetWidth()) {
-        popup_pos.x = GetSize().GetWidth() - full_width;
-      }
-      if (popup_pos.y + acc_height > GetSize().GetHeight()) {
-        popup_pos.y = GetSize().GetHeight() - acc_height;
-      }
-
-      dc.SetPen(*wxTRANSPARENT_PEN);
-      dc.SetBrush(*wxBLACK_BRUSH);
-      dc.DrawRectangle(popup_pos, {full_width, acc_height});
-
-      dc.SetFont(GetFont());
-
-      int cur_height = 10;
-
-      for (const auto &[text, obtained] : report) {
-        wxBitmap *eye_ptr = obtained ? &checked_eye_ : &unchecked_eye_;
-
-        dc.DrawBitmap(*eye_ptr, popup_pos + wxPoint{10, cur_height});
-
-        dc.SetTextForeground(obtained ? *wxWHITE : *wxRED);
-        wxSize item_extent = dc.GetTextExtent(text);
-        dc.DrawText(
-            text,
-            popup_pos +
-                wxPoint{10 + 32 + 10,
-                        cur_height + (32 - dc.GetFontMetrics().height) / 2});
-
-        cur_height += 10 + 32;
-      }
-    }
-
     if (networks_.IsItemInNetwork(*hovered_item_)) {
       dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
@@ -378,10 +334,8 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
         const SubwayItem &item1 = GD_GetSubwayItem(node.entry);
         const SubwayItem &item2 = GD_GetSubwayItem(node.exit);
 
-        wxPoint item1_pos = MapPosToRenderPos(
-            {item1.x + AREA_ACTUAL_SIZE / 2, item1.y + AREA_ACTUAL_SIZE / 2});
-        wxPoint item2_pos = MapPosToRenderPos(
-            {item2.x + AREA_ACTUAL_SIZE / 2, item2.y + AREA_ACTUAL_SIZE / 2});
+        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);
@@ -470,9 +424,7 @@ void SubwayMap::OnMouseMove(wxMouseEvent &event) {
   }
 
   if (!sticky_hover_ && actual_hover_ != hovered_item_) {
-    hovered_item_ = actual_hover_;
-
-    Refresh();
+    EvaluateHover();
   }
 
   if (scroll_mode_) {
@@ -514,13 +466,11 @@ void SubwayMap::OnMouseClick(wxMouseEvent &event) {
     if ((subway_door && !GetDoorRequirements(*subway_door).empty()) ||
         networks_.IsItemInNetwork(*hovered_item_)) {
       if (actual_hover_ != hovered_item_) {
-        hovered_item_ = actual_hover_;
+        EvaluateHover();
 
         if (!hovered_item_) {
           sticky_hover_ = false;
         }
-
-        Refresh();
       } else {
         sticky_hover_ = !sticky_hover_;
       }
@@ -571,11 +521,12 @@ void SubwayMap::OnClickHelp(wxCommandEvent &event) {
       "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.\nIn painting shuffle, paintings that have not "
-      "yet been checked will not show their connections.\nA green shaded owl "
-      "means that there is a painting entrance there.\nA red shaded owl means "
-      "that there are only painting exits there.\nClick on a door or "
-      "warp to make the popup stick until you click again.",
+      "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");
 }
 
@@ -592,20 +543,32 @@ void SubwayMap::Redraw() {
   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 == "starting_room_paintings") {
+        subway_item.special == "early_color_hallways") {
       draw_type = ItemDrawType::kOwl;
-      shade_color = wxColour(0, 255, 0, 128);
+      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);
+
+      draw_type = ItemDrawType::kBox;
+      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)) {
-          draw_type = ItemDrawType::kOwl;
-          shade_color = wxColour(0, 255, 0, 128);
+          brush_color = wxGREEN_BRUSH;
         } else {
-          draw_type = ItemDrawType::kBox;
           brush_color = wxRED_BRUSH;
         }
       }
@@ -619,41 +582,28 @@ void SubwayMap::Redraw() {
       } 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;
-        bool has_codomain_painting = false;
-
-        for (const std::string &painting_id : subway_item.paintings) {
-          if (checked_paintings_.count(painting_id)) {
-            has_checked_painting = true;
-
-            if (painting_mapping.count(painting_id)) {
-              has_mapped_painting = true;
-            } else if (AP_IsPaintingMappedTo(painting_id)) {
-              has_codomain_painting = true;
-            }
-          } else {
-            has_unchecked_painting = true;
-          }
-        }
-
-        if (has_unchecked_painting || has_mapped_painting ||
-            has_codomain_painting) {
+    } 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;
-
-          if (has_checked_painting) {
-            if (has_mapped_painting) {
-              shade_color = wxColour(0, 255, 0, 128);
-            } else {
-              shade_color = wxColour(255, 0, 0, 128);
-            }
-          }
+          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;
         }
       } else if (subway_item.HasWarps()) {
-        draw_type = ItemDrawType::kOwl;
+        brush_color = wxGREEN_BRUSH;
+        if (!subway_item.exits.empty()) {
+          draw_type = ItemDrawType::kOwlExit;
+        } else {
+          draw_type = ItemDrawType::kOwl;
+        }
       }
     } else if (subway_door) {
       draw_type = ItemDrawType::kBox;
@@ -673,21 +623,40 @@ void SubwayMap::Redraw() {
     if (draw_type == ItemDrawType::kBox) {
       gcdc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 1));
       gcdc.SetBrush(*brush_color);
-      gcdc.DrawRectangle(real_area_pos, {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));
-      gcdc.DrawBitmap(owl_bitmap, real_area_pos);
-
-      if (shade_color) {
-        gcdc.SetBrush(wxBrush(*shade_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);
+      }
     }
   }
 }
 
 void SubwayMap::SetUpHelpButton() {
+  help_button_->SetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord,
+                        wxDefaultCoord, wxSIZE_AUTO);
   help_button_->SetPosition({
       GetSize().GetWidth() - help_button_->GetSize().GetWidth() - 15,
       15,
@@ -723,6 +692,51 @@ void SubwayMap::EvaluateScroll(wxPoint pos) {
   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() +
@@ -812,6 +826,13 @@ std::optional<int> SubwayMap::GetRealSubwayDoor(const SubwayItem subway_item) {
 
 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};
+  }
 }
@@ -19,6 +19,8 @@
 #include "game_data.h"
 #include "network_set.h"
 
+class ReportPopup;
+
 class SubwayMap : public wxPanel {
  public:
   SubwayMap(wxWindow *parent);
@@ -46,6 +48,7 @@ class SubwayMap : public wxPanel {
   wxPoint RenderPosToMapPos(wxPoint pos) const;
 
   void EvaluateScroll(wxPoint pos);
+  void EvaluateHover();
 
   void SetZoomPos(wxPoint pos);
   void SetScrollSpeed(int scroll_x, int scroll_y);
@@ -55,8 +58,6 @@ class SubwayMap : public wxPanel {
 
   wxImage map_image_;
   wxImage owl_image_;
-  wxBitmap unchecked_eye_;
-  wxBitmap checked_eye_;
 
   wxBitmap rendered_;
   int render_x_ = 0;
@@ -88,6 +89,8 @@ class SubwayMap : public wxPanel {
   std::optional<int> actual_hover_;
   bool sticky_hover_ = false;
 
+  ReportPopup *report_popup_;
+
   NetworkSet networks_;
   std::set<std::string> checked_paintings_;
 
@@ -16,7 +16,9 @@ void TrackerConfig::Load() {
     asked_to_check_for_updates = file["asked_to_check_for_updates"].as<bool>();
     should_check_for_updates = file["should_check_for_updates"].as<bool>();
     hybrid_areas = file["hybrid_areas"].as<bool>();
-    show_hunt_panels = file["show_hunt_panels"].as<bool>();
+    if (file["show_hunt_panels"] && file["show_hunt_panels"].as<bool>()) {
+      visible_panels = kHUNT_PANELS;
+    }
 
     if (file["connection_history"]) {
       for (const auto& connection : file["connection_history"]) {
@@ -29,6 +31,9 @@ void TrackerConfig::Load() {
     }
 
     ipc_address = file["ipc_address"].as<std::string>();
+    track_position = file["track_position"].as<bool>();
+    visible_panels =
+        static_cast<VisiblePanels>(file["visible_panels"].as<int>());
   } catch (const std::exception&) {
     // It's fine if the file can't be loaded.
   }
@@ -42,7 +47,6 @@ void TrackerConfig::Save() {
   output["asked_to_check_for_updates"] = asked_to_check_for_updates;
   output["should_check_for_updates"] = should_check_for_updates;
   output["hybrid_areas"] = hybrid_areas;
-  output["show_hunt_panels"] = show_hunt_panels;
   
   output.remove("connection_history");
   for (const ConnectionDetails& details : connection_history) {
@@ -55,6 +59,8 @@ void TrackerConfig::Save() {
   }
 
   output["ipc_address"] = ipc_address;
+  output["track_position"] = track_position;
+  output["visible_panels"] = static_cast<int>(visible_panels);
 
   std::ofstream filewriter(filename_);
   filewriter << output;
@@ -23,13 +23,20 @@ class TrackerConfig {
 
   void Save();
 
+  enum VisiblePanels {
+    kLOCATIONS_ONLY,
+    kHUNT_PANELS,
+    kALL_PANELS,
+  };
+
   ConnectionDetails connection_details;
   bool asked_to_check_for_updates = false;
   bool should_check_for_updates = false;
   bool hybrid_areas = false;
-  bool show_hunt_panels = false;
   std::deque<ConnectionDetails> connection_history;
   std::string ipc_address;
+  bool track_position = true;
+  VisiblePanels visible_panels = kLOCATIONS_ONLY;
 
  private:
   std::string filename_;
@@ -5,9 +5,11 @@
 #include <wx/choicebk.h>
 #include <wx/filedlg.h>
 #include <wx/notebook.h>
+#include <wx/splitter.h>
 #include <wx/stdpaths.h>
 #include <wx/webrequest.h>
 
+#include <algorithm>
 #include <nlohmann/json.hpp>
 #include <sstream>
 
@@ -16,6 +18,11 @@
 #include "connection_dialog.h"
 #include "ipc_dialog.h"
 #include "ipc_state.h"
+#include "items_pane.h"
+#include "log_dialog.h"
+#include "logger.h"
+#include "options_pane.h"
+#include "paintings_pane.h"
 #include "settings_dialog.h"
 #include "subway_map.h"
 #include "tracker_config.h"
@@ -44,14 +51,13 @@ enum TrackerFrameIds {
   ID_SETTINGS = 3,
   ID_ZOOM_IN = 4,
   ID_ZOOM_OUT = 5,
-  ID_OPEN_SAVE_FILE = 6,
   ID_IPC_CONNECT = 7,
+  ID_LOG_DIALOG = 8,
 };
 
 wxDEFINE_EVENT(STATE_RESET, wxCommandEvent);
-wxDEFINE_EVENT(STATE_CHANGED, wxCommandEvent);
+wxDEFINE_EVENT(STATE_CHANGED, StateChangedEvent);
 wxDEFINE_EVENT(STATUS_CHANGED, wxCommandEvent);
-wxDEFINE_EVENT(REDRAW_POSITION, wxCommandEvent);
 wxDEFINE_EVENT(CONNECT_TO_AP, ApConnectEvent);
 
 TrackerFrame::TrackerFrame()
@@ -62,16 +68,22 @@ TrackerFrame::TrackerFrame()
   AP_SetTrackerFrame(this);
   IPC_SetTrackerFrame(this);
 
+  SetTheIconCache(&icons_);
+
+  updater_ = std::make_unique<Updater>(this);
+  updater_->Cleanup();
+
   wxMenu *menuFile = new wxMenu();
   menuFile->Append(ID_AP_CONNECT, "&Connect to Archipelago");
   menuFile->Append(ID_IPC_CONNECT, "&Connect to Lingo");
-  menuFile->Append(ID_OPEN_SAVE_FILE, "&Open Save Data\tCtrl-O");
   menuFile->Append(ID_SETTINGS, "&Settings");
   menuFile->Append(wxID_EXIT);
 
   wxMenu *menuView = new wxMenu();
   zoom_in_menu_item_ = menuView->Append(ID_ZOOM_IN, "Zoom In\tCtrl-+");
   zoom_out_menu_item_ = menuView->Append(ID_ZOOM_OUT, "Zoom Out\tCtrl--");
+  menuView->AppendSeparator();
+  menuView->Append(ID_LOG_DIALOG, "Show Log Window\tCtrl-L");
 
   zoom_in_menu_item_->Enable(false);
   zoom_out_menu_item_->Enable(false);
@@ -98,30 +110,43 @@ TrackerFrame::TrackerFrame()
        ID_CHECK_FOR_UPDATES);
   Bind(wxEVT_MENU, &TrackerFrame::OnZoomIn, this, ID_ZOOM_IN);
   Bind(wxEVT_MENU, &TrackerFrame::OnZoomOut, this, ID_ZOOM_OUT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnOpenLogWindow, this, ID_LOG_DIALOG);
   Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, &TrackerFrame::OnChangePage, this);
-  Bind(wxEVT_MENU, &TrackerFrame::OnOpenFile, this, ID_OPEN_SAVE_FILE);
+  Bind(wxEVT_SPLITTER_SASH_POS_CHANGED, &TrackerFrame::OnSashPositionChanged,
+       this);
   Bind(STATE_RESET, &TrackerFrame::OnStateReset, this);
   Bind(STATE_CHANGED, &TrackerFrame::OnStateChanged, this);
   Bind(STATUS_CHANGED, &TrackerFrame::OnStatusChanged, this);
-  Bind(REDRAW_POSITION, &TrackerFrame::OnRedrawPosition, this);
   Bind(CONNECT_TO_AP, &TrackerFrame::OnConnectToAp, this);
 
-  wxChoicebook *choicebook = new wxChoicebook(this, wxID_ANY);
+  wxSize logicalSize = FromDIP(wxSize(1280, 728));
+
+  splitter_window_ = new wxSplitterWindow(this, wxID_ANY);
+  splitter_window_->SetMinimumPaneSize(logicalSize.x / 5);
+
+  wxChoicebook *choicebook = new wxChoicebook(splitter_window_, wxID_ANY);
+
   achievements_pane_ = new AchievementsPane(choicebook);
   choicebook->AddPage(achievements_pane_, "Achievements");
 
-  notebook_ = new wxNotebook(this, wxID_ANY);
+  items_pane_ = new ItemsPane(choicebook);
+  choicebook->AddPage(items_pane_, "Items");
+
+  options_pane_ = new OptionsPane(choicebook);
+  choicebook->AddPage(options_pane_, "Options");
+
+  paintings_pane_ = new PaintingsPane(choicebook);
+  choicebook->AddPage(paintings_pane_, "Paintings");
+
+  notebook_ = new wxNotebook(splitter_window_, wxID_ANY);
   tracker_panel_ = new TrackerPanel(notebook_);
   subway_map_ = new SubwayMap(notebook_);
   notebook_->AddPage(tracker_panel_, "Map");
   notebook_->AddPage(subway_map_, "Subway");
 
-  wxBoxSizer *top_sizer = new wxBoxSizer(wxHORIZONTAL);
-  top_sizer->Add(choicebook, wxSizerFlags().Expand().Proportion(1));
-  top_sizer->Add(notebook_, wxSizerFlags().Expand().Proportion(3));
+  splitter_window_->SplitVertically(choicebook, notebook_, logicalSize.x / 4);
 
-  SetSizerAndFit(top_sizer);
-  SetSize(1280, 728);
+  SetSize(logicalSize);
 
   if (!GetTrackerConfig().asked_to_check_for_updates) {
     GetTrackerConfig().asked_to_check_for_updates = true;
@@ -138,7 +163,7 @@ TrackerFrame::TrackerFrame()
   }
 
   if (GetTrackerConfig().should_check_for_updates) {
-    CheckForUpdates(/*manual=*/false);
+    updater_->CheckForUpdates(/*invisible=*/true);
   }
 
   SetStatusText(GetStatusMessage());
@@ -158,15 +183,8 @@ void TrackerFrame::ResetIndicators() {
   QueueEvent(new wxCommandEvent(STATE_RESET));
 }
 
-void TrackerFrame::UpdateIndicators(UpdateIndicatorsMode mode) {
-  auto evt = new wxCommandEvent(STATE_CHANGED);
-  evt->SetInt(static_cast<int>(mode));
-
-  QueueEvent(evt);
-}
-
-void TrackerFrame::RedrawPosition() {
-  QueueEvent(new wxCommandEvent(REDRAW_POSITION));
+void TrackerFrame::UpdateIndicators(StateUpdate state) {
+  QueueEvent(new StateChangedEvent(STATE_CHANGED, GetId(), std::move(state)));
 }
 
 void TrackerFrame::OnAbout(wxCommandEvent &event) {
@@ -231,15 +249,18 @@ void TrackerFrame::OnSettings(wxCommandEvent &event) {
     GetTrackerConfig().should_check_for_updates =
         dlg.GetShouldCheckForUpdates();
     GetTrackerConfig().hybrid_areas = dlg.GetHybridAreas();
-    GetTrackerConfig().show_hunt_panels = dlg.GetShowHuntPanels();
+    GetTrackerConfig().visible_panels = dlg.GetVisiblePanels();
+    GetTrackerConfig().track_position = dlg.GetTrackPosition();
     GetTrackerConfig().Save();
 
-    UpdateIndicators();
+    UpdateIndicators(StateUpdate{.cleared_locations = true,
+                                 .player_position = true,
+                                 .changed_settings = true});
   }
 }
 
 void TrackerFrame::OnCheckForUpdates(wxCommandEvent &event) {
-  CheckForUpdates(/*manual=*/true);
+  updater_->CheckForUpdates(/*invisible=*/false);
 }
 
 void TrackerFrame::OnZoomIn(wxCommandEvent &event) {
@@ -254,132 +275,93 @@ void TrackerFrame::OnZoomOut(wxCommandEvent &event) {
   }
 }
 
-void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
-  zoom_in_menu_item_->Enable(event.GetSelection() == 1);
-  zoom_out_menu_item_->Enable(event.GetSelection() == 1);
-}
+void TrackerFrame::OnOpenLogWindow(wxCommandEvent &event) {
+  if (log_dialog_ == nullptr) {
+    log_dialog_ = new LogDialog(this);
+    log_dialog_->Show();
+    TrackerSetLogDialog(log_dialog_);
 
-void TrackerFrame::OnOpenFile(wxCommandEvent &event) {
-  wxFileDialog open_file_dialog(
-      this, "Open Lingo Save File",
-      fmt::format("{}\\Godot\\app_userdata\\Lingo\\level1_stable",
-                  wxStandardPaths::Get().GetUserConfigDir().ToStdString()),
-      AP_GetSaveName(), "Lingo save file (*.save)|*.save",
-      wxFD_OPEN | wxFD_FILE_MUST_EXIST);
-  if (open_file_dialog.ShowModal() == wxID_CANCEL) {
-    return;
+    log_dialog_->Bind(wxEVT_CLOSE_WINDOW, &TrackerFrame::OnCloseLogWindow,
+                      this);
+  } else {
+    log_dialog_->SetFocus();
   }
+}
 
-  std::string savedata_path = open_file_dialog.GetPath().ToStdString();
+void TrackerFrame::OnCloseLogWindow(wxCloseEvent& event) {
+  TrackerSetLogDialog(nullptr);
+  log_dialog_ = nullptr;
 
-  if (panels_panel_ == nullptr) {
-    panels_panel_ = new TrackerPanel(notebook_);
-    notebook_->AddPage(panels_panel_, "Panels");
-  }
+  event.Skip();
+}
 
-  notebook_->SetSelection(notebook_->FindPage(panels_panel_));
-  panels_panel_->SetSavedataPath(savedata_path);
+void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
+  zoom_in_menu_item_->Enable(event.GetSelection() == 1);
+  zoom_out_menu_item_->Enable(event.GetSelection() == 1);
+}
+
+void TrackerFrame::OnSashPositionChanged(wxSplitterEvent& event) {
+  notebook_->Refresh();
 }
 
 void TrackerFrame::OnStateReset(wxCommandEvent &event) {
-  tracker_panel_->UpdateIndicators();
+  tracker_panel_->UpdateIndicators(/*reset=*/true);
   achievements_pane_->UpdateIndicators();
+  items_pane_->ResetIndicators();
+  options_pane_->OnConnect();
+  paintings_pane_->ResetIndicators();
   subway_map_->OnConnect();
-  if (panels_panel_ != nullptr) {
-    notebook_->DeletePage(notebook_->FindPage(panels_panel_));
-    panels_panel_ = nullptr;
-  }
   Refresh();
 }
 
-void TrackerFrame::OnStateChanged(wxCommandEvent &event) {
-  UpdateIndicatorsMode mode = static_cast<UpdateIndicatorsMode>(event.GetInt());
-
-  if (mode == kUPDATE_ALL_INDICATORS) {
-    tracker_panel_->UpdateIndicators();
-    achievements_pane_->UpdateIndicators();
+void TrackerFrame::OnStateChanged(StateChangedEvent &event) {
+  const StateUpdate &state = event.GetState();
+
+  bool hunt_panels = false;
+  if (GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) {
+    hunt_panels = std::any_of(
+        state.panels.begin(), state.panels.end(), [](int solve_index) {
+          return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index)).hunt;
+        });
+  } else if (GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS) {
+    hunt_panels = true;
+  }
+  
+  if (!state.items.empty() || !state.paintings.empty() ||
+      state.cleared_locations || hunt_panels) {
+    // TODO: The only real reason to reset tracker_panel during an active
+    // connection is if the hunt panels setting changes. If we remove hunt
+    // panels later, we can get rid of this.
+    tracker_panel_->UpdateIndicators(/*reset=*/state.changed_settings);
     subway_map_->UpdateIndicators();
-    if (panels_panel_ != nullptr) {
-      panels_panel_->UpdateIndicators();
-    }
     Refresh();
-  } else if (mode == kUPDATE_ONLY_PANELS) {
-    if (panels_panel_ == nullptr) {
-      panels_panel_ = new TrackerPanel(notebook_);
-      panels_panel_->SetPanelsMode();
-      notebook_->AddPage(panels_panel_, "Panels");
-    }
-    panels_panel_->UpdateIndicators();
-    if (notebook_->GetSelection() == 2) {
-      Refresh();
+  } else if (state.player_position && GetTrackerConfig().track_position) {
+    if (notebook_->GetSelection() == 0) {
+      tracker_panel_->Refresh();
     }
   }
-}
 
-void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
-  SetStatusText(GetStatusMessage());
-}
-
-void TrackerFrame::OnRedrawPosition(wxCommandEvent &event) {
-  if (notebook_->GetSelection() == 0) {
-    tracker_panel_->Refresh();
-  } else if (notebook_->GetSelection() == 2) {
-    panels_panel_->Refresh();
+  if (std::any_of(state.panels.begin(), state.panels.end(),
+                  [](int solve_index) {
+                    return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index))
+                        .achievement;
+                  })) {
+    achievements_pane_->UpdateIndicators();
   }
-}
-
-void TrackerFrame::OnConnectToAp(ApConnectEvent &event) {
-  AP_Connect(event.GetServer(), event.GetUser(), event.GetPass());
-}
-
-void TrackerFrame::CheckForUpdates(bool manual) {
-  wxWebRequest request = wxWebSession::GetDefault().CreateRequest(
-      this, "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION");
 
-  if (!request.IsOk()) {
-    if (manual) {
-      wxMessageBox("Could not check for updates.", "Error",
-                   wxOK | wxICON_ERROR);
-    } else {
-      SetStatusText("Could not check for updates.");
-    }
+  if (!state.items.empty()) {
+    items_pane_->UpdateIndicators(state.items);
+  }
 
-    return;
+  if (!state.paintings.empty()) {
+    paintings_pane_->UpdateIndicators(state.paintings);
   }
+}
 
-  Bind(wxEVT_WEBREQUEST_STATE, [this, manual](wxWebRequestEvent &evt) {
-    if (evt.GetState() == wxWebRequest::State_Completed) {
-      std::string response = evt.GetResponse().AsString().ToStdString();
-
-      Version latest_version(response);
-      if (kTrackerVersion < latest_version) {
-        std::ostringstream message_text;
-        message_text << "There is a newer version of Lingo AP Tracker "
-                        "available. You have "
-                     << kTrackerVersion.ToString()
-                     << ", and the latest version is "
-                     << latest_version.ToString()
-                     << ". Would you like to update?";
-
-        if (wxMessageBox(message_text.str(), "Update available", wxYES_NO) ==
-            wxYES) {
-          wxLaunchDefaultBrowser(
-              "https://code.fourisland.com/lingo-ap-tracker/about/"
-              "CHANGELOG.md");
-        }
-      } else if (manual) {
-        wxMessageBox("Lingo AP Tracker is up to date!", "Lingo AP Tracker",
-                     wxOK);
-      }
-    } else if (evt.GetState() == wxWebRequest::State_Failed) {
-      if (manual) {
-        wxMessageBox("Could not check for updates.", "Error",
-                     wxOK | wxICON_ERROR);
-      } else {
-        SetStatusText("Could not check for updates.");
-      }
-    }
-  });
+void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
+  SetStatusText(wxString::FromUTF8(GetStatusMessage()));
+}
 
-  request.Start();
+void TrackerFrame::OnConnectToAp(ApConnectEvent &event) {
+  AP_Connect(event.GetServer(), event.GetUser(), event.GetPass());
 }
@@ -7,11 +7,24 @@
 #include <wx/wx.h>
 #endif
 
+#include <memory>
+#include <set>
+
+#include "ap_state.h"
+#include "icons.h"
+#include "updater.h"
+
 class AchievementsPane;
+class ItemsPane;
+class LogDialog;
+class OptionsPane;
+class PaintingsPane;
 class SubwayMap;
 class TrackerPanel;
 class wxBookCtrlEvent;
 class wxNotebook;
+class wxSplitterEvent;
+class wxSplitterWindow;
 
 class ApConnectEvent : public wxEvent {
  public:
@@ -36,17 +49,34 @@ class ApConnectEvent : public wxEvent {
   std::string ap_pass_;
 };
 
+struct StateUpdate {
+  std::vector<ItemState> items;
+  bool progression_items = false;
+  std::vector<std::string> paintings;
+  bool cleared_locations = false;
+  std::set<int> panels;
+  bool player_position = false;
+  bool changed_settings = false;
+};
+
+class StateChangedEvent : public wxEvent {
+ public:
+  StateChangedEvent(wxEventType eventType, int winid, StateUpdate state)
+      : wxEvent(winid, eventType), state_(std::move(state)) {}
+
+  const StateUpdate &GetState() const { return state_; }
+
+  virtual wxEvent *Clone() const { return new StateChangedEvent(*this); }
+
+ private:
+  StateUpdate state_;
+};
+
 wxDECLARE_EVENT(STATE_RESET, wxCommandEvent);
-wxDECLARE_EVENT(STATE_CHANGED, wxCommandEvent);
+wxDECLARE_EVENT(STATE_CHANGED, StateChangedEvent);
 wxDECLARE_EVENT(STATUS_CHANGED, wxCommandEvent);
-wxDECLARE_EVENT(REDRAW_POSITION, wxCommandEvent);
 wxDECLARE_EVENT(CONNECT_TO_AP, ApConnectEvent);
 
-enum UpdateIndicatorsMode {
-  kUPDATE_ALL_INDICATORS = 0,
-  kUPDATE_ONLY_PANELS = 1,
-};
-
 class TrackerFrame : public wxFrame {
  public:
   TrackerFrame();
@@ -55,8 +85,7 @@ class TrackerFrame : public wxFrame {
   void UpdateStatusMessage();
 
   void ResetIndicators();
-  void UpdateIndicators(UpdateIndicatorsMode mode = kUPDATE_ALL_INDICATORS);
-  void RedrawPosition();
+  void UpdateIndicators(StateUpdate state);
 
  private:
   void OnExit(wxCommandEvent &event);
@@ -67,25 +96,32 @@ class TrackerFrame : public wxFrame {
   void OnCheckForUpdates(wxCommandEvent &event);
   void OnZoomIn(wxCommandEvent &event);
   void OnZoomOut(wxCommandEvent &event);
+  void OnOpenLogWindow(wxCommandEvent &event);
+  void OnCloseLogWindow(wxCloseEvent &event);
   void OnChangePage(wxBookCtrlEvent &event);
-  void OnOpenFile(wxCommandEvent &event);
+  void OnSashPositionChanged(wxSplitterEvent &event);
 
   void OnStateReset(wxCommandEvent &event);
-  void OnStateChanged(wxCommandEvent &event);
+  void OnStateChanged(StateChangedEvent &event);
   void OnStatusChanged(wxCommandEvent &event);
-  void OnRedrawPosition(wxCommandEvent &event);
   void OnConnectToAp(ApConnectEvent &event);
+  
+  std::unique_ptr<Updater> updater_;
 
-  void CheckForUpdates(bool manual);
-
+  wxSplitterWindow *splitter_window_;
   wxNotebook *notebook_;
   TrackerPanel *tracker_panel_;
   AchievementsPane *achievements_pane_;
+  ItemsPane *items_pane_;
+  OptionsPane *options_pane_;
+  PaintingsPane *paintings_pane_;
   SubwayMap *subway_map_;
-  TrackerPanel *panels_panel_ = nullptr;
+  LogDialog *log_dialog_ = nullptr;
 
   wxMenuItem *zoom_in_menu_item_;
   wxMenuItem *zoom_out_menu_item_;
+
+  IconCache icons_;
 };
 
 #endif /* end of include guard: TRACKER_FRAME_H_86BD8DFB */
@@ -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});
   }
 }
@@ -17,17 +17,7 @@ class TrackerPanel : public wxPanel {
  public:
   TrackerPanel(wxWindow *parent);
 
-  void UpdateIndicators();
-
-  void SetPanelsMode();
-
-  void SetSavedataPath(std::string savedata_path);
-
-  bool IsPanelsMode() const { return panels_mode_; }
-
-  const std::set<std::string> &GetSolvedPanels() const {
-    return solved_panels_;
-  }
+  void UpdateIndicators(bool reset);
 
  private:
   struct AreaIndicator {
@@ -42,14 +32,13 @@ class TrackerPanel : public wxPanel {
 
   void OnPaint(wxPaintEvent &event);
   void OnMouseMove(wxMouseEvent &event);
-  void OnRefreshSavedata(wxCommandEvent &event);
 
+  void Resize();
   void Redraw();
 
-  void RefreshSavedata();
-
   wxImage map_image_;
   wxImage player_image_;
+  wxBitmap scaled_map_;
   wxBitmap rendered_;
   wxBitmap scaled_player_;
 
@@ -57,12 +46,9 @@ class TrackerPanel : public wxPanel {
   int offset_y_ = 0;
   double scale_x_ = 0;
   double scale_y_ = 0;
+  int real_area_size_ = 0;
 
   std::vector<AreaIndicator> areas_;
-
-  bool panels_mode_ = false;
-  std::optional<std::string> savedata_path_;
-  std::set<std::string> solved_panels_;
 };
 
 #endif /* end of include guard: TRACKER_PANEL_H_D675A54D */
@@ -12,6 +12,7 @@
 
 #include "ap_state.h"
 #include "game_data.h"
+#include "global.h"
 #include "logger.h"
 
 namespace {
@@ -25,6 +26,7 @@ struct Requirements {
   std::set<int> rooms;       // maybe
   bool mastery = false;      // maybe
   bool panel_hunt = false;   // maybe
+  bool postgame = false;
 
   void Merge(const Requirements& rhs) {
     if (rhs.disabled) {
@@ -45,6 +47,7 @@ struct Requirements {
     }
     mastery = mastery || rhs.mastery;
     panel_hunt = panel_hunt || rhs.panel_hunt;
+    postgame = postgame || rhs.postgame;
   }
 };
 
@@ -83,8 +86,6 @@ class RequirementCalculator {
             break;
         }
       } else if (AP_GetDoorShuffleMode() != kDOORS_MODE || 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);
@@ -148,6 +149,10 @@ class RequirementCalculator {
         }
       }
 
+      if (panel_obj.location_name == GetWinCondition()) {
+        requirements.postgame = true;
+      }
+
       panels_[panel_id] = requirements;
     }
 
@@ -162,11 +167,17 @@ class RequirementCalculator {
 struct TrackerState {
   std::map<int, bool> reachability;
   std::set<int> reachable_doors;
+  std::set<int> solveable_panels;
   std::set<int> reachable_paintings;
   std::mutex reachability_mutex;
   RequirementCalculator requirements;
   std::map<int, std::map<std::string, bool>> door_reports;
   bool pilgrimage_doable = false;
+
+  // If these are empty, it actually means everything is non-postgame.
+  std::set<int> non_postgame_areas;
+  std::set<int> non_postgame_locations;
+  std::set<int> non_postgame_paintings;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -181,6 +192,11 @@ class StateCalculator;
 struct StateCalculatorOptions {
   int start;
   bool pilgrimage = false;
+
+  // Treats all items as collected and all paintings as checked, but postgame
+  // areas cannot be reached.
+  bool postgame_detection = false;
+
   StateCalculator* parent = nullptr;
 };
 
@@ -191,6 +207,16 @@ class StateCalculator {
   explicit StateCalculator(StateCalculatorOptions options)
       : options_(options) {}
 
+  void PreloadPanels(const std::set<int>& panels) {
+    solveable_panels_ = panels;
+  }
+
+  void PreloadDoors(const std::set<int>& doors) {
+    for (int door_id : doors) {
+      door_decisions_[door_id] = kYes;
+    }
+  }
+
   void Calculate() {
     painting_mapping_ = AP_GetPaintingMapping();
     checked_paintings_ = AP_GetCheckedPaintings();
@@ -236,7 +262,8 @@ class StateCalculator {
 
           PaintingExit cur_painting = GD_GetPaintingExit(painting_id);
           if (painting_mapping_.count(cur_painting.internal_id) &&
-              checked_paintings_.count(cur_painting.internal_id)) {
+              (checked_paintings_.count(cur_painting.internal_id) ||
+               options_.postgame_detection)) {
             Exit painting_exit;
             PaintingExit target_painting =
                 GD_GetPaintingExit(GD_GetPaintingByName(
@@ -360,6 +387,10 @@ class StateCalculator {
     // evaluated.
     for (const Door& door : GD_GetDoors()) {
       int discard = IsDoorReachable(door.id);
+
+      door_report_[door.id] = {};
+      discard = AreRequirementsSatisfied(
+          GetState().requirements.GetDoor(door.id), &door_report_[door.id]);
     }
   }
 
@@ -417,43 +448,48 @@ class StateCalculator {
       return kNo;
     }
 
+    if (reqs.postgame && options_.postgame_detection) {
+      return kNo;
+    }
+
     Decision final_decision = kYes;
 
-    for (int door_id : reqs.doors) {
-      const Door& door_obj = GD_GetDoor(door_id);
-      Decision decision = IsNonGroupedDoorReachable(door_obj);
+    if (!options_.postgame_detection) {
+      for (int door_id : reqs.doors) {
+        const Door& door_obj = GD_GetDoor(door_id);
+        Decision decision = IsNonGroupedDoorReachable(door_obj);
 
-      if (report) {
-        (*report)[door_obj.item_name] = (decision == kYes);
-      }
+        if (report) {
+          (*report)[door_obj.item_name] = (decision == kYes);
+        }
 
-      if (decision != kYes) {
-        final_decision = decision;
+        if (decision != kYes) {
+          final_decision = decision;
+        }
       }
-    }
 
-    for (int panel_door_id : reqs.panel_doors) {
-      const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_door_id);
-      Decision decision = IsNonGroupedDoorReachable(panel_door_obj);
+      for (int panel_door_id : reqs.panel_doors) {
+        const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_door_id);
+        Decision decision = IsNonGroupedDoorReachable(panel_door_obj);
 
-      if (report) {
-        (*report)[AP_GetItemName(panel_door_obj.ap_item_id)] =
-            (decision == kYes);
-      }
+        if (report) {
+          (*report)[panel_door_obj.item_name] = (decision == kYes);
+        }
 
-      if (decision != kYes) {
-        final_decision = decision;
+        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;
-      }
+      for (int item_id : reqs.items) {
+        bool has_item = AP_HasItem(item_id);
+        if (report) {
+          (*report)[GD_GetItemName(item_id)] = has_item;
+        }
 
-      if (!has_item) {
-        final_decision = kNo;
+        if (!has_item) {
+          final_decision = kNo;
+        }
       }
     }
 
@@ -522,14 +558,7 @@ class StateCalculator {
   }
 
   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]);
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id));
   }
 
   Decision IsDoorReachable(int door_id) {
@@ -661,18 +690,85 @@ class StateCalculator {
 }  // namespace
 
 void ResetReachabilityRequirements() {
+  TrackerLog("Resetting tracker state...");
+
   std::lock_guard reachability_guard(GetState().reachability_mutex);
   GetState().requirements.Reset();
+  GetState().reachable_doors.clear();
+  GetState().solveable_panels.clear();
+
+  if (AP_IsPostgameShuffle()) {
+    GetState().non_postgame_areas.clear();
+    GetState().non_postgame_locations.clear();
+    GetState().non_postgame_paintings.clear();
+  } else {
+    StateCalculator postgame_calculator(
+        {.start = GD_GetRoomByName("Menu"), .postgame_detection = true});
+    postgame_calculator.Calculate();
+
+    std::set<int>& non_postgame_areas = GetState().non_postgame_areas;
+    non_postgame_areas.clear();
+
+    std::set<int>& non_postgame_locations = GetState().non_postgame_locations;
+    non_postgame_locations.clear();
+
+    const std::set<int>& reachable_rooms =
+        postgame_calculator.GetReachableRooms();
+    const std::set<int>& solveable_panels =
+        postgame_calculator.GetSolveablePanels();
+
+    for (const MapArea& map_area : GD_GetMapAreas()) {
+      bool area_reachable = false;
+
+      for (const Location& location_section : map_area.locations) {
+        bool reachable = reachable_rooms.count(location_section.room);
+        if (reachable) {
+          for (int panel_id : location_section.panels) {
+            reachable &= (solveable_panels.count(panel_id) == 1);
+          }
+        }
+
+        if (!reachable && IsLocationWinCondition(location_section)) {
+          reachable = true;
+        }
+
+        if (reachable) {
+          non_postgame_locations.insert(location_section.ap_location_id);
+          area_reachable = true;
+        }
+      }
+
+      for (int painting_id : map_area.paintings) {
+        if (postgame_calculator.GetReachablePaintings().count(painting_id)) {
+          area_reachable = true;
+        }
+      }
+
+      if (area_reachable) {
+        non_postgame_areas.insert(map_area.id);
+      }
+    }
+
+    GetState().non_postgame_paintings =
+        postgame_calculator.GetReachablePaintings();
+  }
 }
 
 void RecalculateReachability() {
+  TrackerLog("Calculating reachability...");
+
   std::lock_guard reachability_guard(GetState().reachability_mutex);
 
+  // Receiving items and checking paintings should never remove access to doors
+  // or panels, so we can preload any doors and panels we already know are
+  // accessible from previous runs, in order to reduce the work.
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
+  state_calculator.PreloadDoors(GetState().reachable_doors);
+  state_calculator.PreloadPanels(GetState().solveable_panels);
   state_calculator.Calculate();
 
   const std::set<int>& reachable_rooms = state_calculator.GetReachableRooms();
-  const std::set<int>& solveable_panels = state_calculator.GetSolveablePanels();
+  std::set<int> solveable_panels = state_calculator.GetSolveablePanels();
 
   std::map<int, bool> new_reachability;
   for (const MapArea& map_area : GD_GetMapAreas()) {
@@ -703,6 +799,7 @@ void RecalculateReachability() {
   
   std::swap(GetState().reachability, new_reachability);
   std::swap(GetState().reachable_doors, new_reachable_doors);
+  std::swap(GetState().solveable_panels, solveable_panels);
   std::swap(GetState().reachable_paintings, reachable_paintings);
   std::swap(GetState().door_reports, door_reports);
   GetState().pilgrimage_doable = state_calculator.IsPilgrimageDoable();
@@ -741,3 +838,33 @@ bool IsPilgrimageDoable() {
 
   return GetState().pilgrimage_doable;
 }
+
+bool IsAreaPostgame(int area_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_areas.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_areas.count(area_id);
+  }
+}
+
+bool IsLocationPostgame(int location_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_locations.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_locations.count(location_id);
+  }
+}
+
+bool IsPaintingPostgame(int painting_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  if (GetState().non_postgame_paintings.empty()) {
+    return false;
+  } else {
+    return !GetState().non_postgame_paintings.count(painting_id);
+  }
+}
@@ -18,4 +18,10 @@ const std::map<std::string, bool>& GetDoorRequirements(int door_id);
 
 bool IsPilgrimageDoable();
 
+bool IsAreaPostgame(int area_id);
+
+bool IsLocationPostgame(int location_id);
+
+bool IsPaintingPostgame(int painting_id);
+
 #endif /* end of include guard: TRACKER_STATE_H_8639BC90 */
@@ -0,0 +1,309 @@
+#include "updater.h"
+
+#include <fmt/core.h>
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+#include <wx/evtloop.h>
+#include <wx/progdlg.h>
+#include <wx/webrequest.h>
+#include <wx/wfstream.h>
+#include <wx/zipstrm.h>
+#include <yaml-cpp/yaml.h>
+
+#include <cstdio>
+#include <deque>
+#include <filesystem>
+#include <fstream>
+
+#include "global.h"
+#include "logger.h"
+#include "version.h"
+
+constexpr const char* kVersionFileUrl =
+    "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION.yaml";
+constexpr const char* kChangelogUrl =
+    "https://code.fourisland.com/lingo-ap-tracker/about/CHANGELOG.md";
+
+namespace {
+
+std::string CalculateStringSha256(const wxString& data) {
+  unsigned char hash[SHA256_DIGEST_LENGTH];
+  EVP_MD_CTX* sha256 = EVP_MD_CTX_new();
+  EVP_DigestInit(sha256, EVP_sha256());
+  EVP_DigestUpdate(sha256, data.c_str(), data.length());
+  EVP_DigestFinal_ex(sha256, hash, nullptr);
+  EVP_MD_CTX_free(sha256);
+
+  char output[65] = {0};
+  for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+    snprintf(output + (i * 2), 3, "%02x", hash[i]);
+  }
+
+  return std::string(output);
+}
+
+}  // namespace
+
+Updater::Updater(wxFrame* parent) : parent_(parent) {
+  Bind(wxEVT_WEBREQUEST_STATE, &Updater::OnWebRequestState, this);
+}
+
+void Updater::Cleanup() {
+  std::filesystem::path oldDir = GetExecutableDirectory() / "old";
+  if (std::filesystem::is_directory(oldDir)) {
+    std::filesystem::remove_all(oldDir);
+  }
+}
+
+void Updater::CheckForUpdates(bool invisible) {
+  wxWebRequest versionRequest =
+      wxWebSession::GetDefault().CreateRequest(this, kVersionFileUrl);
+
+  if (invisible) {
+    update_state_ = UpdateState::GetVersionInvisible;
+
+    versionRequest.Start();
+  } else {
+    update_state_ = UpdateState::GetVersionManual;
+
+    if (DownloadWithProgress(versionRequest)) {
+      if (versionRequest.GetState() == wxWebRequest::State_Failed) {
+        wxMessageBox("Could not check for updates.", "Error",
+                     wxOK | wxICON_ERROR);
+      } else if (versionRequest.GetState() == wxWebRequest::State_Completed) {
+        ProcessVersionFile(
+            versionRequest.GetResponse().AsString().utf8_string());
+      }
+    }
+  }
+}
+
+void Updater::OnWebRequestState(wxWebRequestEvent& evt) {
+  if (update_state_ == UpdateState::GetVersionInvisible) {
+    if (evt.GetState() == wxWebRequest::State_Completed) {
+      ProcessVersionFile(evt.GetResponse().AsString().utf8_string());
+    } else if (evt.GetState() == wxWebRequest::State_Failed) {
+      parent_->SetStatusText("Could not check for updates.");
+    }
+  }
+}
+
+void Updater::ProcessVersionFile(std::string data) {
+  try {
+    YAML::Node versionInfo = YAML::Load(data);
+    Version latestVersion(versionInfo["version"].as<std::string>());
+
+    if (kTrackerVersion < latestVersion) {
+      if (versionInfo["packages"]) {
+        std::string platformIdentifier;
+
+        if (wxPlatformInfo::Get().GetOperatingSystemId() == wxOS_WINDOWS_NT) {
+          platformIdentifier = "win64";
+        }
+
+        if (!platformIdentifier.empty() &&
+            versionInfo["packages"][platformIdentifier]) {
+          wxMessageDialog dialog(
+              nullptr,
+              fmt::format("There is a newer version of Lingo AP Tracker "
+                          "available. You have {}, and the latest version is "
+                          "{}. Would you like to update?",
+                          kTrackerVersion.ToString(), latestVersion.ToString()),
+              "Update available", wxYES_NO | wxCANCEL);
+          dialog.SetYesNoLabels("Install update", "Open changelog");
+
+          int dlgResult = dialog.ShowModal();
+          if (dlgResult == wxID_YES) {
+            const YAML::Node& packageInfo =
+                versionInfo["packages"][platformIdentifier];
+            std::string packageUrl = packageInfo["url"].as<std::string>();
+            std::string packageChecksum =
+                packageInfo["checksum"].as<std::string>();
+
+            std::vector<std::filesystem::path> packageFiles;
+            if (packageInfo["files"]) {
+              for (const YAML::Node& filename : packageInfo["files"]) {
+                packageFiles.push_back(filename.as<std::string>());
+              }
+            }
+
+            std::vector<std::filesystem::path> deletedFiles;
+            if (packageInfo["deleted_files"]) {
+              for (const YAML::Node& filename : packageInfo["deleted_files"]) {
+                deletedFiles.push_back(filename.as<std::string>());
+              }
+            }
+
+            InstallUpdate(packageUrl, packageChecksum, packageFiles,
+                          deletedFiles);
+          } else if (dlgResult == wxID_NO) {
+            wxLaunchDefaultBrowser(kChangelogUrl);
+          }
+
+          return;
+        }
+      }
+
+      if (wxMessageBox(
+              fmt::format("There is a newer version of Lingo AP Tracker "
+                          "available. You have {}, and the latest version is "
+                          "{}. Would you like to update?",
+                          kTrackerVersion.ToString(), latestVersion.ToString()),
+              "Update available", wxYES_NO) == wxYES) {
+        wxLaunchDefaultBrowser(kChangelogUrl);
+      }
+    } else if (update_state_ == UpdateState::GetVersionManual) {
+      wxMessageBox("Lingo AP Tracker is up to date!", "Lingo AP Tracker", wxOK);
+    }
+  } catch (const std::exception& ex) {
+    wxMessageBox("Could not check for updates.", "Error", wxOK | wxICON_ERROR);
+  }
+}
+
+void Updater::InstallUpdate(std::string url, std::string checksum,
+                            std::vector<std::filesystem::path> files,
+                            std::vector<std::filesystem::path> deletedFiles) {
+  update_state_ = UpdateState::GetPackage;
+
+  wxWebRequest packageRequest =
+      wxWebSession::GetDefault().CreateRequest(this, url);
+
+  if (!DownloadWithProgress(packageRequest)) {
+    return;
+  }
+
+  bool download_issue = false;
+
+  wxFileName package_path;
+  package_path.AssignTempFileName("");
+
+  if (!package_path.IsOk()) {
+    download_issue = true;
+  } else {
+    wxFileOutputStream writeOut(package_path.GetFullPath());
+    wxString fileData = packageRequest.GetResponse().AsString();
+    writeOut.WriteAll(fileData.c_str(), fileData.length());
+
+    std::string downloadedChecksum = CalculateStringSha256(fileData);
+    if (downloadedChecksum != checksum) {
+      download_issue = true;
+    }
+  }
+
+  if (download_issue) {
+    if (wxMessageBox("There was an issue downloading the update. Would you "
+                     "like to manually download it instead?",
+                     "Error", wxYES_NO | wxICON_ERROR) == wxID_YES) {
+      wxLaunchDefaultBrowser(kChangelogUrl);
+    }
+    return;
+  }
+
+  std::filesystem::path newArea = GetExecutableDirectory();
+  std::filesystem::path oldArea = newArea / "old";
+  std::set<std::filesystem::path> folders;
+  std::set<std::filesystem::path> filesToMove;
+  for (const std::filesystem::path& existingFile : files) {
+    std::filesystem::path movedPath = oldArea / existingFile;
+    std::filesystem::path movedDir = movedPath;
+    movedDir.remove_filename();
+    folders.insert(movedDir);
+    filesToMove.insert(existingFile);
+  }
+  for (const std::filesystem::path& existingFile : deletedFiles) {
+    std::filesystem::path movedPath = oldArea / existingFile;
+    std::filesystem::path movedDir = movedPath;
+    movedDir.remove_filename();
+    folders.insert(movedDir);
+  }
+
+  for (const std::filesystem::path& newFolder : folders) {
+    TrackerLog(fmt::format("Creating directory {}", newFolder.string()));
+
+    std::filesystem::create_directories(newFolder);
+  }
+
+  for (const std::filesystem::path& existingFile : files) {
+    std::filesystem::path existingPath = newArea / existingFile;
+
+    if (std::filesystem::is_regular_file(existingPath)) {
+      std::filesystem::path movedPath = oldArea / existingFile;
+
+      TrackerLog(fmt::format("Moving {} -> {}", existingPath.string(),
+                             movedPath.string()));
+
+      std::filesystem::rename(existingPath, movedPath);
+    }
+  }
+  for (const std::filesystem::path& existingFile : deletedFiles) {
+    std::filesystem::path existingPath = newArea / existingFile;
+
+    if (std::filesystem::is_regular_file(existingPath)) {
+      std::filesystem::path movedPath = oldArea / existingFile;
+
+      TrackerLog(fmt::format("Moving {} -> {}", existingPath.string(),
+                             movedPath.string()));
+
+      std::filesystem::rename(existingPath, movedPath);
+    }
+  }
+
+  wxFileInputStream fileInputStream(package_path.GetFullPath());
+  wxZipInputStream zipStream(fileInputStream);
+  std::unique_ptr<wxZipEntry> zipEntry;
+  while ((zipEntry = std::unique_ptr<wxZipEntry>(zipStream.GetNextEntry())) !=
+         nullptr) {
+    if (zipEntry->IsDir()) {
+      continue;
+    }
+
+    std::filesystem::path archivePath = zipEntry->GetName().utf8_string();
+
+    TrackerLog(fmt::format("Found {} in archive", archivePath.string()));
+
+    // Cut off the root folder name
+    std::filesystem::path subPath;
+    for (auto it = std::next(archivePath.begin()); it != archivePath.end();
+         it++) {
+      subPath /= *it;
+    }
+
+    std::filesystem::path pastePath = newArea / subPath;
+
+    wxFileOutputStream fileOutput(pastePath.string());
+    zipStream.Read(fileOutput);
+  }
+
+  if (wxMessageBox(
+      "Update installed! The tracker must be restarted for the changes to take "
+      "effect. Do you want to close the tracker?",
+                   "Update installed", wxYES_NO) == wxYES) {
+    wxExit();
+  }
+}
+
+bool Updater::DownloadWithProgress(wxWebRequest& request) {
+  request.Start();
+
+  wxProgressDialog dialog("Checking for updates...", "Checking for updates...",
+                          100, nullptr,
+                          wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_CAN_ABORT |
+                              wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME);
+  while (request.GetState() != wxWebRequest::State_Completed &&
+         request.GetState() != wxWebRequest::State_Failed) {
+    if (request.GetBytesExpectedToReceive() == -1) {
+      if (!dialog.Pulse()) {
+        request.Cancel();
+        return false;
+      }
+    } else {
+      dialog.SetRange(request.GetBytesExpectedToReceive());
+      if (!dialog.Update(request.GetBytesReceived())) {
+        request.Cancel();
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
@@ -0,0 +1,46 @@
+#ifndef UPDATER_H_809E7381
+#define UPDATER_H_809E7381
+
+#include <filesystem>
+#include <set>
+#include <string>
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+class wxWebRequest;
+class wxWebRequestEvent;
+
+class Updater : public wxEvtHandler {
+ public:
+  explicit Updater(wxFrame* parent);
+
+  void Cleanup();
+
+  void CheckForUpdates(bool invisible);
+
+ private:
+  enum class UpdateState {
+    GetVersionInvisible,
+    GetVersionManual,
+    GetPackage,
+  };
+
+  void OnWebRequestState(wxWebRequestEvent& event);
+
+  void ProcessVersionFile(std::string data);
+
+  void InstallUpdate(std::string url, std::string checksum,
+                     std::vector<std::filesystem::path> files,
+                     std::vector<std::filesystem::path> deletedFiles);
+
+  bool DownloadWithProgress(wxWebRequest& request);
+
+  wxFrame* parent_;
+  UpdateState update_state_ = UpdateState::GetVersionInvisible;
+};
+
+#endif /* end of include guard: UPDATER_H_809E7381 */
@@ -36,6 +36,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 12, 0);
+constexpr const Version kTrackerVersion = Version(2, 0, 2);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file
@@ -0,0 +1,3 @@
+#define wxUSE_RC_MANIFEST 1
+#define wxUSE_DPI_AWARE_MANIFEST 2
+#include "wx/msw/wx.rc"
@@ -1,6 +1,5 @@
 {
   "dependencies": [
-    "websocketpp",
     "wxwidgets",
     "openssl",
     "yaml-cpp",
-Subproject 3dd44b931481d7a8e9ba412621fa810232b6628
+Subproject df8bfe519564ae001903e5cdd32af0999531ef7
+Subproject 1b11fd301531e6df35a6107c1e8665b1e77a2d8