65 files changed, 4143 insertions, 1447 deletions

@@ -1,5 +1,6 @@
 build/
 builds/
 assets/LL1.yaml
+assets/ids.yaml
 .DS_Store
 .vs
@@ -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,159 @@
 # 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
+  client (requires v5.1.0 or later). This allows the tracker to show the
+  player's position more precisely, as well as get automatically updated on what
+  non-check panels have been solved.
+- Fixed one of the doors (Outside The Initiated - Eight Door) showing up
+  incorrectly on the subway map.
+
+Download:
+[lingo-ap-tracker-v0.12.0-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.12.0-win64.zip)<br/>
+Source: [v0.12.0](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.12.0)
+
+## v0.11.5 - 2024-12-08
+
+- [A logic error](https://github.com/ArchipelagoMW/Archipelago/pull/4342) was
+  found in Archipelago 0.5.1 related to the number hunt when playing on panels
+  mode door shuffle. In order to work around this, the tracker now uses the same
+  incorrect logic as the generator. This means that you will be able to tell
+  what panels you are expected to solve, even if it is not intuitive. There is
+  already a fix for the logic error, which will likely be included in the next
+  major Archipelago release, at which point this workaround will be removed.
+
+Download:
+[lingo-ap-tracker-v0.11.5-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.11.5-win64.zip)<br/>
+Source: [v0.11.5](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.11.5)
+
+## v0.11.4 - 2024-12-05
+
+- Fixed an issue where Starting Room panels would show up as checks when playing
+  panels mode door shuffle.
+
+Download:
+[lingo-ap-tracker-v0.11.4-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.11.4-win64.zip)<br/>
+Source: [v0.11.4](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.11.4)
+
+## v0.11.3 - 2024-11-26
+
+- Compatibility update for Archipelago 0.5.1
+
+Download:
+[lingo-ap-tracker-v0.11.3-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.11.3-win64.zip)<br/>
+Source: [v0.11.3](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.11.3)
+
+## v0.11.2 - 2024-09-24
+
+- One-way connections on the subway map are now indicated by a circle at the
+  exit. Contributed by art0007i.
+
+Download:
+[lingo-ap-tracker-v0.11.2-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.11.2-win64.zip)<br/>
+Source: [v0.11.2](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.11.2)
+
+## v0.11.1 - 2024-07-25
+
+- The Pilgrim Antechamber sunwarp on the subway map now shows all sunwarp
+  connections, and is red if a pilgrimage is not possible.
+- The save analysis panel now uses the remote location status for non-counting
+  panels.
+- Fixed positioning of Outside The Undeterred - Number Hunt door on subway map.
+- Fixed subway map issue when sunwarp shuffle and individual/progressive sunwarp
+  access were combined where the icons on the map would show unshuffled access.
+- Map area indicators now correctly treat unreachable pre-checked paintings as
+  unchecked.
+
+Download:
+[lingo-ap-tracker-v0.11.1-win64.zip](https://files.fourisland.com/releases/lingo-ap-tracker/lingo-ap-tracker-v0.11.1-win64.zip)<br/>
+Source: [v0.11.1](https://code.fourisland.com/lingo-ap-tracker/tag/?h=v0.11.1)
+
 ## v0.11.0 - 2024-07-19
 
 - Added a savedata analyzer. When connected to a world, the user can open up the
@@ -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,9 +48,33 @@ 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")
+
+add_custom_target(copy_assets ALL
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${SRC_DIR} ${DST_DIR}
+    COMMENT "Copying folder from ${SRC_DIR} to ${DST_DIR}"
+)
+
+add_dependencies(lingo_ap_tracker copy_assets)
@@ -9,4 +9,23 @@ Releases of the tracker can be found [on the releases page](https://code.fourisl
 
 ## Acknowledgments
 
-Thanks to Kinrah for making the subway map image!
+* Brenton Wildes: Created Lingo, and drew some of the images used in the tracker.
+* Kinrah: Made the subway map image.
+* art0007i: Contributed to the display of the subway map.
+
+## Building
+
+To build the app:
+
+1. Clone the repository including submodules: `git clone --recursive https://code.fourisland.com/lingo-ap-tracker`
+2. Put [LL1.yaml from archipelago](https://github.com/ArchipelagoMW/Archipelago/raw/main/worlds/lingo/data/LL1.yaml) in ./assets
+3. Put [ids.yaml from archipelago](https://github.com/ArchipelagoMW/Archipelago/raw/main/worlds/lingo/data/ids.yaml) in ./assets
+4. Configure the project: `cmake --preset=lingo-ap-tracker-preset`
+5. Build the application in debug mode: `cmake --build --preset=lingo-ap-tracker-preset`
+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.11.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
-  tags:
+  painting: garden_painting_tower2
+  entrances:
     - garden_starting
-- pos: [1066, 841]
+- pos: [1076, 851]
   room: Courtyard
   door: Painting Shortcut
-  paintings:
-    - flower_painting_8
-  tags:
+  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
-  tags:
+  painting: symmetry_painting_a_starter
+  entrances:
     - symmetry_starting
-- pos: [1066, 868]
+- pos: [1076, 905]
   room: Outside The Bold
   door: Painting Shortcut
-  paintings:
-    - pencil_painting6
-  tags:
+  painting: pencil_painting6
+  entrances:
     - pencil_starting
-- pos: [1066, 895]
+- pos: [1076, 878]
   room: Outside The Undeterred
   door: Painting Shortcut
-  paintings:
-    - blueman_painting_3
-  tags:
+  painting: blueman_painting_3
+  entrances:
     - blueman_starting
-- pos: [905, 868]
+- pos: [915, 878]
   room: Outside The Agreeable
   door: Painting Shortcut
-  paintings:
-    - eyes_yellow_painting2
-  tags:
+  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
-  tags:
+- 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
-  tags:
+- 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
-  tags:
+- 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,16 +139,15 @@
 - 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
-  tags:
+- pos: [712, 514]
+  painting: smile_painting_4
+  entrances:
     - smiley_crossroads
 - pos: [878, 509]
   sunwarp:
@@ -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,22 +197,20 @@
 - pos: [1216, 525]
   room: Outside The Agreeable
   door: Agreeable Entrance
-- pos: [1138, 287]
-  paintings:
-    - eyes_yellow_painting
-  tags:
+- 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
-  tags:
+- pos: [1226, 481]
+  painting: pencil_painting7
+  entrances:
     - pencil_compass
 - pos: [1196, 417]
   invisible: true
@@ -248,10 +238,9 @@
 - pos: [1714, 434]
   room: Hedge Maze
   door: Observant Entrance
-- pos: [1477, 343]
-  paintings:
-    - garden_painting_tower
-  tags:
+- pos: [1526, 401]
+  painting: garden_painting_tower
+  exits:
     - garden_starting
 - pos: [1565, 311]
   room: The Fearless (First Floor)
@@ -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
-  tags:
+- pos: [1799, 583]
+  painting: crown_painting
+  exits:
     - crown_tower6
-- pos: [1653, 717]
-  paintings:
-    - eight_painting2
-  tags:
+- pos: [1644, 685]
+  painting: eight_painting2
+  entrances:
     - eight_alcove
-- pos: [1653, 662]
-  paintings:
-    - eight_painting
-  tags:
+- 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,83 @@
   sunwarp:
     dots: 5
     type: enter
-- pos: [877, 155]
+- pos: [878, 155]
   room: Number Hunt
   door: Eights
-- pos: [844, 134]
-  paintings:
-    - smile_painting_8
-  tags:
+- 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
-  tags:
-    - owl_tower6
-    - clock_tower6
+- 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:
     - panda_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: [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
-    - hi_scientific
-- pos: [349, 1124]
-  paintings:
-    - map_painting2
+- 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
-  tags:
+- 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
-  tags:
+- pos: [589, 369]
+  painting: blueman_painting
+  entrances:
     - blueman_courtyard
 - pos: [530, 310]
   room: First Second Third Fourth
@@ -501,14 +499,13 @@
 - 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
 - pos: [773, 954]
-  tags:
+  exits:
     - hub_wb
     - wondrous_wb
     - undeterred_wb
@@ -519,45 +516,48 @@
     - scientific_wb
     - cellar_wb
 - pos: [1107, 749]
-  tags:
+  entrances:
     - hub_wb
 - pos: [408, 817]
-  tags:
+  entrances:
     - wondrous_wb
 - pos: [281, 1017]
-  tags:
+  entrances:
     - undeterred_wb
 - pos: [1017, 289]
-  tags:
+  entrances:
     - agreeable_wb
 - pos: [907, 1385]
-  tags:
+  entrances:
     - wanderer_wb
 - pos: [1737, 1053]
-  tags:
+  entrances:
     - gallery_wb
-- pos: [1690, 268]
-  tags:
+- pos: [1784, 395]
+  entrances:
     - observant_wb
-- pos: [250, 604]
-  tags:
+- pos: [122, 350]
+  entrances:
     - scientific_wb
 - pos: [1553, 1467]
-  tags:
+  entrances:
     - cellar_wb
 - 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
-  tags:
+- 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
@@ -582,41 +582,39 @@
 - 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: Outside The Initiated
-  door: Eight Door
-- pos: [1530, 938]
-  paintings:
-    - clock_painting_5
-  tags:
+  room: The Incomparable
+  door: "Eight Door (Outside The Initiated)"
+- pos: [1548, 948]
+  painting: clock_painting_5
+  entrances:
     - clock_initiated
-- pos: [1546, 938]
-  paintings:
-    - clock_painting_2
-    - arrows_painting_2
-  tags:
+- 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
-  tags:
+- pos: [1462, 915]
+  painting: smile_painting_1
+  entrances:
     - smiley_initiated
 - pos: [1430, 691]
   room: Outside The Undeterred
@@ -624,17 +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]
@@ -652,21 +658,21 @@
 - pos: [1468, 1377]
   room: Outside The Bold
   door: Bold Entrance
-- pos: [1425, 1358]
-  paintings:
-    - pencil_painting2
-    - north_missing2
-  tags:
+- 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]
-  tags:
+  exits:
     - undeterred_artistic
-- pos: [279, 1071]
+- pos: [273, 1071]
   room: Number Hunt
   door: Zero Door
 - pos: [338, 1071]
@@ -681,18 +687,16 @@
 - pos: [242, 1071]
   room: Outside The Undeterred
   door: Undeterred Entrance
-- pos: [60, 1017]
-  paintings:
-    - blueman_painting_2
-  tags:
+- 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
-  tags:
+  painting: maze_painting_3
+  entrances:
     - green_numbers
 - pos: [134, 1007]
   sunwarp:
@@ -701,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]
@@ -722,12 +726,11 @@
 - 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
-  tags:
+  painting: smile_painting_5
+  entrances:
     - smiley_numbers
 - pos: [557, 953]
   room: Number Hunt
@@ -744,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
-  tags:
+- pos: [364, 942]
+  painting: boxes_painting
+  entrances:
     - lattice_directional
-- pos: [272, 927]
-  paintings:
-    - smile_painting_7
-  tags:
+- pos: [278, 942]
+  painting: smile_painting_7
+  entrances:
     - smiley_directional
-- pos: [214, 822]
-  paintings:
-    - cherry_painting
-  tags:
+- pos: [278, 803]
+  painting: cherry_painting
+  entrances:
     - apple_directional
-- pos: [266, 735]
+- pos: [262, 573]
   room: Number Hunt
   door: Sixes
-  paintings:
-    - pencil_painting3
-  tags:
+  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
@@ -835,10 +818,9 @@
   # Complex case, because this is also blocked by Knight Night (Final) - Exit
   room: Number Hunt
   door: Sevens
-- pos: [1653, 101]
-  paintings:
-    - smile_painting_9
-  tags:
+- pos: [1687, 117]
+  painting: smile_painting_9
+  exits:
     - smiley_crossroads
     - smiley_deadend
     - smiley_hotcrusts
@@ -847,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]
-  tags:
+  entrances:
     - undeterred_artistic
-- pos: [1653, 169]
-  paintings:
-    - panda_painting_3
-  tags:
+- 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
-  tags:
+- 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
-  tags:
+- 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
-  tags:
+- 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
-  tags:
+- 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
-  paintings:
-    - arrows_painting_9
-- pos: [449, 755]
-  paintings:
-    - flower_painting_6
-  tags:
+- pos: [535, 647]
+  room: The Wondrous
+  door: Exit
+  painting: arrows_painting_9
+- pos: [610, 674]
+  painting: flower_painting_6
+  entrances:
     - flower_arrow
-- pos: [1101, 222]
-  paintings:
-    - panda_painting
-  tags:
+- 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]
@@ -943,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]
@@ -970,23 +978,26 @@
 - 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
-  tags:
+- 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
 - pos: [1120, 1315]
-  tags:
+  entrances: # this could be considered 2 way since the subway map has a one way gate at the exit anyway
     - rhyme_smiley_target
 - pos: [792, 1137]
-  tags:
+  exits:
     - rhyme_smiley_target
 - pos: [895, 1217]
   room: Number Hunt
@@ -997,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
@@ -1012,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
-  tags:
+- 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>
@@ -22,34 +23,59 @@
 #include <tuple>
 
 #include "game_data.h"
+#include "ipc_state.h"
 #include "logger.h"
 #include "tracker_frame.h"
 #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
 
+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 {
 
-struct APState {
-  std::unique_ptr<APClient> apclient;
+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;
-
   TrackerFrame* tracker_frame = nullptr;
+  std::list<std::string> tracked_data_storage_keys;
 
-  bool client_active = false;
+  // Client
   std::mutex client_mutex;
+  std::unique_ptr<APClient> apclient;
+
+  // Protected state
+  std::mutex state_mutex;
+
+  std::string status_message = "Not connected to Archipelago.";
 
   bool connected = false;
-  bool has_connection_result = false;
+  std::string connection_failure;
+  int remaining_loops = 0;
 
   std::string data_storage_prefix;
-  std::list<std::string> tracked_data_storage_keys;
   std::string victory_data_storage_key;
 
   std::string save_name;
@@ -58,9 +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;
@@ -72,171 +101,387 @@ 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;
   std::map<int, SunwarpMapping> sunwarp_mapping;
 
   void Connect(std::string server, std::string player, std::string password) {
+    Initialize();
+
+    {
+      std::lock_guard state_guard(state_mutex);
+      SetStatusMessage("Connecting to Archipelago server....");
+    }
+    TrackerLog(fmt::format("Connecting to Archipelago server ({})...", server));
+
+    // Creating and setting up the client has to all be done while holding the
+    // client mutex, so that the other thread doesn't try to poll before we add
+    // handlers, etc.
+    {
+      TrackerLog("Destroying old AP client...");
+
+      std::lock_guard client_guard(client_mutex);
+
+      if (apclient) {
+        DestroyClient();
+      }
+
+      std::string cert_store = "";
+      if (std::filesystem::exists(CERT_STORE_PATH)) {
+        cert_store = CERT_STORE_PATH;
+      }
+
+      apclient = std::make_unique<APClient>(ap_get_uuid(""), "Lingo", server,
+                                            cert_store);
+
+      {
+        std::lock_guard state_guard(state_mutex);
+
+        connected = false;
+        connection_failure.clear();
+        remaining_loops = CONNECTION_TIMEOUT / CONNECTION_BACKOFF_INTERVAL;
+
+        save_name.clear();
+        inventory.clear();
+        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();
+        mastery_requirement = 21;
+        level_2_requirement = 223;
+        location_checks = kNORMAL_LOCATIONS;
+        victory_condition = kTHE_END;
+        early_color_hallways = false;
+        pilgrimage_enabled = false;
+        pilgrimage_allows_roof_access = false;
+        pilgrimage_allows_paintings = false;
+        sunwarp_access = kSUNWARP_ACCESS_NORMAL;
+        sunwarp_shuffle = false;
+        sunwarp_mapping.clear();
+        postgame_shuffle = true;
+      }
+
+      apclient->set_room_info_handler(
+          [this, player, password]() { OnRoomInfo(player, password); });
+
+      apclient->set_location_checked_handler(
+          [this](const std::list<int64_t>& locations) {
+            OnLocationChecked(locations);
+          });
+
+      apclient->set_slot_disconnected_handler(
+          [this]() { OnSlotDisconnected(); });
+
+      apclient->set_socket_disconnected_handler(
+          [this]() { OnSocketDisconnected(); });
+
+      apclient->set_items_received_handler(
+          [this](const std::list<APClient::NetworkItem>& items) {
+            OnItemsReceived(items);
+          });
+
+      apclient->set_retrieved_handler(
+          [this](const std::map<std::string, nlohmann::json>& data) {
+            OnRetrieved(data);
+          });
+
+      apclient->set_set_reply_handler(
+          [this](const std::string& key, const nlohmann::json& value,
+                 const nlohmann::json&) { OnSetReply(key, value); });
+
+      apclient->set_slot_connected_handler(
+          [this, player, server](const nlohmann::json& slot_data) {
+            OnSlotConnected(player, server, slot_data);
+          });
+
+      apclient->set_slot_refused_handler(
+          [this](const std::list<std::string>& errors) {
+            OnSlotRefused(errors);
+          });
+    }
+  }
+
+  std::string GetStatusMessage() {
+    std::lock_guard state_guard(state_mutex);
+
+    return status_message;
+  }
+
+  bool HasCheckedGameLocation(int location_id) {
+    std::lock_guard state_guard(state_mutex);
+
+    return checked_locations.count(location_id);
+  }
+
+  bool HasItem(int item_id, int quantity) {
+    return inventory.count(item_id) && inventory.at(item_id) >= quantity;
+  }
+
+  bool HasItemSafe(int item_id, int quantity) {
+    std::lock_guard state_guard(state_mutex);
+    return HasItem(item_id, quantity);
+  }
+
+  const std::set<std::string>& GetCheckedPaintings() {
+    std::lock_guard state_guard(state_mutex);
+
+    std::string key = fmt::format("{}Paintings", data_storage_prefix);
+    if (!data_storage.count(key)) {
+      data_storage[key] = std::set<std::string>();
+    }
+
+    return std::any_cast<const std::set<std::string>&>(data_storage.at(key));
+  }
+
+  bool IsPaintingChecked(const std::string& painting_id) {
+    const auto& checked_paintings = GetCheckedPaintings();
+
+    std::lock_guard state_guard(state_mutex);
+
+    return checked_paintings.count(painting_id) ||
+           (painting_mapping.count(painting_id) &&
+            checked_paintings.count(painting_mapping.at(painting_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);
+
+    return data_storage.count(victory_data_storage_key) &&
+           std::any_cast<int>(data_storage.at(victory_data_storage_key)) ==
+               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) {
       TrackerLog("Initializing APState...");
 
-      std::thread([this]() {
-        for (;;) {
+      std::thread([this]() { Thread(); }).detach();
+
+      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");
+      tracked_data_storage_keys.push_back("Paintings");
+
+      initialized = true;
+    }
+  }
+
+  void Thread() {
+    std::string display_error;
+
+    for (;;) {
+      {
+        std::lock_guard client_guard(client_mutex);
+        if (apclient) {
+          apclient->poll();
+
           {
-            std::lock_guard client_guard(client_mutex);
-            if (apclient) {
-              apclient->poll();
+            std::lock_guard state_guard(state_mutex);
+
+            if (!connected) {
+              if (!connection_failure.empty()) {
+                TrackerLog(connection_failure);
+
+                display_error = connection_failure;
+                connection_failure.clear();
+
+                DestroyClient();
+              } else {
+                remaining_loops--;
+
+                if (remaining_loops <= 0) {
+                  DestroyClient();
+
+                  SetStatusMessage("Disconnected from Archipelago.");
+                  TrackerLog("Timeout while connecting to Archipelago server.");
+
+                  display_error =
+                      "Timeout while connecting to Archipelago server.";
+                }
+              }
             }
           }
-
-          std::this_thread::sleep_for(std::chrono::milliseconds(100));
         }
-      }).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));
-        }
+      if (!display_error.empty()) {
+        wxMessageBox(display_error, "Connection failed", wxOK | wxICON_ERROR);
+        display_error.clear();
       }
 
-      tracked_data_storage_keys.push_back("PlayerPos");
-      tracked_data_storage_keys.push_back("Paintings");
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+  }
 
-      initialized = true;
+  void OnRoomInfo(std::string player, std::string password) {
+    {
+      std::lock_guard state_guard(state_mutex);
+
+      inventory.clear();
+
+      SetStatusMessage("Connected to Archipelago server. Authenticating...");
     }
 
-    tracker_frame->SetStatusMessage("Connecting to Archipelago server....");
-    TrackerLog(fmt::format("Connecting to Archipelago server ({})...", server));
+    TrackerLog(fmt::format(
+        "Connected to Archipelago server. Authenticating as {} {}", player,
+        (password.empty() ? "without password" : "with password " + password)));
+
+    apclient->ConnectSlot(player, password, ITEM_HANDLING, {"Tracker"},
+                          {AP_MAJOR, AP_MINOR, AP_REVISION});
+  }
 
+  void OnLocationChecked(const std::list<int64_t>& locations) {
     {
-      TrackerLog("Destroying old AP client...");
+      std::lock_guard state_guard(state_mutex);
 
-      std::lock_guard client_guard(client_mutex);
+      for (const int64_t location_id : locations) {
+        checked_locations.insert(location_id);
+        TrackerLog(fmt::format("Location: {}", location_id));
+      }
+    }
 
-      if (apclient) {
-        DestroyClient();
+    RefreshTracker(StateUpdate{.cleared_locations = true});
+  }
+
+  void OnSlotDisconnected() {
+    std::lock_guard state_guard(state_mutex);
+
+    SetStatusMessage(
+        "Disconnected from Archipelago. Attempting to reconnect...");
+    TrackerLog(
+        "Slot disconnected from Archipelago. Attempting to reconnect...");
+  }
+
+  void OnSocketDisconnected() {
+    std::lock_guard state_guard(state_mutex);
+
+    SetStatusMessage(
+        "Disconnected from Archipelago. Attempting to reconnect...");
+    TrackerLog(
+        "Socket disconnected from Archipelago. Attempting to reconnect...");
+  }
+
+  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;
+        }
       }
 
-      std::string cert_store = "";
-      if (std::filesystem::exists(CERT_STORE_PATH)) {
-        cert_store = CERT_STORE_PATH;
+      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});
       }
+    }
 
-      apclient = std::make_unique<APClient>(ap_get_uuid(""), "Lingo", server,
-                                            cert_store);
+    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, state_update);
+      }
     }
 
-    save_name.clear();
-    inventory.clear();
-    checked_locations.clear();
-    data_storage.clear();
-    player_pos = std::nullopt;
-    victory_data_storage_key.clear();
-    door_shuffle_mode = kNO_DOORS;
-    color_shuffle = false;
-    painting_shuffle = false;
-    painting_mapping.clear();
-    painting_codomain.clear();
-    mastery_requirement = 21;
-    level_2_requirement = 223;
-    location_checks = kNORMAL_LOCATIONS;
-    victory_condition = kTHE_END;
-    early_color_hallways = false;
-    pilgrimage_enabled = false;
-    pilgrimage_allows_roof_access = false;
-    pilgrimage_allows_paintings = false;
-    sunwarp_access = kSUNWARP_ACCESS_NORMAL;
-    sunwarp_shuffle = false;
-    sunwarp_mapping.clear();
-
-    std::mutex connection_mutex;
-    connected = false;
-    has_connection_result = false;
-
-    apclient->set_room_info_handler([this, player, password]() {
-      inventory.clear();
+    RefreshTracker(state_update);
+  }
 
-      TrackerLog(fmt::format(
-          "Connected to Archipelago server. Authenticating as {} {}", player,
-          (password.empty() ? "without password"
-                            : "with password " + password)));
-      tracker_frame->SetStatusMessage(
-          "Connected to Archipelago server. Authenticating...");
-
-      apclient->ConnectSlot(player, password, ITEM_HANDLING, {"Tracker"},
-                            {AP_MAJOR, AP_MINOR, AP_REVISION});
-    });
-
-    apclient->set_location_checked_handler(
-        [this](const std::list<int64_t>& locations) {
-          for (const int64_t location_id : locations) {
-            checked_locations.insert(location_id);
-            TrackerLog(fmt::format("Location: {}", location_id));
-          }
+  void OnSetReply(const std::string& key, const nlohmann::json& value) {
+    StateUpdate state_update;
 
-          RefreshTracker(false);
-        });
-
-    apclient->set_slot_disconnected_handler([this]() {
-      tracker_frame->SetStatusMessage(
-          "Disconnected from Archipelago. Attempting to reconnect...");
-      TrackerLog(
-          "Slot disconnected from Archipelago. Attempting to reconnect...");
-    });
-
-    apclient->set_socket_disconnected_handler([this]() {
-      tracker_frame->SetStatusMessage(
-          "Disconnected from Archipelago. Attempting to reconnect...");
-      TrackerLog(
-          "Socket disconnected from Archipelago. Attempting to reconnect...");
-    });
-
-    apclient->set_items_received_handler(
-        [this](const std::list<APClient::NetworkItem>& items) {
-          for (const APClient::NetworkItem& item : items) {
-            inventory[item.item]++;
-            TrackerLog(fmt::format("Item: {}", item.item));
-          }
+    {
+      std::lock_guard state_guard(state_mutex);
+      HandleDataStorage(key, value, state_update);
+    }
 
-          RefreshTracker(false);
-        });
+    RefreshTracker(state_update);
+  }
 
-    apclient->set_retrieved_handler(
-        [this](const std::map<std::string, nlohmann::json>& data) {
-          for (const auto& [key, value] : data) {
-            HandleDataStorage(key, value);
-          }
+  void OnSlotConnected(std::string player, std::string server,
+                       const nlohmann::json& slot_data) {
+    IPC_SetTrackerSlot(server, player);
 
-          RefreshTracker(false);
-        });
+    TrackerLog("Connected to Archipelago!");
 
-    apclient->set_set_reply_handler([this](const std::string& key,
-                                           const nlohmann::json& value,
-                                           const nlohmann::json&) {
-      HandleDataStorage(key, value);
-      RefreshTracker(false);
-    });
+    {
+      std::lock_guard state_guard(state_mutex);
 
-    apclient->set_slot_connected_handler([this, player, server,
-                                          &connection_mutex](
-                                             const nlohmann::json& slot_data) {
-      tracker_frame->SetStatusMessage(
-          fmt::format("Connected to Archipelago! ({}@{})", player, server));
-      TrackerLog("Connected to Archipelago!");
+      SetStatusMessage(
+          fmt::format("Connected to Archipelago! ({}@{}).", player, server));
 
       save_name = fmt::format("zzAP_{}_{}.save", apclient->get_seed(),
                               apclient->get_player_number());
       data_storage_prefix =
           fmt::format("Lingo_{}_", apclient->get_player_number());
       door_shuffle_mode = slot_data["shuffle_doors"].get<DoorShuffleMode>();
+      if (slot_data.contains("group_doors")) {
+        group_doors = slot_data.contains("group_doors") &&
+                      slot_data["group_doors"].get<int>() == 1;
+      } else {
+        // If group_doors doesn't exist yet, that means kPANELS_MODE is
+        // actually kSIMPLE_DOORS.
+        if (door_shuffle_mode == kPANELS_MODE) {
+          door_shuffle_mode = kDOORS_MODE;
+          group_doors = true;
+        }
+      }
       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>();
@@ -258,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();
@@ -295,111 +543,87 @@ struct APState {
       apclient->Get(corrected_keys);
       apclient->SetNotify(corrected_keys);
 
-      ResetReachabilityRequirements();
-      RefreshTracker(true);
-
-      {
-        std::lock_guard connection_lock(connection_mutex);
-        if (!has_connection_result) {
-          connected = true;
-          has_connection_result = true;
-        }
-      }
-    });
-
-    apclient->set_slot_refused_handler(
-        [this, &connection_mutex](const std::list<std::string>& errors) {
-          {
-            std::lock_guard connection_lock(connection_mutex);
-            connected = false;
-            has_connection_result = true;
-          }
-
-          tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
-
-          std::vector<std::string> error_messages;
-          error_messages.push_back("Could not connect to Archipelago.");
-
-          for (const std::string& error : errors) {
-            if (error == "InvalidSlot") {
-              error_messages.push_back("Invalid player name.");
-            } else if (error == "InvalidGame") {
-              error_messages.push_back(
-                  "The specified player is not playing Lingo.");
-            } else if (error == "IncompatibleVersion") {
-              error_messages.push_back(
-                  "The Archipelago server is not the correct version for this "
-                  "client.");
-            } else if (error == "InvalidPassword") {
-              error_messages.push_back("Incorrect password.");
-            } else if (error == "InvalidItemsHandling") {
-              error_messages.push_back(
-                  "Invalid item handling flag. This is a bug with the tracker. "
-                  "Please report it to the lingo-ap-tracker GitHub.");
-            } else {
-              error_messages.push_back("Unknown error.");
-            }
-          }
-
-          std::string full_message = hatkirby::implode(error_messages, " ");
-          TrackerLog(full_message);
-
-          wxMessageBox(full_message, "Connection failed", wxOK | wxICON_ERROR);
-        });
-
-    client_active = true;
-
-    int timeout = 5000;  // 5 seconds
-    int interval = 100;
-    int remaining_loops = timeout / interval;
-    while (true) {
-      {
-        std::lock_guard connection_lock(connection_mutex);
-        if (has_connection_result) {
-          break;
-        }
-      }
-
-      if (interval == 0) {
-        DestroyClient();
-
-        tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
-        TrackerLog("Timeout while connecting to Archipelago server.");
-        wxMessageBox("Timeout while connecting to Archipelago server.",
-                     "Connection failed", wxOK | wxICON_ERROR);
+      connected = true;
+    }
 
-        {
-          std::lock_guard connection_lock(connection_mutex);
-          connected = false;
-          has_connection_result = true;
-        }
+    ResetReachabilityRequirements();
+    RefreshTracker(std::nullopt);
+  }
 
-        break;
+  void OnSlotRefused(const std::list<std::string>& errors) {
+    std::vector<std::string> error_messages;
+    error_messages.push_back("Could not connect to Archipelago.");
+
+    for (const std::string& error : errors) {
+      if (error == "InvalidSlot") {
+        error_messages.push_back("Invalid player name.");
+      } else if (error == "InvalidGame") {
+        error_messages.push_back("The specified player is not playing Lingo.");
+      } else if (error == "IncompatibleVersion") {
+        error_messages.push_back(
+            "The Archipelago server is not the correct version for this "
+            "client.");
+      } else if (error == "InvalidPassword") {
+        error_messages.push_back("Incorrect password.");
+      } else if (error == "InvalidItemsHandling") {
+        error_messages.push_back(
+            "Invalid item handling flag. This is a bug with the tracker. "
+            "Please report it to the lingo-ap-tracker GitHub.");
+      } else {
+        error_messages.push_back("Unknown error.");
       }
+    }
 
-      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    {
+      std::lock_guard state_guard(state_mutex);
+      connection_failure = hatkirby::implode(error_messages, " ");
 
-      interval--;
+      SetStatusMessage("Disconnected from Archipelago.");
     }
+  }
 
-    if (connected) {
-      client_active = false;
-    }
+  // Assumes state mutex is locked.
+  void SetStatusMessage(std::string msg) {
+    status_message = std::move(msg);
+
+    tracker_frame->UpdateStatusMessage();
   }
 
-  void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
+  // Assumes state mutex is locked.
+  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>>();
       }
@@ -408,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);
       }
@@ -419,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;
       }
@@ -428,74 +655,39 @@ struct APState {
     }
   }
 
-  bool HasCheckedGameLocation(int location_id) {
-    return checked_locations.count(location_id);
-  }
-
-  bool HasCheckedHuntPanel(int location_id) {
-    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) {
-    std::string key =
-        fmt::format("{}Achievement|{}", data_storage_prefix, name);
-    return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
-  }
-
-  const std::set<std::string>& GetCheckedPaintings() {
-    std::string key = fmt::format("{}Paintings", data_storage_prefix);
-    if (!data_storage.count(key)) {
-      data_storage[key] = std::set<std::string>();
-    }
+  // State mutex should NOT be locked.
+  // nullopt state_update indicates a reset.
+  void RefreshTracker(std::optional<StateUpdate> state_update) {
+    TrackerLog("Refreshing display...");
 
-    return std::any_cast<const std::set<std::string>&>(data_storage.at(key));
-  }
+    if (!state_update || state_update->progression_items ||
+        !state_update->paintings.empty()) {
+      std::string prev_msg;
+      {
+        std::lock_guard state_guard(state_mutex);
 
-  bool IsPaintingChecked(const std::string& painting_id) {
-    const auto& checked_paintings = GetCheckedPaintings();
+        prev_msg = status_message;
+        SetStatusMessage(fmt::format("{} Recalculating...", status_message));
+      }
 
-    return checked_paintings.count(painting_id) ||
-           (painting_mapping.count(painting_id) &&
-            checked_paintings.count(painting_mapping.at(painting_id)));
-  }
+      RecalculateReachability();
 
-  void RefreshTracker(bool reset) {
-    TrackerLog("Refreshing display...");
+      {
+        std::lock_guard state_guard(state_mutex);
 
-    RecalculateReachability();
+        SetStatusMessage(prev_msg);
+      }
+    }
+    
 
-    if (reset) {
+    if (!state_update) {
       tracker_frame->ResetIndicators();
     } else {
-      tracker_frame->UpdateIndicators();
-    }
-  }
-
-  int64_t GetItemId(const std::string& item_name) {
-    int64_t ap_id = apclient->get_item_id(item_name);
-    if (ap_id == APClient::INVALID_NAME_ID) {
-      TrackerLog(fmt::format("Could not find AP item ID for {}", item_name));
+      tracker_frame->UpdateIndicators(*state_update);
     }
-
-    return ap_id;
-  }
-
-  std::string GetItemName(int id) { return apclient->get_item_name(id); }
-
-  bool HasReachedGoal() {
-    return data_storage.count(victory_data_storage_key) &&
-           std::any_cast<int>(data_storage.at(victory_data_storage_key)) ==
-               30;  // CLIENT_GOAL
   }
 
   void DestroyClient() {
-    client_active = false;
     apclient->reset();
     apclient.reset();
   }
@@ -514,39 +706,63 @@ void AP_Connect(std::string server, std::string player, std::string password) {
   GetState().Connect(server, player, password);
 }
 
-std::string AP_GetSaveName() { return GetState().save_name; }
+std::string AP_GetStatusMessage() { return GetState().GetStatusMessage(); }
 
-bool AP_HasCheckedGameLocation(int location_id) {
-  return GetState().HasCheckedGameLocation(location_id);
+std::string AP_GetSaveName() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().save_name;
 }
 
-bool AP_HasCheckedHuntPanel(int location_id) {
-  return GetState().HasCheckedHuntPanel(location_id);
+bool AP_HasCheckedGameLocation(int location_id) {
+  return GetState().HasCheckedGameLocation(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() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().door_shuffle_mode;
+}
+
+bool AP_AreDoorsGrouped() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().group_doors;
 }
 
-DoorShuffleMode AP_GetDoorShuffleMode() { return GetState().door_shuffle_mode; }
+bool AP_IsColorShuffle() {
+  std::lock_guard state_guard(GetState().state_mutex);
 
-bool AP_IsColorShuffle() { return GetState().color_shuffle; }
+  return GetState().color_shuffle;
+}
 
-bool AP_IsPaintingShuffle() { return GetState().painting_shuffle; }
+bool AP_IsPaintingShuffle() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().painting_shuffle;
+}
+
+std::map<std::string, std::string> AP_GetPaintingMapping() {
+  std::lock_guard state_guard(GetState().state_mutex);
 
-const std::map<std::string, std::string>& AP_GetPaintingMapping() {
   return GetState().painting_mapping;
 }
 
 bool AP_IsPaintingMappedTo(const std::string& painting_id) {
+  std::lock_guard state_guard(GetState().state_mutex);
+
   return GetState().painting_codomain.count(painting_id);
 }
 
-const std::set<std::string>& AP_GetCheckedPaintings() {
+std::set<std::string> AP_GetCheckedPaintings() {
   return GetState().GetCheckedPaintings();
 }
 
@@ -554,11 +770,29 @@ bool AP_IsPaintingChecked(const std::string& painting_id) {
   return GetState().IsPaintingChecked(painting_id);
 }
 
-int AP_GetMasteryRequirement() { return GetState().mastery_requirement; }
+void AP_RevealPaintings() { GetState().RevealPaintings(); }
+
+int AP_GetMasteryRequirement() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().mastery_requirement;
+}
 
-int AP_GetLevel2Requirement() { return GetState().level_2_requirement; }
+int AP_GetLevel2Requirement() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  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);
+
   int world_state = 0;
 
   switch (GetState().location_checks) {
@@ -575,43 +809,76 @@ bool AP_IsLocationVisible(int classification) {
       return false;
   }
 
-  if (GetState().door_shuffle_mode && !GetState().early_color_hallways) {
+  if (GetState().door_shuffle_mode == kDOORS_MODE &&
+      !GetState().early_color_hallways) {
     world_state |= kLOCATION_SMALL_SPHERE_ONE;
   }
 
   return (world_state & classification);
 }
 
+PanelShuffleMode AP_GetPanelShuffleMode() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().panel_shuffle_mode;
+}
+
 VictoryCondition AP_GetVictoryCondition() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
   return GetState().victory_condition;
 }
 
-bool AP_HasAchievement(const std::string& achievement_name) {
-  return GetState().HasAchievement(achievement_name);
+bool AP_HasEarlyColorHallways() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().early_color_hallways;
 }
 
-bool AP_HasEarlyColorHallways() { return GetState().early_color_hallways; }
+bool AP_IsPilgrimageEnabled() {
+  std::lock_guard state_guard(GetState().state_mutex);
 
-bool AP_IsPilgrimageEnabled() { return GetState().pilgrimage_enabled; }
+  return GetState().pilgrimage_enabled;
+}
 
 bool AP_DoesPilgrimageAllowRoofAccess() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
   return GetState().pilgrimage_allows_roof_access;
 }
 
 bool AP_DoesPilgrimageAllowPaintings() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
   return GetState().pilgrimage_allows_paintings;
 }
 
-SunwarpAccess AP_GetSunwarpAccess() { return GetState().sunwarp_access; }
+SunwarpAccess AP_GetSunwarpAccess() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().sunwarp_access;
+}
 
-bool AP_IsSunwarpShuffle() { return GetState().sunwarp_shuffle; }
+bool AP_IsSunwarpShuffle() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
+  return GetState().sunwarp_shuffle;
+}
 
-const std::map<int, SunwarpMapping>& AP_GetSunwarpMapping() {
+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() {
+  std::lock_guard state_guard(GetState().state_mutex);
+
   return GetState().player_pos;
 }
+
+bool AP_IsPanelSolved(int solve_index) {
+  return GetState().IsPanelSolved(solve_index);
+}
@@ -11,7 +11,7 @@
 
 class TrackerFrame;
 
-enum DoorShuffleMode { kNO_DOORS = 0, kSIMPLE_DOORS = 1, kCOMPLEX_DOORS = 2 };
+enum DoorShuffleMode { kNO_DOORS = 0, kPANELS_MODE = 1, kDOORS_MODE = 2 };
 
 enum VictoryCondition {
   kTHE_END = 0,
@@ -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,43 +41,57 @@ 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);
 
+std::string AP_GetStatusMessage();
+
 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);
 
-std::string AP_GetItemName(int item_id);
+bool AP_HasItemSafe(int item_id, int quantity = 1);
 
 DoorShuffleMode AP_GetDoorShuffleMode();
 
+bool AP_AreDoorsGrouped();
+
 bool AP_IsColorShuffle();
 
 bool AP_IsPaintingShuffle();
 
-const std::map<std::string, std::string>& AP_GetPaintingMapping();
+std::map<std::string, std::string> AP_GetPaintingMapping();
 
 bool AP_IsPaintingMappedTo(const std::string& painting_id);
 
-const std::set<std::string>& AP_GetCheckedPaintings();
+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();
 
@@ -89,10 +105,14 @@ SunwarpAccess AP_GetSunwarpAccess();
 
 bool AP_IsSunwarpShuffle();
 
-const std::map<int, SunwarpMapping>& AP_GetSunwarpMapping();
+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,36 +12,11 @@
 
 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_;
   std::vector<Panel> panels_;
+  std::vector<PanelDoor> panel_doors_;
   std::vector<MapArea> map_areas_;
   std::vector<SubwayItem> subway_items_;
   std::vector<PaintingExit> paintings_;
@@ -49,6 +24,7 @@ struct GameData {
   std::map<std::string, int> room_by_id_;
   std::map<std::string, int> door_by_id_;
   std::map<std::string, int> panel_by_id_;
+  std::map<std::string, int> panel_doors_by_id_;
   std::map<std::string, int> area_by_id_;
   std::map<std::string, int> painting_by_id_;
 
@@ -56,6 +32,7 @@ struct GameData {
 
   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_;
 
@@ -66,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_;
 
@@ -81,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));
@@ -98,8 +77,18 @@ 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>());
 
@@ -177,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>()));
               }
             }
           }
@@ -288,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,
@@ -357,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,
@@ -373,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));
@@ -430,6 +426,90 @@ struct GameData {
         }
       }
 
+      if (room_it.second["panel_doors"]) {
+        for (const auto &panel_door_it : room_it.second["panel_doors"]) {
+          std::string panel_door_name = panel_door_it.first.as<std::string>();
+          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]
+                        [panel_door_name]) {
+            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));
+          }
+
+          if (panel_door_it.second["panel_group"]) {
+            std::string panel_group =
+                panel_door_it.second["panel_group"].as<std::string>();
+
+            if (ids_config["panel_groups"] &&
+                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));
+            }
+          }
+        }
+      }
+
       if (room_it.second["paintings"]) {
         for (const auto &painting : room_it.second["paintings"]) {
           std::string internal_id = painting["id"].as<std::string>();
@@ -437,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;
@@ -478,33 +565,74 @@ 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));
           }
 
-          int index = 1;
-          for (const auto &stage : progression_it.second) {
-            int door_id = -1;
+          if (progression_it.second["doors"]) {
+            int index = 1;
+            for (const auto &stage : progression_it.second["doors"]) {
+              int door_id = -1;
+
+              if (stage.IsScalar()) {
+                door_id =
+                    AddOrGetDoor(rooms_[room_id].name, stage.as<std::string>());
+              } else {
+                door_id = AddOrGetDoor(stage["room"].as<std::string>(),
+                                       stage["door"].as<std::string>());
+              }
 
-            if (stage.IsScalar()) {
-              door_id =
-                  AddOrGetDoor(rooms_[room_id].name, stage.as<std::string>());
-            } else {
-              door_id = AddOrGetDoor(stage["room"].as<std::string>(),
-                                     stage["door"].as<std::string>());
+              doors_[door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
             }
+          }
+
+          if (progression_it.second["panel_doors"]) {
+            int index = 1;
+            for (const auto &stage : progression_it.second["panel_doors"]) {
+              int panel_door_id = -1;
+
+              if (stage.IsScalar()) {
+                panel_door_id = AddOrGetPanelDoor(rooms_[room_id].name,
+                                                  stage.as<std::string>());
+              } else {
+                panel_door_id =
+                    AddOrGetPanelDoor(stage["room"].as<std::string>(),
+                                      stage["panel_door"].as<std::string>());
+              }
 
-            doors_[door_id].progressives.push_back(
-                {.item_name = progressive_item_name,
-                 .ap_item_id = progressive_item_id,
-                 .quantity = index});
-            index++;
+              panel_doors_[panel_door_id].progressives.push_back(
+                  {.item_name = progressive_item_name,
+                   .ap_item_id = progressive_item_id,
+                   .quantity = index});
+              index++;
+            }
           }
         }
       }
     }
 
+    // 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;
@@ -525,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;
 
@@ -541,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)) {
@@ -639,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);
           }
@@ -666,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"]) {
@@ -681,6 +809,18 @@ struct GameData {
         }
       }
 
+      if (subway_it["entrances"]) {
+        for (const auto &entrance_it : subway_it["entrances"]) {
+          subway_item.entrances.push_back(entrance_it.as<std::string>());
+        }
+      }
+
+      if (subway_it["exits"]) {
+        for (const auto &exit_it : subway_it["exits"]) {
+          subway_item.exits.push_back(exit_it.as<std::string>());
+        }
+      }
+
       if (subway_it["sunwarp"]) {
         SubwaySunwarp sunwarp;
         sunwarp.dots = subway_it["sunwarp"]["dots"].as<int>();
@@ -707,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);
     }
 
@@ -760,6 +904,18 @@ struct GameData {
     return panel_by_id_[full_name];
   }
 
+  int AddOrGetPanelDoor(std::string room, std::string panel) {
+    std::string full_name = room + " - " + panel;
+
+    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({});
+    }
+
+    return panel_doors_by_id_[full_name];
+  }
+
   int AddOrGetArea(std::string area) {
     if (!area_by_id_.count(area)) {
       if (loaded_area_data_) {
@@ -792,6 +948,11 @@ GameData &GetState() {
 
 }  // namespace
 
+bool SubwayItem::HasWarps() const {
+  return !(this->tags.empty() && this->entrances.empty() &&
+           this->exits.empty());
+}
+
 bool SubwaySunwarp::operator<(const SubwaySunwarp &rhs) const {
   return std::tie(dots, type) < std::tie(rhs.dots, rhs.type);
 }
@@ -810,6 +971,10 @@ const std::vector<Door> &GD_GetDoors() { return GetState().doors_; }
 
 const Door &GD_GetDoor(int door_id) { return GetState().doors_.at(door_id); }
 
+const PanelDoor &GD_GetPanelDoor(int panel_door_id) {
+  return GetState().panel_doors_.at(panel_door_id);
+}
+
 int GD_GetDoorByName(const std::string &name) {
   return GetState().door_by_id_.at(name);
 }
@@ -818,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);
 }
@@ -860,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;
+  }
+}
@@ -56,6 +56,8 @@ struct Panel {
   bool non_counting = false;
   int ap_location_id = -1;
   bool hunt = false;
+  int panel_door = -1;
+  int solve_index = -1;
 };
 
 struct ProgressiveRequirement {
@@ -83,6 +85,13 @@ struct Door {
   DoorType type = DoorType::kNormal;
 };
 
+struct PanelDoor {
+  int ap_item_id = -1;
+  int group_ap_item_id = -1;
+  std::vector<ProgressiveRequirement> progressives;
+  std::string item_name;
+};
+
 struct Exit {
   int source_room;
   int destination_room;
@@ -94,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 {
@@ -146,11 +157,16 @@ struct SubwayItem {
   int id;
   int x;
   int y;
+  bool tilted = false;
   std::optional<int> door;
-  std::vector<std::string> paintings;
-  std::vector<std::string> tags;
+  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
   std::optional<SubwaySunwarp> sunwarp;
   std::optional<std::string> special;
+
+  bool HasWarps() const;
 };
 
 const std::vector<MapArea>& GD_GetMapAreas();
@@ -161,6 +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();
@@ -171,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,83 +0,0 @@
-// Godot save decoder algorithm by Chris Souvey.
-
-#include "godot_variant.h"
-
-#include <algorithm>
-#include <charconv>
-#include <cstddef>
-#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 */
@@ -0,0 +1,54 @@
+#include "ipc_dialog.h"
+
+#include "tracker_config.h"
+
+constexpr const char* kDefaultIpcAddress = "ws://127.0.0.1:41253";
+
+IpcDialog::IpcDialog() : wxDialog(nullptr, wxID_ANY, "Connect to game") {
+  std::string address_value;
+  if (GetTrackerConfig().ipc_address.empty()) {
+    address_value = kDefaultIpcAddress;
+  } else {
+    address_value = GetTrackerConfig().ipc_address;
+  }
+
+  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, FromDIP(10), FromDIP(10));
+  form_sizer->Add(
+      new wxStaticText(this, -1, "Address:"),
+      wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
+  form_sizer->Add(address_box_, wxSizerFlags().Expand());
+  form_sizer->Add(reset_button);
+
+  wxBoxSizer* top_sizer = new wxBoxSizer(wxVERTICAL);
+  wxStaticText* top_text = new wxStaticText(this, -1, "");
+  top_sizer->Add(top_text, wxSizerFlags().Align(wxALIGN_LEFT).DoubleBorder().Expand());
+  top_sizer->Add(form_sizer, wxSizerFlags().DoubleBorder().Expand());
+  top_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL),
+                 wxSizerFlags().Border().Center());
+
+  SetSizer(top_sizer);
+  Layout();
+  Fit();
+
+  int width = top_text->GetClientSize().GetWidth();
+  top_text->SetLabel(
+      "This allows you to connect to a running Lingo game and track non-multiworld "
+      "state, such as the player's position and what panels are solved. Unless "
+      "you are doing something weird, the default value for the address is "
+      "probably correct.");
+  top_text->Wrap(width);
+
+  Fit();
+  Center();
+}
+
+void IpcDialog::OnResetClicked(wxCommandEvent& event) {
+  address_box_->SetValue(kDefaultIpcAddress);
+}
@@ -0,0 +1,24 @@
+#ifndef IPC_DIALOG_H_F4C5680C
+#define IPC_DIALOG_H_F4C5680C
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <string>
+
+class IpcDialog : public wxDialog {
+ public:
+  IpcDialog();
+
+  std::string GetIpcAddress() { return address_box_->GetValue().utf8_string(); }
+
+ private:
+  void OnResetClicked(wxCommandEvent& event);
+
+  wxTextCtrl* address_box_;
+};
+
+#endif /* end of include guard: IPC_DIALOG_H_F4C5680C */
@@ -0,0 +1,367 @@
+#include "ipc_state.h"
+
+#define _WEBSOCKETPP_CPP11_STRICT_
+
+#include <fmt/core.h>
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <set>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <wswrap.hpp>
+
+#include "ap_state.h"
+#include "logger.h"
+#include "tracker_frame.h"
+
+namespace {
+
+struct IPCState {
+  std::mutex state_mutex;
+  TrackerFrame* tracker_frame = nullptr;
+
+  // Protected state
+  bool initialized = false;
+  std::string address;
+  bool should_disconnect = false;
+
+  std::optional<std::string> status_message;
+
+  bool slot_matches = false;
+  std::string tracker_ap_server;
+  std::string tracker_ap_user;
+  std::string game_ap_server;
+  std::string game_ap_user;
+
+  std::optional<std::tuple<int, int>> player_position;
+
+  // Thread state
+  std::unique_ptr<wswrap::WS> ws;
+  bool connected = false;
+
+  void SetTrackerFrame(TrackerFrame* frame) { tracker_frame = frame; }
+
+  void Connect(std::string a) {
+    // This is the main concurrency concern, as it mutates protected state in an
+    // important way. Thread() is documented with how it interacts with this
+    // function.
+    std::lock_guard state_guard(state_mutex);
+
+    if (!initialized) {
+      std::thread([this]() { Thread(); }).detach();
+
+      initialized = true;
+    } else if (address != a) {
+      should_disconnect = true;
+    }
+
+    address = a;
+  }
+
+  std::optional<std::string> GetStatusMessage() {
+    std::lock_guard state_guard(state_mutex);
+
+    return status_message;
+  }
+
+  void SetTrackerSlot(std::string server, std::string user) {
+    // This function is called from the APState thread, not the main thread, and
+    // it mutates protected state. It only really competes with OnMessage(), when
+    // a "Connect" message is received. If this is called right before, and the
+    // tracker slot does not match the old game slot, it will initiate a
+    // disconnect, and then the OnMessage() handler will see should_disconnect
+    // and stop processing the "Connect" message. If this is called right after
+    // and the slot does not match, IPC will disconnect, which is tolerable.
+    std::lock_guard state_guard(state_mutex);
+
+    tracker_ap_server = std::move(server);
+    tracker_ap_user = std::move(user);
+
+    CheckIfSlotMatches();
+
+    if (!slot_matches) {
+      should_disconnect = true;
+      address.clear();
+    }
+  }
+
+  bool IsConnected() {
+    std::lock_guard state_guard(state_mutex);
+
+    return slot_matches;
+  }
+
+  std::optional<std::tuple<int, int>> GetPlayerPosition() {
+    std::lock_guard state_guard(state_mutex);
+
+    return player_position;
+  }
+
+ private:
+  void Thread() {
+    for (;;) {
+      // initialized is definitely true because it is set to true when the thread
+      // is created and only set to false within this block, when the thread is
+      // killed. Thus, a call to Connect would always at most set
+      // should_disconnect and address. If this happens before this block, it is
+      // as if we are starting from a new thread anyway because should_disconnect
+      // is immediately reset. If a call to Connect happens after this block,
+      // then a connection attempt will be made to the wrong address, but the
+      // thread will grab the mutex right after this and back out the wrong
+      // connection.
+      std::string ipc_address;
+      {
+        std::lock_guard state_guard(state_mutex);
+
+        SetStatusMessage("Disconnected from game.");
+
+        should_disconnect = false;
+
+        slot_matches = false;
+        game_ap_server.clear();
+        game_ap_user.clear();
+
+        player_position = std::nullopt;
+
+        if (address.empty()) {
+          initialized = false;
+          return;
+        }
+
+        ipc_address = address;
+
+        SetStatusMessage("Connecting to game...");
+      }
+
+      int backoff_amount = 0;
+
+      TrackerLog(fmt::format("Looking for game over IPC ({})...", ipc_address));
+
+      while (!connected) {
+        if (TryConnect(ipc_address)) {
+          int backoff_limit = (backoff_amount + 1) * 10;
+
+          for (int i = 0; i < backoff_limit && !connected; i++) {
+            // If Connect is called right before this block, we will see and
+            // handle should_disconnect. If it is called right after, we will do
+            // one bad poll, one sleep, and then grab the mutex again right
+            // after.
+            {
+              std::lock_guard state_guard(state_mutex);
+              if (should_disconnect) {
+                break;
+              }
+            }
+
+            ws->poll();
+
+            // Back off
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+          }
+
+          backoff_amount++;
+        } else {
+          std::lock_guard state_guard(state_mutex);
+
+          if (!should_disconnect) {
+            should_disconnect = true;
+            address.clear();
+
+            SetStatusMessage("Disconnected from game.");
+          }
+
+          break;
+        }
+
+        // If Connect is called right before this block, we will see and handle
+        // should_disconnect. If it is called right after, and the connection
+        // was unsuccessful, we will grab the mutex after one bad connection
+        // attempt. If the connection was successful, we grab the mutex right
+        // after exiting the loop.
+        bool show_error = false;
+        {
+          std::lock_guard state_guard(state_mutex);
+
+          if (should_disconnect) {
+            break;
+          } else if (!connected) {
+            if (backoff_amount >= 10) {
+              should_disconnect = true;
+              address.clear();
+
+              SetStatusMessage("Disconnected from game.");
+
+              show_error = true;
+            } else {
+              TrackerLog(fmt::format("Retrying IPC in {} second(s)...",
+                                     backoff_amount + 1));
+            }
+          }
+        }
+
+        // We do this after giving up the mutex because otherwise we could
+        // deadlock with the main thread.
+        if (show_error) {
+          TrackerLog("Giving up on IPC.");
+
+          wxMessageBox("Connection to Lingo timed out.", "Connection failed",
+                       wxOK | wxICON_ERROR);
+          break;
+        }
+      }
+
+      // Pretty much every lock guard in the thread is the same. We check for
+      // should_disconnect, and if it gets set directly after the block, we do
+      // minimal bad work before checking for it again.
+      {
+        std::lock_guard state_guard(state_mutex);
+        if (should_disconnect) {
+          ws.reset();
+          continue;
+        }
+      }
+
+      while (connected) {
+        ws->poll();
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+        {
+          std::lock_guard state_guard(state_mutex);
+          if (should_disconnect) {
+            ws.reset();
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  bool TryConnect(std::string ipc_address) {
+    try {
+      ws = std::make_unique<wswrap::WS>(
+          ipc_address, [this]() { OnConnect(); }, [this]() { OnClose(); },
+          [this](const std::string& s) { OnMessage(s); },
+          [this](const std::string& s) { OnError(s); });
+      return true;
+    } catch (const std::exception& ex) {
+      TrackerLog(fmt::format("Error connecting to Lingo: {}", ex.what()));
+      wxMessageBox(ex.what(), "Error connecting to Lingo", wxOK | wxICON_ERROR);
+      ws.reset();
+      return false;
+    }
+  }
+
+  void OnConnect() {
+    connected = true;
+
+    {
+      std::lock_guard state_guard(state_mutex);
+
+      slot_matches = false;
+      player_position = std::nullopt;
+    }
+  }
+
+  void OnClose() {
+    connected = false;
+
+    {
+      std::lock_guard state_guard(state_mutex);
+
+      slot_matches = false;
+    }
+  }
+
+  void OnMessage(const std::string& s) {
+    TrackerLog(s);
+
+    auto msg = nlohmann::json::parse(s);
+
+    if (msg["cmd"] == "Connect") {
+      std::lock_guard state_guard(state_mutex);
+      if (should_disconnect) {
+        return;
+      }
+
+      game_ap_server = msg["slot"]["server"];
+      game_ap_user = msg["slot"]["player"];
+
+      CheckIfSlotMatches();
+
+      if (!slot_matches) {
+        tracker_frame->ConnectToAp(game_ap_server, game_ap_user,
+                                   msg["slot"]["password"]);
+      }
+    } else if (msg["cmd"] == "UpdatePosition") {
+      std::lock_guard state_guard(state_mutex);
+
+      player_position =
+          std::make_tuple<int, int>(msg["position"]["x"], msg["position"]["z"]);
+
+      tracker_frame->UpdateIndicators(StateUpdate{.player_position = true});
+    }
+  }
+
+  void OnError(const std::string& s) {}
+
+  // Assumes mutex is locked.
+  void CheckIfSlotMatches() {
+    slot_matches = (tracker_ap_server == game_ap_server &&
+                    tracker_ap_user == game_ap_user);
+
+    if (slot_matches) {
+      SetStatusMessage("Connected to game.");
+
+      Sync();
+    } else if (connected) {
+      SetStatusMessage("Local game doesn't match AP slot.");
+    }
+  }
+
+  // Assumes mutex is locked.
+  void SetStatusMessage(std::optional<std::string> msg) {
+    status_message = msg;
+
+    tracker_frame->UpdateStatusMessage();
+  }
+
+  void Sync() {
+    nlohmann::json msg;
+    msg["cmd"] = "Sync";
+
+    ws->send_text(msg.dump());
+  }
+};
+
+IPCState& GetState() {
+  static IPCState* instance = new IPCState();
+  return *instance;
+}
+
+}  // namespace
+
+void IPC_SetTrackerFrame(TrackerFrame* tracker_frame) {
+  GetState().SetTrackerFrame(tracker_frame);
+}
+
+void IPC_Connect(std::string address) { GetState().Connect(address); }
+
+std::optional<std::string> IPC_GetStatusMessage() {
+  return GetState().GetStatusMessage();
+}
+
+void IPC_SetTrackerSlot(std::string server, std::string user) {
+  GetState().SetTrackerSlot(server, user);
+}
+
+bool IPC_IsConnected() { return GetState().IsConnected(); }
+
+std::optional<std::tuple<int, int>> IPC_GetPlayerPosition() {
+  return GetState().GetPlayerPosition();
+}
@@ -0,0 +1,23 @@
+#ifndef IPC_STATE_H_6B3B0958
+#define IPC_STATE_H_6B3B0958
+
+#include <optional>
+#include <set>
+#include <string>
+#include <tuple>
+
+class TrackerFrame;
+
+void IPC_SetTrackerFrame(TrackerFrame* tracker_frame);
+
+void IPC_Connect(std::string address);
+
+std::optional<std::string> IPC_GetStatusMessage();
+
+void IPC_SetTrackerSlot(std::string server, std::string user);
+
+bool IPC_IsConnected();
+
+std::optional<std::tuple<int, int>> IPC_GetPlayerPosition();
+
+#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();
@@ -4,9 +4,8 @@ void NetworkSet::Clear() {
   network_by_item_.clear();
 }
 
-void NetworkSet::AddLink(int id1, int id2) {
-  if (id2 > id1) {
-    // Make sure id1 < id2
+void NetworkSet::AddLink(int id1, int id2, bool two_way) {
+  if (two_way && id2 > id1) {
     std::swap(id1, id2);
   }
 
@@ -17,13 +16,14 @@ void NetworkSet::AddLink(int id1, int id2) {
     network_by_item_[id2] = {};
   }
 
-  network_by_item_[id1].insert({id1, id2});
-  network_by_item_[id2].insert({id1, id2});
+  NetworkNode node = {id1, id2, two_way};
+
+  network_by_item_[id1].insert(node);
+  network_by_item_[id2].insert(node);
 }
 
-void NetworkSet::AddLinkToNetwork(int network_id, int id1, int id2) {
-  if (id2 > id1) {
-    // Make sure id1 < id2
+void NetworkSet::AddLinkToNetwork(int network_id, int id1, int id2, bool two_way) {
+  if (two_way && id2 > id1) {
     std::swap(id1, id2);
   }
 
@@ -31,13 +31,22 @@ void NetworkSet::AddLinkToNetwork(int network_id, int id1, int id2) {
     network_by_item_[network_id] = {};
   }
 
-  network_by_item_[network_id].insert({id1, id2});
+  NetworkNode node = {id1, id2, two_way};
+
+  network_by_item_[network_id].insert(node);
 }
 
 bool NetworkSet::IsItemInNetwork(int id) const {
   return network_by_item_.count(id);
 }
 
-const std::set<std::pair<int, int>>& NetworkSet::GetNetworkGraph(int id) const {
+const std::set<NetworkNode>& NetworkSet::GetNetworkGraph(int id) const {
   return network_by_item_.at(id);
 }
+
+bool NetworkNode::operator<(const NetworkNode& rhs) const {
+  if (entry != rhs.entry) return entry < rhs.entry;
+  if (exit != rhs.exit) return exit < rhs.exit;
+  if (two_way != rhs.two_way) return two_way < rhs.two_way;
+  return false;
+}
@@ -7,21 +7,29 @@
 #include <utility>
 #include <vector>
 
+struct NetworkNode {
+  int entry;
+  int exit;
+  bool two_way;
+
+  bool operator<(const NetworkNode& rhs) const;
+};
+
 class NetworkSet {
  public:
   void Clear();
 
-  void AddLink(int id1, int id2);
+  void AddLink(int id1, int id2, bool two_way);
 
-  void AddLinkToNetwork(int network_id, int id1, int id2);
+  void AddLinkToNetwork(int network_id, int id1, int id2, bool two_way);
 
   bool IsItemInNetwork(int id) const;
 
-  const std::set<std::pair<int, int>>& GetNetworkGraph(int id) const;
+  const std::set<NetworkNode>& GetNetworkGraph(int id) const;
 
  private:
 
-  std::map<int, std::set<std::pair<int, int>>> network_by_item_;
+  std::map<int, std::set<NetworkNode>> network_by_item_;
 };
 
 #endif /* end of include guard: NETWORK_SET_H_3036B8E3 */
@@ -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,31 +9,25 @@
 #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 {
 
-std::optional<int> GetRealSubwayDoor(const SubwayItem subway_item) {
-  if (AP_IsSunwarpShuffle() && subway_item.sunwarp &&
-      subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
-    int sunwarp_index = subway_item.sunwarp->dots - 1;
-    if (subway_item.sunwarp->type == SubwaySunwarpType::kExit) {
-      sunwarp_index += 6;
-    }
-
-    for (const auto &[start_index, mapping] : AP_GetSunwarpMapping()) {
-      if (start_index == sunwarp_index || mapping.exit_index == sunwarp_index) {
-        return GD_GetSunwarpDoors().at(mapping.dots - 1);
-      }
-    }
+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};
   }
-
-  return subway_item.door;
 }
 
 }  // namespace
@@ -53,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())});
@@ -79,50 +65,72 @@ 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() {
   networks_.Clear();
 
   std::map<std::string, std::vector<int>> tagged;
+  std::map<std::string, std::vector<int>> entrances;
+  std::map<std::string, std::vector<int>> exits;
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     if (AP_HasEarlyColorHallways() &&
-        subway_item.special == "starting_room_paintings") {
-      tagged["early_ch"].push_back(subway_item.id);
+        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;
     }
 
     for (const std::string &tag : subway_item.tags) {
       tagged[tag].push_back(subway_item.id);
     }
+    for (const std::string &tag : subway_item.entrances) {
+      entrances[tag].push_back(subway_item.id);
+    }
+    for (const std::string &tag : subway_item.exits) {
+      exits[tag].push_back(subway_item.id);
+    }
 
-    if (!AP_IsSunwarpShuffle() && subway_item.sunwarp &&
-        subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
+    if (!AP_IsSunwarpShuffle() && subway_item.sunwarp) {
       std::string tag = fmt::format("sunwarp{}", subway_item.sunwarp->dots);
-      tagged[tag].push_back(subway_item.id);
+      switch (subway_item.sunwarp->type) {
+        case SubwaySunwarpType::kEnter:
+          entrances[tag].push_back(subway_item.id);
+          break;
+        case SubwaySunwarpType::kExit:
+          exits[tag].push_back(subway_item.id);
+          break;
+        default:
+          break;
+      }
     }
 
-    if (!AP_IsPilgrimageEnabled() &&
-        (subway_item.special == "sun_painting" ||
-         subway_item.special == "sun_painting_exit")) {
-      tagged["sun_painting"].push_back(subway_item.id);
+    if (!AP_IsPilgrimageEnabled()) {
+      if (subway_item.special == "sun_painting") {
+        entrances["sun_painting"].push_back(subway_item.id);
+      } else if (subway_item.special == "sun_painting_exit") {
+        exits["sun_painting"].push_back(subway_item.id);
+      }
     }
   }
 
   if (AP_IsSunwarpShuffle()) {
+    sunwarp_mapping_ = AP_GetSunwarpMapping();
+
     SubwaySunwarp final_sunwarp{.dots = 6, .type = SubwaySunwarpType::kFinal};
     int final_sunwarp_item = GD_GetSubwayItemForSunwarp(final_sunwarp);
 
-    for (const auto &[index, mapping] : AP_GetSunwarpMapping()) {
+    for (const auto &[index, mapping] : sunwarp_mapping_) {
       std::string tag = fmt::format("sunwarp{}", mapping.dots);
 
       SubwaySunwarp fromWarp;
@@ -143,13 +151,14 @@ void SubwayMap::OnConnect() {
         toWarp.type = SubwaySunwarpType::kExit;
       }
 
-      tagged[tag].push_back(GD_GetSubwayItemForSunwarp(fromWarp));
-      tagged[tag].push_back(GD_GetSubwayItemForSunwarp(toWarp));
-      
+      entrances[tag].push_back(GD_GetSubwayItemForSunwarp(fromWarp));
+      exits[tag].push_back(GD_GetSubwayItemForSunwarp(toWarp));
+
       networks_.AddLinkToNetwork(
           final_sunwarp_item, GD_GetSubwayItemForSunwarp(fromWarp),
           mapping.dots == 6 ? final_sunwarp_item
-                            : GD_GetSubwayItemForSunwarp(toWarp));
+                            : GD_GetSubwayItemForSunwarp(toWarp),
+          false);
     }
   }
 
@@ -159,40 +168,61 @@ void SubwayMap::OnConnect() {
          tag_it1++) {
       for (auto tag_it2 = std::next(tag_it1); tag_it2 != items.end();
            tag_it2++) {
-        networks_.AddLink(*tag_it1, *tag_it2);
+        // two links because tags are bi-directional
+        networks_.AddLink(*tag_it1, *tag_it2, true);
+      }
+    }
+  }
+
+  for (const auto &[tag, items] : entrances) {
+    if (!exits.contains(tag)) continue;
+    for (auto exit : exits[tag]) {
+      for (auto entrance : items) {
+        networks_.AddLink(entrance, exit, false);
       }
     }
   }
 
   checked_paintings_.clear();
+
+  UpdateIndicators();
 }
 
 void SubwayMap::UpdateIndicators() {
+  if (AP_IsSunwarpShuffle()) {
+    sunwarp_mapping_ = AP_GetSunwarpMapping();
+  }
+
   if (AP_IsPaintingShuffle()) {
-    for (const std::string &painting_id : AP_GetCheckedPaintings()) {
+    std::map<std::string, std::string> painting_mapping =
+        AP_GetPaintingMapping();
+    std::set<std::string> remote_checked_paintings = AP_GetCheckedPaintings();
+
+    for (const std::string &painting_id : remote_checked_paintings) {
       if (!checked_paintings_.count(painting_id)) {
         checked_paintings_.insert(painting_id);
 
-        if (AP_GetPaintingMapping().count(painting_id)) {
+        if (painting_mapping.count(painting_id)) {
           std::optional<int> from_id = GD_GetSubwayItemForPainting(painting_id);
-          std::optional<int> to_id = GD_GetSubwayItemForPainting(
-              AP_GetPaintingMapping().at(painting_id));
+          std::optional<int> to_id = GD_GetSubwayItemForPainting(painting_mapping.at(painting_id));
 
           if (from_id && to_id) {
-            networks_.AddLink(*from_id, *to_id);
+            networks_.AddLink(*from_id, *to_id, false);
           }
         }
       }
     }
   }
 
+  report_popup_->UpdateIndicators();
+
   Redraw();
 }
 
 void SubwayMap::UpdateSunwarp(SubwaySunwarp from_sunwarp,
                               SubwaySunwarp to_sunwarp) {
   networks_.AddLink(GD_GetSubwayItemForSunwarp(from_sunwarp),
-                    GD_GetSubwayItemForSunwarp(to_sunwarp));
+                    GD_GetSubwayItemForSunwarp(to_sunwarp), false);
 }
 
 void SubwayMap::Zoom(bool in) {
@@ -239,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);
@@ -294,79 +327,15 @@ 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);
 
-      for (const auto &[item_id1, item_id2] :
-           networks_.GetNetworkGraph(*hovered_item_)) {
-        const SubwayItem &item1 = GD_GetSubwayItem(item_id1);
-        const SubwayItem &item2 = GD_GetSubwayItem(item_id2);
+      for (const auto node : networks_.GetNetworkGraph(*hovered_item_)) {
+        const SubwayItem &item1 = GD_GetSubwayItem(node.entry);
+        const SubwayItem &item2 = GD_GetSubwayItem(node.exit);
 
-        wxPoint item1_pos = MapPosToRenderPos(
-            {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);
@@ -381,6 +350,12 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
           dc.DrawLine(item1_pos, item2_pos);
           dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
           dc.DrawLine(item1_pos, item2_pos);
+          if (!node.two_way) {
+            dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 2));
+            dc.SetBrush(*wxCYAN_BRUSH);
+            dc.DrawCircle(item2_pos, 4);
+            dc.SetBrush(*wxTRANSPARENT_BRUSH);
+          }
         } else {
           int ellipse_x;
           int ellipse_y;
@@ -423,6 +398,12 @@ void SubwayMap::OnPaint(wxPaintEvent &event) {
           dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
           dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2,
                              halfheight * 2, start, end);
+          if (!node.two_way) {
+            dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 2));
+            dc.SetBrush(*wxCYAN_BRUSH);
+            dc.DrawCircle(item2_pos, 4);
+            dc.SetBrush(*wxTRANSPARENT_BRUSH);
+          }
         }
       }
     }
@@ -443,9 +424,7 @@ void SubwayMap::OnMouseMove(wxMouseEvent &event) {
   }
 
   if (!sticky_hover_ && actual_hover_ != hovered_item_) {
-    hovered_item_ = actual_hover_;
-
-    Refresh();
+    EvaluateHover();
   }
 
   if (scroll_mode_) {
@@ -487,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_;
       }
@@ -543,11 +520,13 @@ void SubwayMap::OnClickHelp(wxCommandEvent &event) {
       "corner.\nClick on a side of the screen to start panning. It will follow "
       "your mouse. Click again to stop.\nHover over a door to see the "
       "requirements to open it.\nHover over a warp or active painting to see "
-      "what it is connected to.\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.",
+      "what it is connected to.\nFor one-way connections, there will be a "
+      "circle at the exit.\nCircles represent paintings.\nA red circle means "
+      "that the painting is locked by a door.\nA blue circle means painting "
+      "shuffle is enabled and the painting has not been checked yet.\nA black "
+      "circle means the painting is not a warp.\nA green circle means that the "
+      "painting is a warp.\nPainting exits will be indicated with an X.\nClick "
+      "on a door or warp to make the popup stick until you click again.",
       "Subway Map Help");
 }
 
@@ -559,23 +538,37 @@ void SubwayMap::Redraw() {
 
   wxGCDC gcdc(dc);
 
+  std::map<std::string, std::string> painting_mapping = AP_GetPaintingMapping();
+
   for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
     ItemDrawType draw_type = ItemDrawType::kNone;
     const wxBrush *brush_color = wxGREY_BRUSH;
-    std::optional<wxColour> shade_color;
     std::optional<int> subway_door = GetRealSubwayDoor(subway_item);
 
     if (AP_HasEarlyColorHallways() &&
-        subway_item.special == "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;
         }
       }
@@ -589,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 (AP_GetPaintingMapping().count(painting_id)) {
-              has_mapped_painting = true;
-            } else if (AP_IsPaintingMappedTo(painting_id)) {
-              has_codomain_painting = true;
-            }
-          } else {
-            has_unchecked_painting = true;
-          }
+    } else if (subway_item.painting) {
+      if (subway_door && !IsDoorOpen(*subway_door)) {
+        draw_type = ItemDrawType::kOwl;
+        brush_color = wxRED_BRUSH;
+      } else if (AP_IsPaintingShuffle()) {
+        if (!checked_paintings_.count(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwl;
+          brush_color = wxBLUE_BRUSH;
+        } else if (painting_mapping.count(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwl;
+          brush_color = wxGREEN_BRUSH;
+        } else if (AP_IsPaintingMappedTo(*subway_item.painting)) {
+          draw_type = ItemDrawType::kOwlExit;
+          brush_color = wxGREEN_BRUSH;
         }
-
-        if (has_unchecked_painting || has_mapped_painting ||
-            has_codomain_painting) {
+      } else if (subway_item.HasWarps()) {
+        brush_color = wxGREEN_BRUSH;
+        if (!subway_item.exits.empty()) {
+          draw_type = ItemDrawType::kOwlExit;
+        } else {
           draw_type = ItemDrawType::kOwl;
-
-          if (has_checked_painting) {
-            if (has_mapped_painting) {
-              shade_color = wxColour(0, 255, 0, 128);
-            } else {
-              shade_color = wxColour(255, 0, 0, 128);
-            }
-          }
         }
-      } else if (!subway_item.tags.empty()) {
-        draw_type = ItemDrawType::kOwl;
       }
     } else if (subway_door) {
       draw_type = ItemDrawType::kBox;
@@ -643,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,
@@ -693,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() +
@@ -762,8 +806,33 @@ void SubwayMap::SetZoom(double zoom, wxPoint static_point) {
   zoom_slider_->SetValue((zoom - 1.0) / 0.25);
 }
 
+std::optional<int> SubwayMap::GetRealSubwayDoor(const SubwayItem subway_item) {
+  if (AP_IsSunwarpShuffle() && subway_item.sunwarp &&
+      subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
+    int sunwarp_index = subway_item.sunwarp->dots - 1;
+    if (subway_item.sunwarp->type == SubwaySunwarpType::kExit) {
+      sunwarp_index += 6;
+    }
+
+    for (const auto &[start_index, mapping] : sunwarp_mapping_) {
+      if (start_index == sunwarp_index || mapping.exit_index == sunwarp_index) {
+        return GD_GetSunwarpDoors().at(mapping.dots - 1);
+      }
+    }
+  }
+
+  return subway_item.door;
+}
+
 quadtree::Box<float> SubwayMap::GetItemBox::operator()(const int &id) const {
   const SubwayItem &subway_item = GD_GetSubwayItem(id);
-  return {static_cast<float>(subway_item.x), static_cast<float>(subway_item.y),
-          AREA_ACTUAL_SIZE, AREA_ACTUAL_SIZE};
+  if (subway_item.painting) {
+    return {static_cast<float>(subway_item.x) - PAINTING_RADIUS,
+            static_cast<float>(subway_item.y) - PAINTING_RADIUS,
+            PAINTING_RADIUS * 2, PAINTING_RADIUS * 2};
+  } else {
+    return {static_cast<float>(subway_item.x),
+            static_cast<float>(subway_item.y), AREA_ACTUAL_SIZE,
+            AREA_ACTUAL_SIZE};
+  }
 }
@@ -15,9 +15,12 @@
 
 #include <quadtree/Quadtree.h>
 
+#include "ap_state.h"
 #include "game_data.h"
 #include "network_set.h"
 
+class ReportPopup;
+
 class SubwayMap : public wxPanel {
  public:
   SubwayMap(wxWindow *parent);
@@ -45,15 +48,16 @@ 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);
   void SetZoom(double zoom, wxPoint static_point);
 
+  std::optional<int> GetRealSubwayDoor(const SubwayItem subway_item);
+
   wxImage map_image_;
   wxImage owl_image_;
-  wxBitmap unchecked_eye_;
-  wxBitmap checked_eye_;
 
   wxBitmap rendered_;
   int render_x_ = 0;
@@ -85,8 +89,13 @@ class SubwayMap : public wxPanel {
   std::optional<int> actual_hover_;
   bool sticky_hover_ = false;
 
+  ReportPopup *report_popup_;
+
   NetworkSet networks_;
   std::set<std::string> checked_paintings_;
+
+  // Cached from APState.
+  std::map<int, SunwarpMapping> sunwarp_mapping_;
 };
 
 #endif /* end of include guard: SUBWAY_MAP_H_BD2D843E */
@@ -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"]) {
@@ -27,6 +29,11 @@ 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.
   }
@@ -40,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) {
@@ -52,6 +58,10 @@ void TrackerConfig::Save() {
     output["connection_history"].push_back(connection);
   }
 
+  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,12 +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_;
@@ -1,37 +1,64 @@
 #include "tracker_frame.h"
 
+#include <fmt/core.h>
 #include <wx/aboutdlg.h>
 #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 <fmt/core.h>
+#include <algorithm>
 #include <nlohmann/json.hpp>
 #include <sstream>
 
 #include "achievements_pane.h"
 #include "ap_state.h"
 #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"
 #include "tracker_panel.h"
 #include "version.h"
 
+namespace {
+
+std::string GetStatusMessage() {
+  std::string msg = AP_GetStatusMessage();
+
+  std::optional<std::string> ipc_msg = IPC_GetStatusMessage();
+  if (ipc_msg) {
+    msg += " ";
+    msg += *ipc_msg;
+  }
+
+  return msg;
+}
+
+}  // namespace
+
 enum TrackerFrameIds {
-  ID_CONNECT = 1,
+  ID_AP_CONNECT = 1,
   ID_CHECK_FOR_UPDATES = 2,
   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(CONNECT_TO_AP, ApConnectEvent);
 
 TrackerFrame::TrackerFrame()
     : wxFrame(nullptr, wxID_ANY, "Lingo Archipelago Tracker", wxDefaultPosition,
@@ -39,16 +66,24 @@ TrackerFrame::TrackerFrame()
   ::wxInitAllImageHandlers();
 
   AP_SetTrackerFrame(this);
+  IPC_SetTrackerFrame(this);
+
+  SetTheIconCache(&icons_);
+
+  updater_ = std::make_unique<Updater>(this);
+  updater_->Cleanup();
 
   wxMenu *menuFile = new wxMenu();
-  menuFile->Append(ID_CONNECT, "&Connect");
-  menuFile->Append(ID_OPEN_SAVE_FILE, "&Open Save Data\tCtrl-O");
+  menuFile->Append(ID_AP_CONNECT, "&Connect to Archipelago");
+  menuFile->Append(ID_IPC_CONNECT, "&Connect to Lingo");
   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);
@@ -65,38 +100,53 @@ TrackerFrame::TrackerFrame()
   SetMenuBar(menuBar);
 
   CreateStatusBar();
-  SetStatusText("Not connected to Archipelago.");
 
   Bind(wxEVT_MENU, &TrackerFrame::OnAbout, this, wxID_ABOUT);
   Bind(wxEVT_MENU, &TrackerFrame::OnExit, this, wxID_EXIT);
-  Bind(wxEVT_MENU, &TrackerFrame::OnConnect, this, ID_CONNECT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnApConnect, this, ID_AP_CONNECT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnIpcConnect, this, ID_IPC_CONNECT);
   Bind(wxEVT_MENU, &TrackerFrame::OnSettings, this, ID_SETTINGS);
   Bind(wxEVT_MENU, &TrackerFrame::OnCheckForUpdates, this,
        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(CONNECT_TO_AP, &TrackerFrame::OnConnectToAp, this);
+
+  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);
 
-  wxChoicebook *choicebook = new wxChoicebook(this, 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;
@@ -113,23 +163,28 @@ TrackerFrame::TrackerFrame()
   }
 
   if (GetTrackerConfig().should_check_for_updates) {
-    CheckForUpdates(/*manual=*/false);
+    updater_->CheckForUpdates(/*invisible=*/true);
   }
+
+  SetStatusText(GetStatusMessage());
 }
 
-void TrackerFrame::SetStatusMessage(std::string message) {
-  wxCommandEvent *event = new wxCommandEvent(STATUS_CHANGED);
-  event->SetString(message.c_str());
+void TrackerFrame::ConnectToAp(std::string server, std::string user,
+                               std::string pass) {
+  QueueEvent(new ApConnectEvent(CONNECT_TO_AP, GetId(), std::move(server),
+                                std::move(user), std::move(pass)));
+}
 
-  QueueEvent(event);
+void TrackerFrame::UpdateStatusMessage() {
+  QueueEvent(new wxCommandEvent(STATUS_CHANGED));
 }
 
 void TrackerFrame::ResetIndicators() {
   QueueEvent(new wxCommandEvent(STATE_RESET));
 }
 
-void TrackerFrame::UpdateIndicators() {
-  QueueEvent(new wxCommandEvent(STATE_CHANGED));
+void TrackerFrame::UpdateIndicators(StateUpdate state) {
+  QueueEvent(new StateChangedEvent(STATE_CHANGED, GetId(), std::move(state)));
 }
 
 void TrackerFrame::OnAbout(wxCommandEvent &event) {
@@ -137,6 +192,7 @@ void TrackerFrame::OnAbout(wxCommandEvent &event) {
   about_info.SetName("Lingo Archipelago Tracker");
   about_info.SetVersion(kTrackerVersion.ToString());
   about_info.AddDeveloper("hatkirby");
+  about_info.AddDeveloper("art0007i");
   about_info.AddArtist("Brenton Wildes");
   about_info.AddArtist("kinrah");
 
@@ -145,7 +201,7 @@ void TrackerFrame::OnAbout(wxCommandEvent &event) {
 
 void TrackerFrame::OnExit(wxCommandEvent &event) { Close(true); }
 
-void TrackerFrame::OnConnect(wxCommandEvent &event) {
+void TrackerFrame::OnApConnect(wxCommandEvent &event) {
   ConnectionDialog dlg;
 
   if (dlg.ShowModal() == wxID_OK) {
@@ -175,6 +231,17 @@ void TrackerFrame::OnConnect(wxCommandEvent &event) {
   }
 }
 
+void TrackerFrame::OnIpcConnect(wxCommandEvent &event) {
+  IpcDialog dlg;
+
+  if (dlg.ShowModal() == wxID_OK) {
+    GetTrackerConfig().ipc_address = dlg.GetIpcAddress();
+    GetTrackerConfig().Save();
+
+    IPC_Connect(dlg.GetIpcAddress());
+  }
+}
+
 void TrackerFrame::OnSettings(wxCommandEvent &event) {
   SettingsDialog dlg;
 
@@ -182,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) {
@@ -199,112 +269,99 @@ void TrackerFrame::OnZoomIn(wxCommandEvent &event) {
   }
 }
 
-void TrackerFrame::OnZoomOut(wxCommandEvent& event) {
+void TrackerFrame::OnZoomOut(wxCommandEvent &event) {
   if (notebook_->GetSelection() == 1) {
     subway_map_->Zoom(false);
   }
 }
 
-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::OnStateReset(wxCommandEvent& event) {
-  tracker_panel_->UpdateIndicators();
-  achievements_pane_->UpdateIndicators();
-  subway_map_->OnConnect();
-  if (panels_panel_ != nullptr) {
-    notebook_->DeletePage(notebook_->FindPage(panels_panel_));
-    panels_panel_ = nullptr;
-  }
-  Refresh();
+void TrackerFrame::OnSashPositionChanged(wxSplitterEvent& event) {
+  notebook_->Refresh();
 }
 
-void TrackerFrame::OnStateChanged(wxCommandEvent &event) {
-  tracker_panel_->UpdateIndicators();
+void TrackerFrame::OnStateReset(wxCommandEvent &event) {
+  tracker_panel_->UpdateIndicators(/*reset=*/true);
   achievements_pane_->UpdateIndicators();
-  subway_map_->UpdateIndicators();
-  if (panels_panel_ != nullptr) {
-    panels_panel_->UpdateIndicators();
-  }
+  items_pane_->ResetIndicators();
+  options_pane_->OnConnect();
+  paintings_pane_->ResetIndicators();
+  subway_map_->OnConnect();
   Refresh();
 }
 
-void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
-  SetStatusText(event.GetString());
-}
+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();
+    Refresh();
+  } else if (state.player_position && GetTrackerConfig().track_position) {
+    if (notebook_->GetSelection() == 0) {
+      tracker_panel_->Refresh();
+    }
+  }
 
-void TrackerFrame::CheckForUpdates(bool manual) {
-  wxWebRequest request = wxWebSession::GetDefault().CreateRequest(
-      this, "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION");
+  if (std::any_of(state.panels.begin(), state.panels.end(),
+                  [](int solve_index) {
+                    return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index))
+                        .achievement;
+                  })) {
+    achievements_pane_->UpdateIndicators();
+  }
 
-  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,50 +7,121 @@
 #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:
+  ApConnectEvent(wxEventType eventType, int winid, std::string server,
+                 std::string user, std::string pass)
+      : wxEvent(winid, eventType),
+        ap_server_(std::move(server)),
+        ap_user_(std::move(user)),
+        ap_pass_(std::move(pass)) {}
+
+  const std::string &GetServer() const { return ap_server_; }
+
+  const std::string &GetUser() const { return ap_user_; }
+
+  const std::string &GetPass() const { return ap_pass_; }
+
+  virtual wxEvent *Clone() const { return new ApConnectEvent(*this); }
+
+ private:
+  std::string ap_server_;
+  std::string ap_user_;
+  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(CONNECT_TO_AP, ApConnectEvent);
 
 class TrackerFrame : public wxFrame {
  public:
   TrackerFrame();
 
-  void SetStatusMessage(std::string message);
+  void ConnectToAp(std::string server, std::string user, std::string pass);
+  void UpdateStatusMessage();
 
   void ResetIndicators();
-  void UpdateIndicators();
+  void UpdateIndicators(StateUpdate state);
 
  private:
   void OnExit(wxCommandEvent &event);
   void OnAbout(wxCommandEvent &event);
-  void OnConnect(wxCommandEvent &event);
+  void OnApConnect(wxCommandEvent &event);
+  void OnIpcConnect(wxCommandEvent &event);
   void OnSettings(wxCommandEvent &event);
   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 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,7 @@
 #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"
 
@@ -43,67 +43,74 @@ 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() {
-  for (AreaIndicator &area : areas_) {
-    area.popup->UpdateIndicators();
-  }
-
-  Redraw();
-}
-
-void TrackerPanel::SetSavedataPath(std::string savedata_path) {
-  if (!panels_mode_) {
-    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();
   }
 
   wxBufferedPaintDC dc(this);
   dc.DrawBitmap(rendered_, 0, 0);
 
-  if (AP_GetPlayerPosition().has_value()) {
+  std::optional<std::tuple<int, int>> player_position;
+  if (GetTrackerConfig().track_position)
+  {
+    if (IPC_IsConnected()) {
+      player_position = IPC_GetPlayerPosition();
+    } else {
+      player_position = AP_GetPlayerPosition();
+    }
+  }
+
+  if (player_position.has_value()) {
     // 1588, 1194
     // 14x14 -> 154x154
     double intended_x =
-        1588.0 + (std::get<0>(*AP_GetPlayerPosition()) * (154.0 / 14.0));
+        1588.0 + (std::get<0>(*player_position) * (154.0 / 14.0));
     double intended_y =
-        1194.0 + (std::get<1>(*AP_GetPlayerPosition()) * (154.0 / 14.0));
+        1194.0 + (std::get<1>(*player_position) * (154.0 / 14.0));
 
-    int real_x = offset_x_ + scale_x_ * intended_x - scaled_player_.GetWidth() / 2;
-    int real_y = offset_y_ + scale_y_ * intended_y - scaled_player_.GetHeight() / 2;
+    int real_x =
+        offset_x_ + scale_x_ * intended_x - scaled_player_.GetWidth() / 2;
+    int real_y =
+        offset_y_ + scale_y_ * intended_y - scaled_player_.GetHeight() / 2;
 
     dc.DrawBitmap(scaled_player_, real_x, real_y);
   }
@@ -125,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;
@@ -149,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));
 
@@ -164,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;
@@ -199,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 = !solved_panels_.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) {
@@ -223,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)) {
@@ -237,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) {
@@ -254,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;
@@ -269,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});
-    }
-
-    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();
+                       {real_area_size_, real_area_size_});
     }
-    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,15 +17,7 @@ class TrackerPanel : public wxPanel {
  public:
   TrackerPanel(wxWindow *parent);
 
-  void UpdateIndicators();
-
-  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 {
@@ -40,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_;
 
@@ -55,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 {
@@ -19,11 +20,13 @@ namespace {
 struct Requirements {
   bool disabled = false;
 
-  std::set<int> doors;      // non-grouped, handles progressive
-  std::set<int> items;      // all other items
-  std::set<int> rooms;      // maybe
-  bool mastery = false;     // maybe
-  bool panel_hunt = false;  // maybe
+  std::set<int> doors;       // non-grouped, handles progressive
+  std::set<int> panel_doors; // non-grouped, handles progressive
+  std::set<int> items;       // all other items
+  std::set<int> rooms;       // maybe
+  bool mastery = false;      // maybe
+  bool panel_hunt = false;   // maybe
+  bool postgame = false;
 
   void Merge(const Requirements& rhs) {
     if (rhs.disabled) {
@@ -33,6 +36,9 @@ struct Requirements {
     for (int id : rhs.doors) {
       doors.insert(id);
     }
+    for (int id : rhs.panel_doors) {
+      panel_doors.insert(id);
+    }
     for (int id : rhs.items) {
       items.insert(id);
     }
@@ -41,6 +47,7 @@ struct Requirements {
     }
     mastery = mastery || rhs.mastery;
     panel_hunt = panel_hunt || rhs.panel_hunt;
+    postgame = postgame || rhs.postgame;
   }
 };
 
@@ -78,15 +85,12 @@ class RequirementCalculator {
             requirements.doors.insert(door_obj.id);
             break;
         }
-      } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
-        requirements.rooms.insert(door_obj.room);
-
+      } else if (AP_GetDoorShuffleMode() != kDOORS_MODE || door_obj.skip_item) {
         for (int panel_id : door_obj.panels) {
           const Requirements& panel_reqs = GetPanel(panel_id);
           requirements.Merge(panel_reqs);
         }
-      } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
-                 !door_obj.group_name.empty()) {
+      } else if (AP_AreDoorsGrouped() && !door_obj.group_name.empty()) {
         requirements.items.insert(door_obj.group_ap_item_id);
       } else {
         requirements.doors.insert(door_obj.id);
@@ -133,6 +137,21 @@ class RequirementCalculator {
           requirements.items.insert(GD_GetItemIdForColor(color));
         }
       }
+      
+      if (panel_obj.panel_door != -1 &&
+          AP_GetDoorShuffleMode() == kPANELS_MODE) {
+        const PanelDoor& panel_door_obj = GD_GetPanelDoor(panel_obj.panel_door);
+
+        if (panel_door_obj.group_ap_item_id != -1 && AP_AreDoorsGrouped()) {
+          requirements.items.insert(panel_door_obj.group_ap_item_id);
+        } else {
+          requirements.panel_doors.insert(panel_obj.panel_door);
+        }
+      }
+
+      if (panel_obj.location_name == GetWinCondition()) {
+        requirements.postgame = true;
+      }
 
       panels_[panel_id] = requirements;
     }
@@ -148,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 };
@@ -167,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;
 };
 
@@ -177,7 +207,21 @@ 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();
+    sunwarp_mapping_ = AP_GetSunwarpMapping();
+
     std::list<int> panel_boundary;
     std::list<int> painting_boundary;
     std::list<Exit> flood_boundary;
@@ -217,12 +261,13 @@ class StateCalculator {
           reachable_changed = true;
 
           PaintingExit cur_painting = GD_GetPaintingExit(painting_id);
-          if (AP_GetPaintingMapping().count(cur_painting.internal_id) &&
-              AP_GetCheckedPaintings().count(cur_painting.internal_id)) {
+          if (painting_mapping_.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(
-                    AP_GetPaintingMapping().at(cur_painting.internal_id)));
+                    painting_mapping_.at(cur_painting.internal_id)));
             painting_exit.source_room = cur_painting.room;
             painting_exit.destination_room = target_painting.room;
             painting_exit.type = EntranceType::kPainting;
@@ -281,8 +326,8 @@ class StateCalculator {
 
           if (AP_IsSunwarpShuffle()) {
             for (int index : room_obj.sunwarps) {
-              if (AP_GetSunwarpMapping().count(index)) {
-                const SunwarpMapping& sm = AP_GetSunwarpMapping().at(index);
+              if (sunwarp_mapping_.count(index)) {
+                const SunwarpMapping& sm = sunwarp_mapping_.at(index);
 
                 new_boundary.push_back(
                     {.source_room = room_exit.destination_room,
@@ -296,15 +341,14 @@ class StateCalculator {
           if (AP_HasEarlyColorHallways() && room_obj.name == "Starting Room") {
             new_boundary.push_back(
                 {.source_room = room_exit.destination_room,
-                 .destination_room = GD_GetRoomByName("Outside The Undeterred"),
+                 .destination_room = GD_GetRoomByName("Color Hallways"),
                  .type = EntranceType::kPainting});
           }
 
           if (AP_IsPilgrimageEnabled()) {
             int pilgrimage_start_id = GD_GetRoomByName("Hub Room");
             if (AP_IsSunwarpShuffle()) {
-              for (const auto& [start_index, mapping] :
-                   AP_GetSunwarpMapping()) {
+              for (const auto& [start_index, mapping] : sunwarp_mapping_) {
                 if (mapping.dots == 1) {
                   pilgrimage_start_id = GD_GetRoomForSunwarp(start_index);
                 }
@@ -343,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]);
     }
   }
 
@@ -378,7 +426,8 @@ class StateCalculator {
   }
 
  private:
-  Decision IsNonGroupedDoorReachable(const Door& door_obj) {
+  template <typename T>
+  Decision IsNonGroupedDoorReachable(const T& door_obj) {
     bool has_item = AP_HasItem(door_obj.ap_item_id);
 
     if (!has_item) {
@@ -399,29 +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 item_id : reqs.items) {
-      bool has_item = AP_HasItem(item_id);
-      if (report) {
-        (*report)[AP_GetItemName(item_id)] = has_item;
+      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)[panel_door_obj.item_name] = (decision == kYes);
+        }
+
+        if (decision != kYes) {
+          final_decision = decision;
+        }
       }
 
-      if (!has_item) {
-        final_decision = kNo;
+      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;
+        }
       }
     }
 
@@ -490,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) {
@@ -549,7 +610,7 @@ class StateCalculator {
       if (AP_IsSunwarpShuffle()) {
         pilgrimage_pairs = std::vector<std::tuple<int, int>>(5);
 
-        for (const auto& [start_index, mapping] : AP_GetSunwarpMapping()) {
+        for (const auto& [start_index, mapping] : sunwarp_mapping_) {
           if (mapping.dots > 1) {
             std::get<1>(pilgrimage_pairs[mapping.dots - 2]) = start_index;
           }
@@ -620,23 +681,94 @@ class StateCalculator {
   bool pilgrimage_doable_ = false;
 
   std::map<int, std::list<int>> paths_;
+
+  std::map<std::string, std::string> painting_mapping_;
+  std::set<std::string> checked_paintings_;
+  std::map<int, SunwarpMapping> sunwarp_mapping_;
 };
 
 }  // 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()) {
@@ -667,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();
@@ -705,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 */
@@ -0,0 +1,5 @@
+#include "version.h"
+
+std::ostream& operator<<(std::ostream& out, const Version& ver) {
+  return out << "v" << ver.major << "." << ver.minor << "." << ver.revision;
+}
@@ -36,6 +36,6 @@ struct Version {
   }
 };
 
-constexpr const Version kTrackerVersion = Version(0, 11, 1);
+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