27 files changed, 3150 insertions, 241 deletions

@@ -22,6 +22,7 @@ include_directories(
   ${yaml-cpp_INCLUDE_DIRS}
   ${OpenSSL_INCLUDE_DIRS}
   vendor/whereami
+  vendor
 )
 
 find_path(SYSTEM_INCLUDE_DIR zlib.h)
@@ -39,10 +40,11 @@ add_executable(lingo_ap_tracker
   "src/connection_dialog.cpp"
   "src/tracker_state.cpp"
   "src/tracker_config.cpp"
-  "src/logger.cpp"
   "src/achievements_pane.cpp"
   "src/settings_dialog.cpp"
   "src/global.cpp"
+  "src/subway_map.cpp"
+  "src/network_set.cpp"
   "vendor/whereami/whereami.c"
 )
 set_property(TARGET lingo_ap_tracker PROPERTY CXX_STANDARD 20)
@@ -67,6 +67,8 @@
     map: [2642, 872]

   Eight Room:

     fold_into: The Incomparable

+  Eight Alcove:

+    fold_into: The Incomparable

   Orange Tower First Floor:

     map: [1285, 928]

   Color Hunt:

@@ -83,8 +85,10 @@
     map: [1252, 1259]

   Orange Tower Seventh Floor:

     map: [1587, 1900]

-  Orange Tower Basement:

+  Orange Tower Sixth Floor:

     map: [1587, 2000]

+  Orange Tower Basement:

+    map: [1587, 2100]

   Courtyard:

     map: [863, 387]

   First Second Third Fourth:

@@ -224,11 +228,15 @@
   The Eyes They See:

     map: [955, 933]

   Far Window:

-   fold_into: The Eyes They See

+    fold_into: The Eyes They See

+  Wondrous Lobby:

+    fold_into: The Eyes They See

   Outside The Wondrous:

     map: [691, 524]

   The Wondrous:

     map: [648, 338]

+  The Wondrous (Doorknob):

+    fold_into: The Wondrous

   The Wondrous (Bookcase):

     fold_into: The Wondrous

   The Wondrous (Chandelier):

@@ -0,0 +1,1041 @@
+---
+- pos: [1050, 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]
+  room: Hedge Maze
+  door: Painting Shortcut
+  paintings:
+    - garden_painting_tower2
+  tags:
+    - garden_starting
+- pos: [1066, 841]
+  room: Courtyard
+  door: Painting Shortcut
+  paintings:
+    - flower_painting_8
+  tags:
+    - flower_starting
+- pos: [905, 895]
+  room: The Wondrous (Doorknob)
+  door: Painting Shortcut
+  paintings:
+    - symmetry_painting_a_starter
+  tags:
+    - symmetry_starting
+- pos: [1066, 868]
+  room: Outside The Bold
+  door: Painting Shortcut
+  paintings:
+    - pencil_painting6
+  tags:
+    - pencil_starting
+- pos: [1066, 895]
+  room: Outside The Undeterred
+  door: Painting Shortcut
+  paintings:
+    - blueman_painting_3
+  tags:
+    - blueman_starting
+- pos: [905, 868]
+  room: Outside The Agreeable
+  door: Painting Shortcut
+  paintings:
+    - eyes_yellow_painting2
+  tags:
+    - street_starting
+- pos: [1211, 879]
+  room: Hidden Room
+  door: Dead End Door
+- pos: [1291, 906]
+  room: Hidden Room
+  door: Knight Night Entrance
+- pos: [1103, 980]
+  room: Hidden Room
+  door: Seeker Entrance
+- pos: [1173, 980]
+  room: Hidden Room
+  door: Rhyme Room Entrance
+- pos: [1116, 939]
+  paintings:
+    - owl_painting
+  tags:
+    - owl_hidden
+- pos: [986, 793]
+  room: Second Room
+  door: Exit Door
+- pos: [798, 584]
+  room: Hub Room
+  door: Crossroads Entrance
+- pos: [932, 665]
+  room: Hub Room
+  door: Tenacious Entrance
+- pos: [1361, 578]
+  room: Hub Room
+  door: Shortcut to Hedge Maze
+- pos: [1312, 841]
+  room: Hub Room
+  door: Near RAT Door
+- pos: [1371, 729]
+  room: Hub Room
+  door: Traveled Entrance
+- pos: [1313, 686]
+  paintings:
+    - maze_painting
+  tags:
+    - green_owl
+    - green_numbers
+- pos: [1172, 760]
+  sunwarp:
+    dots: 1
+    type: enter
+- pos: [1302, 638]
+  room: Outside The Undeterred
+  door: Fours
+- pos: [1243, 819]
+  room: Outside The Undeterred
+  door: Fours
+- pos: [1276, 819]
+  room: Outside The Undeterred
+  door: Eights
+- pos: [1263, 867]
+  paintings:
+    - smile_painting_6
+  tags:
+    - smiley_deadend
+- pos: [1012, 1086]
+  sunwarp:
+    dots: 6
+    type: final
+- pos: [938, 1002]
+  room: Pilgrim Antechamber
+  door: Sun Painting
+  special: sun_painting
+- pos: [1053, 1090]
+  invisible: true
+  special: sun_painting_exit
+- pos: [1077, 1061]
+  room: Pilgrim Room
+  door: Shortcut to The Seeker
+- pos: [713, 359]
+  room: Number Hunt
+  door: Eights
+- pos: [932, 348]
+  room: Crossroads
+  door: Hollow Hallway
+- pos: [798, 290]
+  room: Crossroads
+  door: Tower Entrance
+- pos: [932, 477]
+  room: Crossroads
+  door: Tenacious Entrance
+- pos: [638, 477]
+  room: Crossroads
+  door: Discerning Entrance
+- pos: [905, 290]
+  room: Crossroads
+  door: Tower Back Entrance
+- pos: [894, 423]
+  room: Crossroads
+  door: Words Sword Door
+- pos: [632, 643]
+  room: Crossroads
+  door: Eye Wall
+- pos: [638, 520]
+  room: Crossroads
+  door: Roof Access
+- pos: [756, 400]
+  paintings:
+    - smile_painting_4
+  tags:
+    - smiley_crossroads
+- pos: [878, 509]
+  sunwarp:
+    dots: 1
+    type: exit
+- pos: [1056, 344]
+  room: Lost Area
+  door: Exit
+- pos: [954, 290]
+  room: Lost Area
+  door: Exit
+- pos: [986, 290]
+  room: Number Hunt
+  door: Eights
+- pos: [954, 247]
+  room: Amen Name Area
+  door: Exit
+- pos: [954, 222]
+  paintings:
+    - west_afar
+- pos: [986, 697]
+  room: The Tenacious
+  door: Shortcut to Hub Room
+- pos: [1173, 665]
+  room: Near Far Area
+  door: Door
+- pos: [1173, 622]
+  room: Warts Straw Area
+  door: Door
+- pos: [1173, 579]
+  room: Leaf Feel Area
+  door: Door
+- pos: [1173, 333]
+  room: Outside The Agreeable
+  door: Purple Barrier
+- pos: [1088, 289]
+  room: Outside The Undeterred
+  door: Fives
+- pos: [1088, 418]
+  room: Outside The Undeterred
+  door: Fives
+- pos: [1039, 477]
+  room: Outside The Agreeable
+  door: Tenacious Entrance
+- pos: [1147, 525]
+  room: Outside The Agreeable
+  door: Black Door
+- pos: [1216, 525]
+  room: Outside The Agreeable
+  door: Agreeable Entrance
+- pos: [1138, 287]
+  paintings:
+    - eyes_yellow_painting
+  tags:
+    - street_starting
+- pos: [1088, 385]
+  sunwarp:
+    dots: 6
+    type: enter
+- pos: [1195, 450]
+  room: Compass Room
+  door: Lookout Entrance
+- pos: [1214, 457]
+  paintings:
+    - pencil_painting7
+  tags:
+    - pencil_compass
+- pos: [1196, 417]
+  invisible: true
+  tags:
+    - agreeable_to_lookout
+- pos: [1657, 1392]
+  room: Room Room
+  door: Excavation
+- pos: [1725, 1441]
+  invisible: true
+  tags:
+    - agreeable_to_lookout
+- pos: [1040, 665]
+  room: Dread Hallway
+  door: Tenacious Entrance
+- pos: [1324, 525]
+  room: The Agreeable
+  door: Shortcut to Hedge Maze
+- pos: [1484, 392]
+  room: Hedge Maze
+  door: Perceptive Entrance
+- pos: [1441, 241]
+  room: Hedge Maze
+  door: Observant Entrance
+- pos: [1714, 434]
+  room: Hedge Maze
+  door: Observant Entrance
+- pos: [1477, 343]
+  paintings:
+    - garden_painting_tower
+  tags:
+    - garden_starting
+- pos: [1565, 311]
+  room: The Fearless (First Floor)
+  door: Second Floor
+- pos: [1597, 279]
+  room: The Fearless (Second Floor)
+  door: Third Floor
+- pos: [1414, 209]
+  room: The Observant
+  door: Backside Door
+- pos: [1624, 188]
+  room: The Observant
+  door: Stairs
+- pos: [1667, 686]
+  room: The Incomparable
+  door: Eight Door
+- pos: [1784, 569]
+  paintings:
+    - crown_painting
+  tags:
+    - crown_tower6
+- pos: [1653, 717]
+  paintings:
+    - eight_painting2
+  tags:
+    - eight_alcove
+- pos: [1653, 662]
+  paintings:
+    - eight_painting
+  tags:
+    - eight_alcove
+- pos: [697, 1471]
+  room: Orange Tower
+  door: Second Floor
+- pos: [633, 1406]
+  room: Orange Tower
+  door: Third Floor
+- pos: [570, 1343]
+  room: Orange Tower
+  door: Fourth Floor
+- pos: [504, 1279]
+  room: Orange Tower
+  door: Fifth Floor
+- pos: [440, 1215]
+  room: Orange Tower
+  door: Sixth Floor
+- pos: [379, 1153]
+  room: Orange Tower
+  door: Seventh Floor
+- pos: [905, 793]
+  room: Orange Tower First Floor
+  door: Shortcut to Hub Room
+- pos: [686, 820]
+  room: Orange Tower First Floor
+  door: Salt Pepper Door
+- pos: [755, 787]
+  sunwarp:
+    dots: 4
+    type: enter
+- pos: [719, 846]
+  tags:
+    - tower1_tower1
+- pos: [681, 1506]
+  tags:
+    - tower1_tower1
+- pos: [722, 1439]
+  tags:
+    - tower2_undeterred
+- pos: [533, 1375]
+  tags:
+    - tower3_tower3
+- pos: [662, 1375]
+  tags:
+    - tower3_gallery
+- pos: [483, 1307]
+  tags:
+    - tower4_room
+- pos: [598, 1307]
+  tags:
+    - tower4_tower4
+- pos: [598, 1287]
+  tags:
+    - tower4_courtyard
+- pos: [533, 1245]
+  tags:
+    - tower5_welcome
+- pos: [419, 1245]
+  tags:
+    - tower5_cellar
+- pos: [419, 1267]
+  tags:
+    - tower5_quadruple
+- pos: [203, 1014]
+  tags:
+    - tower2_undeterred
+- pos: [1325, 1191]
+  tags:
+    - tower3_tower3
+- pos: [1700, 1021]
+  tags:
+    - tower3_gallery
+- pos: [1653, 1318]
+  tags:
+    - tower4_room
+- pos: [918, 222]
+  tags:
+    - tower4_tower4
+- pos: [806, 222]
+  tags:
+    - tower4_courtyard
+- pos: [652, 951]
+  tags:
+    - tower5_welcome
+- pos: [1553, 1440]
+  tags:
+    - tower5_cellar
+- pos: [1459, 1119]
+  tags:
+    - tower5_quadruple
+- pos: [1216, 1280]
+  room: Orange Tower Third Floor
+  door: Red Barrier
+- pos: [1173, 1248]
+  room: Orange Tower Third Floor
+  door: Rhyme Room Entrance
+- pos: [1270, 1231]
+  paintings:
+    - arrows_painting_6
+    - flower_painting_5
+- pos: [1216, 1216]
+  sunwarp:
+    dots: 2
+    type: exit
+- pos: [1253, 1172]
+  sunwarp:
+    dots: 3
+    type: enter
+- pos: [852, 198]
+  room: Orange Tower Fourth Floor
+  door: Hot Crusts Door
+- pos: [830, 289]
+  sunwarp:
+    dots: 5
+    type: enter
+- pos: [877, 155]
+  room: Number Hunt
+  door: Eights
+- pos: [844, 134]
+  paintings:
+    - smile_painting_8
+  tags:
+    - smiley_hotcrusts
+- pos: [797, 155]
+  sunwarp:
+    dots: 2
+    type: enter
+- pos: [679, 985]
+  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
+    - panda_tower6
+    - crown_tower6
+    - apple_tower6
+    - hi_scientific
+- pos: [349, 1124]
+  paintings:
+    - map_painting2
+- pos: [436, 1159]
+  room: Orange Tower Seventh Floor
+  door: Mastery
+- pos: [544, 1159]
+  paintings:
+    - arrows_painting_11
+- pos: [498, 284]
+  room: Courtyard
+  door: Green Barrier
+- pos: [556, 233]
+  paintings:
+    - flower_painting_7
+  tags:
+    - flower_starting
+    - flower_arrow
+- pos: [600, 332]
+  room: Number Hunt
+  door: Nines
+- pos: [579, 350]
+  paintings:
+    - blueman_painting
+  tags:
+    - blueman_courtyard
+- pos: [530, 310]
+  room: First Second Third Fourth
+  door: Backside Door
+- pos: [584, 107]
+  room: The Colorful (White)
+  door: Progress Door
+- pos: [622, 107]
+  room: The Colorful (Black)
+  door: Progress Door
+- pos: [659, 107]
+  room: The Colorful (Red)
+  door: Progress Door
+- pos: [697, 107]
+  room: The Colorful (Yellow)
+  door: Progress Door
+- pos: [734, 107]
+  room: The Colorful (Blue)
+  door: Progress Door
+- pos: [772, 107]
+  room: The Colorful (Purple)
+  door: Progress Door
+- pos: [809, 107]
+  room: The Colorful (Orange)
+  door: Progress Door
+- pos: [847, 107]
+  room: The Colorful (Green)
+  door: Progress Door
+- pos: [884, 107]
+  room: The Colorful (Brown)
+  door: Progress Door
+- pos: [922, 107]
+  room: The Colorful (Gray)
+  door: Progress Door
+- pos: [967, 107]
+  paintings:
+    - arrows_painting_12
+- pos: [878, 954]
+  room: Welcome Back Area
+  door: Shortcut to Starting Room
+- pos: [773, 954]
+  tags:
+    - hub_wb
+    - wondrous_wb
+    - undeterred_wb
+    - agreeable_wb
+    - wanderer_wb
+    - observant_wb
+    - gallery_wb
+    - scientific_wb
+    - cellar_wb
+- pos: [1107, 749]
+  tags:
+    - hub_wb
+- pos: [408, 817]
+  tags:
+    - wondrous_wb
+- pos: [281, 1017]
+  tags:
+    - undeterred_wb
+- pos: [1017, 289]
+  tags:
+    - agreeable_wb
+- pos: [907, 1385]
+  tags:
+    - wanderer_wb
+- pos: [1737, 1053]
+  tags:
+    - gallery_wb
+- pos: [1690, 268]
+  tags:
+    - observant_wb
+- pos: [250, 604]
+  tags:
+    - scientific_wb
+- pos: [1553, 1467]
+  tags:
+    - 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:
+    - green_owl
+    - owl_hidden
+    - owl_tower6
+- pos: [1478, 938]
+  room: Number Hunt
+  door: Sevens
+- pos: [1580, 853]
+  room: Number Hunt
+  door: Sevens
+- pos: [1478, 905]
+  room: Number Hunt
+  door: Eights
+- pos: [1452, 841]
+  room: Number Hunt
+  door: Nines
+- pos: [1420, 841]
+  room: Outside The Initiated
+  door: Blue Barrier
+- pos: [1479, 1018]
+  room: Outside The Initiated
+  door: Orange Barrier
+- pos: [1360, 847]
+  room: Outside The Initiated
+  door: Shortcut to Hub Room
+- pos: [1511, 841]
+  room: Outside The Initiated
+  door: Initiated Entrance
+- pos: [1141, 1441]
+  room: Orange Tower Third Floor
+  door: Orange Barrier
+- pos: [1173, 1441]
+  room: Outside The Initiated
+  door: Green Barrier
+- pos: [1206, 1441]
+  room: Outside The Initiated
+  door: Purple Barrier
+- pos: [1189, 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:
+    - clock_initiated
+- pos: [1546, 938]
+  paintings:
+    - clock_painting_2
+    - arrows_painting_2
+  tags:
+    - clock_tower6
+    - clock_initiated
+- pos: [1579, 813]
+  sunwarp:
+    dots: 3
+    type: exit
+- pos: [1444, 896]
+  paintings:
+    - smile_painting_1
+  tags:
+    - smiley_initiated
+- pos: [1430, 691]
+  room: Outside The Undeterred
+  door: Fours
+- pos: [1468, 728]
+  room: The Traveled
+  door: Color Hallways Entrance
+- pos: [1533, 707]
+  tags:
+    - red_ch
+    - blue_ch
+    - yellow_ch
+    - green_ch
+- pos: [1567, 1264]
+  tags:
+    - red_ch
+- pos: [150, 808]
+  tags:
+    - blue_ch
+- pos: [626, 371]
+  tags:
+    - yellow_ch
+- pos: [1368, 241]
+  tags:
+    - green_ch
+- pos: [1543, 1307]
+  room: Number Hunt
+  door: Sixes
+- pos: [1543, 1388]
+  room: Number Hunt
+  door: Nines
+- pos: [1468, 1377]
+  room: Outside The Bold
+  door: Bold Entrance
+- pos: [1425, 1358]
+  paintings:
+    - pencil_painting2
+    - north_missing2
+  tags:
+    - pencil_compass
+    - pencil_starting
+    - pencil_directional
+- pos: [1334, 1419]
+  room: Outside The Bold
+  door: Steady Entrance
+- pos: [445, 1048]
+  tags:
+    - undeterred_artistic
+- pos: [279, 1071]
+  room: Number Hunt
+  door: Zero Door
+- pos: [338, 1071]
+  room: Outside The Undeterred
+  door: Twos
+- pos: [370, 1071]
+  room: Outside The Undeterred
+  door: Threes
+- pos: [402, 1071]
+  room: Outside The Undeterred
+  door: Fours
+- pos: [242, 1071]
+  room: Outside The Undeterred
+  door: Undeterred Entrance
+- pos: [60, 1017]
+  paintings:
+    - blueman_painting_2
+  tags:
+    - blueman_courtyard
+    - blueman_starting
+- pos: [60, 970]
+  special: early_color_hallways
+- pos: [402, 1012]
+  room: Outside The Undeterred
+  door: Green Painting
+  paintings:
+    - maze_painting_3
+  tags:
+    - green_numbers
+- pos: [134, 1007]
+  sunwarp:
+    dots: 4
+    type: exit
+- pos: [719, 1039]
+  room: Outside The Undeterred
+  door: Challenge Entrance
+- pos: [438, 1039]
+  room: Outside The Undeterred
+  door: Number Hunt
+- pos: [563, 1071]
+  room: Outside The Undeterred
+  door: Fives
+- pos: [596, 1071]
+  room: Number Hunt
+  door: Sixes
+- pos: [627, 1071]
+  room: Number Hunt
+  door: Sevens
+- pos: [659, 1071]
+  room: Number Hunt
+  door: Eights
+- pos: [692, 1071]
+  room: Number Hunt
+  door: Nines
+- pos: [525, 1002]
+  room: Number Hunt
+  door: Door to Directional Gallery
+- pos: [659, 1014]
+  room: Number Hunt
+  door: Eights
+  paintings:
+    - smile_painting_5
+  tags:
+    - smiley_numbers
+- pos: [557, 953]
+  room: Number Hunt
+  door: Sevens
+- pos: [391, 932]
+  room: Number Hunt
+  door: Sixes
+- pos: [311, 932]
+  room: Number Hunt
+  door: Nines
+- pos: [268, 868]
+  room: Number Hunt
+  door: Eights
+- pos: [268, 825]
+  room: Directional Gallery
+  door: Yellow Barrier
+- pos: [231, 681]
+  room: Number Hunt
+  door: Sixes
+- pos: [242, 980]
+  room: Directional Gallery
+  door: Shortcut to The Undeterred
+- pos: [351, 927]
+  paintings:
+    - boxes_painting
+  tags:
+    - lattice_directional
+- pos: [272, 927]
+  paintings:
+    - smile_painting_7
+  tags:
+    - smiley_directional
+- pos: [214, 822]
+  paintings:
+    - cherry_painting
+  tags:
+    - apple_directional
+- pos: [266, 735]
+  room: Number Hunt
+  door: Sixes
+  paintings:
+    - pencil_painting3
+  tags:
+    - pencil_directional
+- pos: [215, 735]
+  paintings:
+    - 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]
+  room: Outside The Initiated
+  door: Entrance
+  paintings:
+    - fruitbowl_painting3
+- pos: [1290, 1323]
+  sunwarp:
+    dots: 5
+    type: exit
+- pos: [1189, 1356]
+  room: Outside The Initiated
+  door: Entrance
+- pos: [1154, 1332]
+  paintings:
+    - colors_painting
+- pos: [1640, 1260]
+  room: The Bearer
+  door: Backside Door
+- pos: [1468, 1287]
+  room: The Bearer
+  door: Entrance
+- pos: [1430, 1232]
+  room: Number Hunt
+  door: Sixes
+- pos: [1388, 1152]
+  room: Bearer Side Area
+  door: Shortcut to Tower
+- pos: [1273, 1142]
+  paintings:
+    - pencil_painting5
+    - pencil_painting4
+- pos: [1355, 1092]
+  room: Knight Night (Final)
+  door: Exit
+- pos: [1382, 900]
+  room: Knight Night (Final)
+  door: Exit
+- pos: [1388, 1002]
+  # 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:
+    - smiley_crossroads
+    - smiley_deadend
+    - smiley_hotcrusts
+    - smiley_numbers
+    - smiley_directional
+    - smiley_initiated
+    - smiley_gallery
+    - smiley_theysee
+- pos: [1656, 139]
+  room: The Artistic (Smiley)
+  door: Door to Panda
+- pos: [1711, 140]
+  tags:
+    - undeterred_artistic
+- pos: [1653, 169]
+  paintings:
+    - panda_painting_3
+  tags:
+    - panda_tower6
+    - panda_hallway
+- pos: [1708, 171]
+  room: The Artistic (Panda)
+  door: Door to Lattice
+- pos: [1761, 169]
+  paintings:
+    - boxes_painting2
+  tags:
+    - lattice_directional
+- pos: [1762, 139]
+  room: The Artistic (Lattice)
+  door: Door to Apple
+- pos: [1761, 101]
+  paintings:
+    - cherry_painting3
+  tags:
+    - apple_tower6
+    - apple_directional
+- pos: [1708, 107]
+  room: The Artistic (Apple)
+  door: Door to Smiley
+- pos: [370, 681]
+  room: Number Hunt
+  door: Eights
+- pos: [411, 685]
+  paintings:
+    - eye_painting_2
+    - smile_painting_2
+  tags:
+    - smiley_theysee
+- pos: [310, 750]
+  room: The Eyes They See
+  door: Exit
+- pos: [334, 798]
+  paintings:
+    - arrows_painting_5
+- pos: [370, 792]
+  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:
+    - symmetry_starting
+- pos: [407, 755]
+  room: The Wondrous
+  door: Exit
+  paintings:
+    - arrows_painting_9
+- pos: [449, 755]
+  paintings:
+    - flower_painting_6
+  tags:
+    - flower_arrow
+- pos: [1101, 222]
+  paintings:
+    - panda_painting
+  tags:
+    - panda_hallway
+- pos: [1152, 209]
+  room: Hallway Room (1)
+  door: Exit
+- pos: [1189, 170]
+  room: Hallway Room (2)
+  door: Exit
+- pos: [1238, 124]
+  room: Hallway Room (3)
+  door: Exit
+- pos: [1313, 108]
+  room: Hallway Room (4)
+  door: Exit
+- pos: [1528, 108]
+  room: Hallway Room (4)
+  door: Exit
+- pos: [1415, 140]
+  room: Number Hunt
+  door: Nines
+- pos: [1458, 133]
+  paintings:
+    - south_afar
+- pos: [826, 1452]
+  room: Outside The Wanderer
+  door: Wanderer Entrance
+- pos: [763, 1465]
+  room: Outside The Wanderer
+  door: Tower Entrance
+- pos: [1655, 1151]
+  room: Number Hunt
+  door: Eights
+- pos: [1623, 1044]
+  room: Art Gallery
+  door: Second Floor
+- pos: [1623, 1019]
+  room: Art Gallery
+  door: Third Floor
+- pos: [1623, 991]
+  room: Art Gallery
+  door: Fourth Floor
+- pos: [1623, 964]
+  room: Art Gallery
+  door: Fifth Floor
+- 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:
+    - smiley_gallery
+- pos: [1120, 1286]
+  room: Rhyme Room (Smiley)
+  door: Door to Target
+- pos: [1120, 1315]
+  tags:
+    - rhyme_smiley_target
+- pos: [792, 1137]
+  tags:
+    - rhyme_smiley_target
+- pos: [895, 1217]
+  room: Number Hunt
+  door: Nines
+- pos: [938, 1296]
+  room: Rhyme Room (Cross)
+  door: Exit
+- pos: [1120, 1195]
+  room: Rhyme Room (Circle)
+  door: Door to Smiley
+- pos: [1118, 1137]
+  paintings:
+    - arrows_painting_3
+- pos: [1050, 1142]
+  room: Rhyme Room (Looped Square)
+  door: Door to Circle
+- pos: [987, 1194]
+  room: Rhyme Room (Looped Square)
+  door: Door to Cross
+- pos: [922, 1142]
+  room: Rhyme Room (Looped Square)
+  door: Door to Target
+- pos: [852, 1200]
+  room: Rhyme Room (Target)
+  door: Door to Cross
+- pos: [850, 1138]
+  paintings:
+    - arrows_painting_4
+- pos: [1652, 1393]
+  room: Room Room
+  door: Excavation
+- pos: [1592, 1442]
+  room: Room Room
+  door: Cellar Exit
+- pos: [1570, 938]
+  room: Outside The Wise
+  door: Wise Entrance
+- pos: [1653, 935]
+  paintings:
+    - clock_painting_3
+- pos: [369, 605]
+  room: Outside The Scientific
+  door: Scientific Entrance
+- pos: [294, 602]
+  paintings:
+    - hi_solved_painting4
+  tags:
+    - hi_scientific
+- pos: [814, 1001]
+  room: Challenge Room
+  door: Welcome Door
@@ -21,7 +21,6 @@
 #include <tuple>
 
 #include "game_data.h"
-#include "logger.h"
 #include "tracker_frame.h"
 #include "tracker_state.h"
 
@@ -71,11 +70,12 @@ struct APState {
   bool sunwarp_shuffle = false;
 
   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) {
     if (!initialized) {
-      TrackerLog("Initializing APState...");
+      wxLogVerbose("Initializing APState...");
 
       std::thread([this]() {
         for (;;) {
@@ -103,15 +103,16 @@ struct APState {
       }
 
       tracked_data_storage_keys.push_back("PlayerPos");
+      tracked_data_storage_keys.push_back("Paintings");
 
       initialized = true;
     }
 
     tracker_frame->SetStatusMessage("Connecting to Archipelago server....");
-    TrackerLog("Connecting to Archipelago server (" + server + ")...");
+    wxLogStatus("Connecting to Archipelago server (%s)...", server);
 
     {
-      TrackerLog("Destroying old AP client...");
+      wxLogVerbose("Destroying old AP client...");
 
       std::lock_guard client_guard(client_mutex);
 
@@ -137,6 +138,7 @@ struct APState {
     color_shuffle = false;
     painting_shuffle = false;
     painting_mapping.clear();
+    painting_codomain.clear();
     mastery_requirement = 21;
     level_2_requirement = 223;
     location_checks = kNORMAL_LOCATIONS;
@@ -155,10 +157,10 @@ struct APState {
     apclient->set_room_info_handler([this, player, password]() {
       inventory.clear();
 
-      TrackerLog("Connected to Archipelago server. Authenticating as " +
-                 player +
-                 (password.empty() ? " without password"
-                                   : " with password " + password));
+      wxLogStatus("Connected to Archipelago server. Authenticating as %s %s",
+                  player,
+                  (password.empty() ? "without password"
+                                    : "with password " + password));
       tracker_frame->SetStatusMessage(
           "Connected to Archipelago server. Authenticating...");
 
@@ -170,23 +172,23 @@ struct APState {
         [this](const std::list<int64_t>& locations) {
           for (const int64_t location_id : locations) {
             checked_locations.insert(location_id);
-            TrackerLog("Location: " + std::to_string(location_id));
+            wxLogVerbose("Location: %lld", location_id);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_slot_disconnected_handler([this]() {
       tracker_frame->SetStatusMessage(
           "Disconnected from Archipelago. Attempting to reconnect...");
-      TrackerLog(
+      wxLogStatus(
           "Slot disconnected from Archipelago. Attempting to reconnect...");
     });
 
     apclient->set_socket_disconnected_handler([this]() {
       tracker_frame->SetStatusMessage(
           "Disconnected from Archipelago. Attempting to reconnect...");
-      TrackerLog(
+      wxLogStatus(
           "Socket disconnected from Archipelago. Attempting to reconnect...");
     });
 
@@ -194,10 +196,10 @@ struct APState {
         [this](const std::list<APClient::NetworkItem>& items) {
           for (const APClient::NetworkItem& item : items) {
             inventory[item.item]++;
-            TrackerLog("Item: " + std::to_string(item.item));
+            wxLogVerbose("Item: %lld", item.item);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_retrieved_handler(
@@ -206,20 +208,20 @@ struct APState {
             HandleDataStorage(key, value);
           }
 
-          RefreshTracker();
+          RefreshTracker(false);
         });
 
     apclient->set_set_reply_handler([this](const std::string& key,
                                            const nlohmann::json& value,
                                            const nlohmann::json&) {
       HandleDataStorage(key, value);
-      RefreshTracker();
+      RefreshTracker(false);
     });
 
     apclient->set_slot_connected_handler([this](
                                              const nlohmann::json& slot_data) {
       tracker_frame->SetStatusMessage("Connected to Archipelago!");
-      TrackerLog("Connected to Archipelago!");
+      wxLogStatus("Connected to Archipelago!");
 
       data_storage_prefix =
           "Lingo_" + std::to_string(apclient->get_player_number()) + "_";
@@ -253,6 +255,7 @@ struct APState {
         for (const auto& mapping_it :
              slot_data["painting_entrance_to_exit"].items()) {
           painting_mapping[mapping_it.key()] = mapping_it.value();
+          painting_codomain.insert(mapping_it.value());
         }
       }
 
@@ -271,7 +274,8 @@ struct APState {
       connected = true;
       has_connection_result = true;
 
-      RefreshTracker();
+      ResetReachabilityRequirements();
+      RefreshTracker(true);
 
       std::list<std::string> corrected_keys;
       for (const std::string& key : tracked_data_storage_keys) {
@@ -323,7 +327,7 @@ struct APState {
           }
 
           std::string full_message = hatkirby::implode(error_messages, " ");
-          TrackerLog(full_message);
+          wxLogError(wxString(full_message));
 
           wxMessageBox(full_message, "Connection failed", wxOK | wxICON_ERROR);
         });
@@ -341,8 +345,7 @@ struct APState {
         DestroyClient();
 
         tracker_frame->SetStatusMessage("Disconnected from Archipelago.");
-
-        TrackerLog("Timeout while connecting to Archipelago server.");
+        wxLogStatus("Timeout while connecting to Archipelago server.");
         wxMessageBox("Timeout while connecting to Archipelago server.",
                      "Connection failed", wxOK | wxICON_ERROR);
       }
@@ -353,7 +356,7 @@ struct APState {
     }
 
     if (connected) {
-      RefreshTracker();
+      RefreshTracker(false);
     } else {
       client_active = false;
     }
@@ -362,12 +365,11 @@ struct APState {
   void HandleDataStorage(const std::string& key, const nlohmann::json& value) {
     if (value.is_boolean()) {
       data_storage[key] = value.get<bool>();
-      TrackerLog("Data storage " + key + " retrieved as " +
-                 (value.get<bool>() ? "true" : "false"));
+      wxLogVerbose("Data storage %s retrieved as %s", key,
+                   (value.get<bool>() ? "true" : "false"));
     } else if (value.is_number()) {
       data_storage[key] = value.get<int>();
-      TrackerLog("Data storage " + key + " retrieved as " +
-                 std::to_string(value.get<int>()));
+      wxLogVerbose("Data storage %s retrieved as %d", key, value.get<int>());
     } else if (value.is_object()) {
       if (key.ends_with("PlayerPos")) {
         auto map_value = value.get<std::map<std::string, int>>();
@@ -376,7 +378,7 @@ struct APState {
         data_storage[key] = value.get<std::map<std::string, int>>();
       }
 
-      TrackerLog("Data storage " + key + " retrieved as dictionary");
+      wxLogVerbose("Data storage %s retrieved as dictionary", key);
     } else if (value.is_null()) {
       if (key.ends_with("PlayerPos")) {
         player_pos = std::nullopt;
@@ -384,7 +386,19 @@ struct APState {
         data_storage.erase(key);
       }
 
-      TrackerLog("Data storage " + key + " retrieved as null");
+      wxLogVerbose("Data storage %s retrieved as null", key);
+    } else if (value.is_array()) {
+      auto list_value = value.get<std::vector<std::string>>();
+
+      if (key.ends_with("Paintings")) {
+        data_storage[key] =
+            std::set<std::string>(list_value.begin(), list_value.end());
+      } else {
+        data_storage[key] = list_value;
+      }
+
+      wxLogVerbose("Data storage %s retrieved as list: [%s]", key,
+                   hatkirby::implode(list_value, ", "));
     }
   }
 
@@ -407,22 +421,46 @@ struct APState {
     return data_storage.count(key) && std::any_cast<bool>(data_storage.at(key));
   }
 
-  void RefreshTracker() {
-    TrackerLog("Refreshing display...");
+  const std::set<std::string>& GetCheckedPaintings() {
+    std::string key = data_storage_prefix + "Paintings";
+    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();
+
+    return checked_paintings.count(painting_id) ||
+           (painting_mapping.count(painting_id) &&
+            checked_paintings.count(painting_mapping.at(painting_id)));
+  }
+
+  void RefreshTracker(bool reset) {
+    wxLogVerbose("Refreshing display...");
 
     RecalculateReachability();
-    tracker_frame->UpdateIndicators();
+
+    if (reset) {
+      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("Could not find AP item ID for " + item_name);
+      wxLogError("Could not find AP item ID for %s", item_name);
     }
 
     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)) ==
@@ -461,16 +499,32 @@ bool AP_HasItem(int item_id, int quantity) {
   return GetState().HasItem(item_id, quantity);
 }
 
+std::string AP_GetItemName(int item_id) {
+  return GetState().GetItemName(item_id);
+}
+
 DoorShuffleMode AP_GetDoorShuffleMode() { return GetState().door_shuffle_mode; }
 
 bool AP_IsColorShuffle() { return GetState().color_shuffle; }
 
 bool AP_IsPaintingShuffle() { return GetState().painting_shuffle; }
 
-const std::map<std::string, std::string> AP_GetPaintingMapping() {
+const std::map<std::string, std::string>& AP_GetPaintingMapping() {
   return GetState().painting_mapping;
 }
 
+bool AP_IsPaintingMappedTo(const std::string& painting_id) {
+  return GetState().painting_codomain.count(painting_id);
+}
+
+const std::set<std::string>& AP_GetCheckedPaintings() {
+  return GetState().GetCheckedPaintings();
+}
+
+bool AP_IsPaintingChecked(const std::string& painting_id) {
+  return GetState().IsPaintingChecked(painting_id);
+}
+
 int AP_GetMasteryRequirement() { return GetState().mastery_requirement; }
 
 int AP_GetLevel2Requirement() { return GetState().level_2_requirement; }
@@ -3,6 +3,7 @@
 
 #include <map>
 #include <optional>
+#include <set>
 #include <string>
 #include <tuple>
 
@@ -48,13 +49,21 @@ bool AP_HasCheckedHuntPanel(int location_id);
 
 bool AP_HasItem(int item_id, int quantity = 1);
 
+std::string AP_GetItemName(int item_id);
+
 DoorShuffleMode AP_GetDoorShuffleMode();
 
 bool AP_IsColorShuffle();
 
 bool AP_IsPaintingShuffle();
 
-const std::map<std::string, std::string> AP_GetPaintingMapping();
+const std::map<std::string, std::string>& AP_GetPaintingMapping();
+
+bool AP_IsPaintingMappedTo(const std::string& painting_id);
+
+const std::set<std::string>& AP_GetCheckedPaintings();
+
+bool AP_IsPaintingChecked(const std::string& painting_id);
 
 int AP_GetMasteryRequirement();
 
@@ -1,5 +1,7 @@
 #include "area_popup.h"
 
+#include <wx/dcbuffer.h>
+
 #include "ap_state.h"
 #include "game_data.h"
 #include "global.h"
@@ -8,6 +10,8 @@
 
 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)
@@ -61,6 +65,19 @@ void AreaPopup::UpdateIndicators() {
     }
   }
 
+  if (AP_IsPaintingShuffle()) {
+    for (int painting_id : map_area.paintings) {
+      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;
+      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 = std::max(header_extent.GetWidth(), item_width) + 20;
 
@@ -105,10 +122,31 @@ void AreaPopup::UpdateIndicators() {
 
     cur_height += 10 + 32;
   }
+
+  if (AP_IsPaintingShuffle()) {
+    for (int painting_id : map_area.paintings) {
+      const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+      bool checked = AP_IsPaintingChecked(painting.internal_id);
+      wxBitmap* eye_ptr = checked ? &checked_eye_ : &unchecked_eye_;
+
+      mem_dc.DrawBitmap(*eye_ptr, {10, cur_height});
+
+      bool reachable = IsPaintingReachable(painting_id);
+      const wxColour* text_color = reachable ? wxWHITE : wxRED;
+      mem_dc.SetTextForeground(*text_color);
+
+      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});
+
+      cur_height += 10 + 32;
+    }
+  }
 }
 
 void AreaPopup::OnPaint(wxPaintEvent& event) {
-  wxPaintDC dc(this);
+  wxBufferedPaintDC dc(this);
   PrepareDC(dc);
   dc.DrawBitmap(rendered_, 0, 0);
 
@@ -1,5 +1,11 @@
 #include "game_data.h"
 
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
 #include <hkutil/string.h>
 #include <yaml-cpp/yaml.h>
 
@@ -7,7 +13,6 @@
 #include <sstream>
 
 #include "global.h"
-#include "logger.h"
 
 namespace {
 
@@ -31,9 +36,7 @@ LingoColor GetColorForString(const std::string &str) {
   } else if (str == "purple") {
     return LingoColor::kPurple;
   } else {
-    std::ostringstream errmsg;
-    errmsg << "Invalid color: " << str;
-    TrackerLog(errmsg.str());
+    wxLogError("Invalid color: %s", str);
 
     return LingoColor::kNone;
   }
@@ -44,11 +47,14 @@ struct GameData {
   std::vector<Door> doors_;
   std::vector<Panel> panels_;
   std::vector<MapArea> map_areas_;
+  std::vector<SubwayItem> subway_items_;
+  std::vector<PaintingExit> paintings_;
 
   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> area_by_id_;
+  std::map<std::string, int> painting_by_id_;
 
   std::vector<int> door_definition_order_;
 
@@ -61,6 +67,9 @@ struct GameData {
 
   std::vector<int> sunwarp_doors_;
 
+  std::map<std::string, int> subway_item_by_painting_;
+  std::map<SubwaySunwarp, int> subway_item_by_sunwarp_;
+
   bool loaded_area_data_ = false;
   std::set<std::string> malconfigured_areas_;
 
@@ -79,9 +88,7 @@ struct GameData {
         ap_id_by_color_[GetColorForString(input_name)] =
             ids_config["special_items"][color_name].as<int>();
       } else {
-        std::ostringstream errmsg;
-        errmsg << "Missing AP item ID for color " << color_name;
-        TrackerLog(errmsg.str());
+        wxLogError("Missing AP item ID for color %s", color_name);
       }
     };
 
@@ -156,8 +163,9 @@ struct GameData {
           }
           default: {
             // This shouldn't happen.
-            std::cout << "Error reading game data: " << entrance_it
-                      << std::endl;
+            std::ostringstream formatted;
+            formatted << entrance_it;
+            wxLogError("Error reading game data: %s", formatted.str());
             break;
           }
         }
@@ -282,10 +290,8 @@ struct GameData {
                           [panels_[panel_id].name]
                               .as<int>();
           } else {
-            std::ostringstream errmsg;
-            errmsg << "Missing AP location ID for panel "
-                   << rooms_[room_id].name << " - " << panels_[panel_id].name;
-            TrackerLog(errmsg.str());
+            wxLogError("Missing AP location ID for panel %s - %s",
+                       rooms_[room_id].name, panels_[panel_id].name);
           }
         }
       }
@@ -348,10 +354,8 @@ struct GameData {
                             [doors_[door_id].name]["item"]
                                 .as<int>();
             } else {
-              std::ostringstream errmsg;
-              errmsg << "Missing AP item ID for door " << rooms_[room_id].name
-                     << " - " << doors_[door_id].name;
-              TrackerLog(errmsg.str());
+              wxLogError("Missing AP item ID for door %s - %s",
+                         rooms_[room_id].name, doors_[door_id].name);
             }
           }
 
@@ -365,10 +369,8 @@ struct GameData {
                   ids_config["door_groups"][doors_[door_id].group_name]
                       .as<int>();
             } else {
-              std::ostringstream errmsg;
-              errmsg << "Missing AP item ID for door group "
-                     << doors_[door_id].group_name;
-              TrackerLog(errmsg.str());
+              wxLogError("Missing AP item ID for door group %s",
+                         doors_[door_id].group_name);
             }
           }
 
@@ -378,13 +380,11 @@ struct GameData {
           } else if (!door_it.second["skip_location"] &&
                      !door_it.second["event"]) {
             if (has_external_panels) {
-              std::ostringstream errmsg;
-              errmsg
-                  << rooms_[room_id].name << " - " << doors_[door_id].name
-                  << " has panels from other rooms but does not have an "
-                     "explicit "
-                     "location name and is not marked skip_location or event";
-              TrackerLog(errmsg.str());
+              wxLogError(
+                  "%s - %s has panels from other rooms but does not have an "
+                  "explicit location name and is not marked skip_location or "
+                  "event",
+                  rooms_[room_id].name, doors_[door_id].name);
             }
 
             doors_[door_id].location_name =
@@ -404,10 +404,8 @@ struct GameData {
                             [doors_[door_id].name]["location"]
                                 .as<int>();
             } else {
-              std::ostringstream errmsg;
-              errmsg << "Missing AP location ID for door "
-                     << rooms_[room_id].name << " - " << doors_[door_id].name;
-              TrackerLog(errmsg.str());
+              wxLogError("Missing AP location ID for door %s - %s",
+                         rooms_[room_id].name, doors_[door_id].name);
             }
           }
 
@@ -428,12 +426,13 @@ struct GameData {
 
       if (room_it.second["paintings"]) {
         for (const auto &painting : room_it.second["paintings"]) {
-          std::string painting_id = painting["id"].as<std::string>();
-          room_by_painting_[painting_id] = room_id;
+          std::string internal_id = painting["id"].as<std::string>();
 
-          if (!painting["exit_only"] || !painting["exit_only"].as<bool>()) {
-            PaintingExit painting_exit;
-            painting_exit.id = painting_id;
+          if ((!painting["exit_only"] || !painting["exit_only"].as<bool>()) &&
+              (!painting["disable"] || !painting["disable"].as<bool>())) {
+            int painting_id = AddOrGetPainting(internal_id);
+            PaintingExit &painting_exit = paintings_[painting_id];
+            painting_exit.room = room_id;
 
             if (painting["required_door"]) {
               std::string rd_room = rooms_[room_id].name;
@@ -445,7 +444,7 @@ struct GameData {
                   rd_room, painting["required_door"]["door"].as<std::string>());
             }
 
-            rooms_[room_id].paintings.push_back(painting_exit);
+            rooms_[room_id].paintings.push_back(painting_exit.id);
           }
         }
       }
@@ -473,10 +472,8 @@ struct GameData {
             progressive_item_id =
                 ids_config["progression"][progressive_item_name].as<int>();
           } else {
-            std::ostringstream errmsg;
-            errmsg << "Missing AP item ID for progressive item "
-                   << progressive_item_name;
-            TrackerLog(errmsg.str());
+            wxLogError("Missing AP item ID for progressive item %s",
+                       progressive_item_name);
           }
 
           int index = 1;
@@ -618,11 +615,98 @@ struct GameData {
       }
     }
 
+    for (const Room &room : rooms_) {
+      std::string area_name = room.name;
+      if (fold_areas.count(room.name)) {
+        int fold_area_id = fold_areas[room.name];
+        area_name = map_areas_[fold_area_id].name;
+      }
+
+      if (!room.paintings.empty()) {
+        int area_id = AddOrGetArea(area_name);
+        MapArea &map_area = map_areas_[area_id];
+
+        for (int painting_id : room.paintings) {
+          map_area.paintings.push_back(painting_id);
+        }
+      }
+    }
+
     // Report errors.
     for (const std::string &area : malconfigured_areas_) {
-      std::ostringstream errstr;
-      errstr << "Area data not found for: " << area;
-      TrackerLog(errstr.str());
+      wxLogError("Area data not found for: %s", area);
+    }
+
+    // Read in subway items.
+    YAML::Node subway_config =
+        YAML::LoadFile(GetAbsolutePath("assets/subway.yaml"));
+    for (const auto &subway_it : subway_config) {
+      SubwayItem subway_item;
+      subway_item.id = subway_items_.size();
+      subway_item.x = subway_it["pos"][0].as<int>();
+      subway_item.y = subway_it["pos"][1].as<int>();
+
+      if (subway_it["door"]) {
+        subway_item.door = AddOrGetDoor(subway_it["room"].as<std::string>(),
+                                        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["tags"]) {
+        for (const auto &tag_it : subway_it["tags"]) {
+          subway_item.tags.push_back(tag_it.as<std::string>());
+        }
+      }
+
+      if (subway_it["sunwarp"]) {
+        SubwaySunwarp sunwarp;
+        sunwarp.dots = subway_it["sunwarp"]["dots"].as<int>();
+
+        std::string sunwarp_type =
+            subway_it["sunwarp"]["type"].as<std::string>();
+        if (sunwarp_type == "final") {
+          sunwarp.type = SubwaySunwarpType::kFinal;
+        } else if (sunwarp_type == "exit") {
+          sunwarp.type = SubwaySunwarpType::kExit;
+        } else {
+          sunwarp.type = SubwaySunwarpType::kEnter;
+        }
+
+        subway_item.sunwarp = sunwarp;
+
+        subway_item_by_sunwarp_[sunwarp] = subway_item.id;
+
+        subway_item.door =
+            AddOrGetDoor("Sunwarps", std::to_string(sunwarp.dots) + " Sunwarp");
+      }
+
+      if (subway_it["special"]) {
+        subway_item.special = subway_it["special"].as<std::string>();
+      }
+
+      subway_items_.push_back(subway_item);
+    }
+
+    // Find singleton subway tags.
+    std::map<std::string, std::set<int>> subway_tags;
+    for (const SubwayItem &subway_item : subway_items_) {
+      for (const std::string &tag : subway_item.tags) {
+        subway_tags[tag].insert(subway_item.id);
+      }
+    }
+
+    for (const auto &[tag, items] : subway_tags) {
+      if (items.size() == 1) {
+        wxLogWarning("Singleton subway item tag: %s", tag);
+      }
     }
   }
 
@@ -639,8 +723,10 @@ struct GameData {
     std::string full_name = room + " - " + door;
 
     if (!door_by_id_.count(full_name)) {
+      int door_id = doors_.size();
       door_by_id_[full_name] = doors_.size();
-      doors_.push_back({.room = AddOrGetRoom(room), .name = door});
+      doors_.push_back(
+          {.id = door_id, .room = AddOrGetRoom(room), .name = door});
     }
 
     return door_by_id_[full_name];
@@ -672,6 +758,16 @@ struct GameData {
 
     return area_by_id_[area];
   }
+
+  int AddOrGetPainting(std::string internal_id) {
+    if (!painting_by_id_.count(internal_id)) {
+      int painting_id = paintings_.size();
+      painting_by_id_[internal_id] = painting_id;
+      paintings_.push_back({.id = painting_id, .internal_id = internal_id});
+    }
+
+    return painting_by_id_[internal_id];
+  }
 };
 
 GameData &GetState() {
@@ -681,6 +777,10 @@ GameData &GetState() {
 
 }  // namespace
 
+bool SubwaySunwarp::operator<(const SubwaySunwarp &rhs) const {
+  return std::tie(dots, type) < std::tie(rhs.dots, rhs.type);
+}
+
 const std::vector<MapArea> &GD_GetMapAreas() { return GetState().map_areas_; }
 
 const MapArea &GD_GetMapArea(int id) { return GetState().map_areas_.at(id); }
@@ -703,8 +803,12 @@ const Panel &GD_GetPanel(int panel_id) {
   return GetState().panels_.at(panel_id);
 }
 
-int GD_GetRoomForPainting(const std::string &painting_id) {
-  return GetState().room_by_painting_.at(painting_id);
+const PaintingExit &GD_GetPaintingExit(int painting_id) {
+  return GetState().paintings_.at(painting_id);
+}
+
+int GD_GetPaintingByName(const std::string &name) {
+  return GetState().painting_by_id_.at(name);
 }
 
 const std::vector<int> &GD_GetAchievementPanels() {
@@ -722,3 +826,24 @@ const std::vector<int> &GD_GetSunwarpDoors() {
 int GD_GetRoomForSunwarp(int index) {
   return GetState().room_by_sunwarp_.at(index);
 }
+
+const std::vector<SubwayItem> &GD_GetSubwayItems() {
+  return GetState().subway_items_;
+}
+
+const SubwayItem &GD_GetSubwayItem(int id) {
+  return GetState().subway_items_.at(id);
+}
+
+int GD_GetSubwayItemForPainting(const std::string &painting_id) {
+#ifndef NDEBUG
+  if (!GetState().subway_item_by_painting_.count(painting_id)) {
+    wxLogError("No subway item for painting %s", painting_id);
+  }
+#endif
+  return GetState().subway_item_by_painting_.at(painting_id);
+}
+
+int GD_GetSubwayItemForSunwarp(const SubwaySunwarp &sunwarp) {
+  return GetState().subway_item_by_sunwarp_.at(sunwarp);
+}
@@ -63,6 +63,7 @@ struct ProgressiveRequirement {
 };
 
 struct Door {
+  int id;
   int room;
   std::string name;
   std::string location_name;
@@ -87,14 +88,16 @@ struct Exit {
 };
 
 struct PaintingExit {
-  std::string id;
+  int id;
+  int room;
+  std::string internal_id;
   std::optional<int> door;
 };
 
 struct Room {
   std::string name;
   std::vector<Exit> exits;
-  std::vector<PaintingExit> paintings;
+  std::vector<int> paintings;
   std::vector<int> sunwarps;
   std::vector<int> panels;
 };
@@ -113,12 +116,37 @@ struct MapArea {
   int id;
   std::string name;
   std::vector<Location> locations;
+  std::vector<int> paintings;
   int map_x;
   int map_y;
   int classification = 0;
   bool hunt = false;
 };
 
+enum class SubwaySunwarpType {
+  kEnter,
+  kExit,
+  kFinal
+};
+
+struct SubwaySunwarp {
+  int dots;
+  SubwaySunwarpType type;
+
+  bool operator<(const SubwaySunwarp& rhs) const;
+};
+
+struct SubwayItem {
+  int id;
+  int x;
+  int y;
+  std::optional<int> door;
+  std::vector<std::string> paintings;
+  std::vector<std::string> tags;
+  std::optional<SubwaySunwarp> sunwarp;
+  std::optional<std::string> special;
+};
+
 const std::vector<MapArea>& GD_GetMapAreas();
 const MapArea& GD_GetMapArea(int id);
 int GD_GetRoomByName(const std::string& name);
@@ -127,10 +155,15 @@ 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_GetRoomForPainting(const std::string& painting_id);
+const PaintingExit& GD_GetPaintingExit(int painting_id);
+int GD_GetPaintingByName(const std::string& name);
 const std::vector<int>& GD_GetAchievementPanels();
 int GD_GetItemIdForColor(LingoColor color);
 const std::vector<int>& GD_GetSunwarpDoors();
 int GD_GetRoomForSunwarp(int index);
+const std::vector<SubwayItem>& GD_GetSubwayItems();
+const SubwayItem& GD_GetSubwayItem(int id);
+int GD_GetSubwayItemForPainting(const std::string& painting_id);
+int GD_GetSubwayItemForSunwarp(const SubwaySunwarp& sunwarp);
 
 #endif /* end of include guard: GAME_DATA_H_9C42AC51 */
@@ -1,32 +0,0 @@
-#include "logger.h"
-
-#include <chrono>
-#include <fstream>
-#include <mutex>
-
-#include "global.h"
-
-namespace {
-
-class Logger {
- public:
-  Logger() : logfile_(GetAbsolutePath("debug.log")) {}
-
-  void LogLine(const std::string& text) {
-    std::lock_guard guard(file_mutex_);
-    logfile_ << "[" << std::chrono::system_clock::now() << "] " << text
-             << std::endl;
-    logfile_.flush();
-  }
-
- private:
-  std::ofstream logfile_;
-  std::mutex file_mutex_;
-};
-
-}  // namespace
-
-void TrackerLog(const std::string& text) {
-  static Logger* instance = new Logger();
-  instance->LogLine(text);
-}
@@ -1,8 +0,0 @@
-#ifndef LOGGER_H_6E7B9594
-#define LOGGER_H_6E7B9594
-
-#include <string>
-
-void TrackerLog(const std::string& text);
-
-#endif /* end of include guard: LOGGER_H_6E7B9594 */
@@ -4,18 +4,41 @@
 #include <wx/wx.h>
 #endif
 
+#include <fstream>
+
+#include "global.h"
 #include "tracker_config.h"
 #include "tracker_frame.h"
 
+static std::ofstream* logfile;
+
 class TrackerApp : public wxApp {
  public:
   virtual bool OnInit() {
+    logfile = new std::ofstream(GetAbsolutePath("debug.log"));
+    wxLog::SetActiveTarget(new wxLogStream(logfile));
+
+#ifndef NDEBUG
+    wxLog::SetVerbose(true);
+    wxLog::SetActiveTarget(new wxLogWindow(nullptr, "Debug Log"));
+#endif
+
     GetTrackerConfig().Load();
 
     TrackerFrame *frame = new TrackerFrame();
     frame->Show(true);
     return true;
   }
+
+  bool OnExceptionInMainLoop() override {
+    try {
+      throw;
+    } catch (const std::exception& ex) {
+      wxLogError(ex.what());
+    }
+
+    return false;
+  }
 };
 
 wxIMPLEMENT_APP(TrackerApp);
@@ -0,0 +1,30 @@
+#include "network_set.h"
+
+void NetworkSet::Clear() {
+  network_by_item_.clear();
+}
+
+void NetworkSet::AddLink(int id1, int id2) {
+  if (id2 > id1) {
+    // Make sure id1 < id2
+    std::swap(id1, id2);
+  }
+
+  if (!network_by_item_.count(id1)) {
+    network_by_item_[id1] = {};
+  }
+  if (!network_by_item_.count(id2)) {
+    network_by_item_[id2] = {};
+  }
+
+  network_by_item_[id1].insert({id1, id2});
+  network_by_item_[id2].insert({id1, id2});
+}
+
+bool NetworkSet::IsItemInNetwork(int id) const {
+  return network_by_item_.count(id);
+}
+
+const std::set<std::pair<int, int>>& NetworkSet::GetNetworkGraph(int id) const {
+  return network_by_item_.at(id);
+}
@@ -0,0 +1,25 @@
+#ifndef NETWORK_SET_H_3036B8E3
+#define NETWORK_SET_H_3036B8E3
+
+#include <map>
+#include <optional>
+#include <set>
+#include <utility>
+#include <vector>
+
+class NetworkSet {
+ public:
+  void Clear();
+
+  void AddLink(int id1, int id2);
+
+  bool IsItemInNetwork(int id) const;
+
+  const std::set<std::pair<int, int>>& GetNetworkGraph(int id) const;
+
+ private:
+
+  std::map<int, std::set<std::pair<int, int>>> network_by_item_;
+};
+
+#endif /* end of include guard: NETWORK_SET_H_3036B8E3 */
@@ -0,0 +1,700 @@
+#include "subway_map.h"
+
+#include <wx/dcbuffer.h>
+#include <wx/dcgraph.h>
+
+#include <sstream>
+
+#include "ap_state.h"
+#include "game_data.h"
+#include "global.h"
+#include "tracker_state.h"
+
+constexpr int AREA_ACTUAL_SIZE = 21;
+constexpr int OWL_ACTUAL_SIZE = 32;
+
+enum class ItemDrawType { kNone, kBox, kOwl };
+
+SubwayMap::SubwayMap(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
+  map_image_ =
+      wxImage(GetAbsolutePath("assets/subway.png").c_str(), wxBITMAP_TYPE_PNG);
+  if (!map_image_.IsOk()) {
+    return;
+  }
+
+  owl_image_ =
+      wxImage(GetAbsolutePath("assets/owl.png").c_str(), wxBITMAP_TYPE_PNG);
+  if (!owl_image_.IsOk()) {
+    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())});
+  for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
+    tree_->add(subway_item.id);
+  }
+
+  Redraw();
+
+  scroll_timer_ = new wxTimer(this);
+
+  Bind(wxEVT_PAINT, &SubwayMap::OnPaint, this);
+  Bind(wxEVT_MOTION, &SubwayMap::OnMouseMove, this);
+  Bind(wxEVT_MOUSEWHEEL, &SubwayMap::OnMouseScroll, this);
+  Bind(wxEVT_LEAVE_WINDOW, &SubwayMap::OnMouseLeave, this);
+  Bind(wxEVT_LEFT_DOWN, &SubwayMap::OnMouseClick, this);
+  Bind(wxEVT_TIMER, &SubwayMap::OnTimer, this);
+
+  zoom_slider_ = new wxSlider(this, wxID_ANY, 0, 0, 8, {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();
+}
+
+void SubwayMap::OnConnect() {
+  networks_.Clear();
+
+  std::map<std::string, std::vector<int>> tagged;
+  for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
+    if (AP_HasEarlyColorHallways() &&
+        (subway_item.special == "starting_room_paintings" ||
+         subway_item.special == "early_color_hallways")) {
+      tagged["early_color_hallways"].push_back(subway_item.id);
+    }
+
+    if (AP_IsPaintingShuffle() && !subway_item.paintings.empty()) {
+      continue;
+    }
+
+    for (const std::string &tag : subway_item.tags) {
+      tagged[tag].push_back(subway_item.id);
+    }
+
+    if (!AP_IsSunwarpShuffle() && subway_item.sunwarp &&
+        subway_item.sunwarp->type != SubwaySunwarpType::kFinal) {
+      std::ostringstream tag;
+      tag << "sunwarp" << subway_item.sunwarp->dots;
+
+      tagged[tag.str()].push_back(subway_item.id);
+    }
+
+    if (!AP_IsPilgrimageEnabled() &&
+        (subway_item.special == "sun_painting" ||
+         subway_item.special == "sun_painting_exit")) {
+      tagged["sun_painting"].push_back(subway_item.id);
+    }
+  }
+
+  for (const auto &[tag, items] : tagged) {
+    // Pairwise connect all items with the same tag.
+    for (auto tag_it1 = items.begin(); std::next(tag_it1) != items.end();
+         tag_it1++) {
+      for (auto tag_it2 = std::next(tag_it1); tag_it2 != items.end();
+           tag_it2++) {
+        networks_.AddLink(*tag_it1, *tag_it2);
+      }
+    }
+  }
+
+  checked_paintings_.clear();
+}
+
+void SubwayMap::UpdateIndicators() {
+  if (AP_IsPaintingShuffle()) {
+    for (const std::string &painting_id : AP_GetCheckedPaintings()) {
+      if (!checked_paintings_.count(painting_id)) {
+        checked_paintings_.insert(painting_id);
+
+        if (AP_GetPaintingMapping().count(painting_id)) {
+          networks_.AddLink(GD_GetSubwayItemForPainting(painting_id),
+                            GD_GetSubwayItemForPainting(
+                                AP_GetPaintingMapping().at(painting_id)));
+        }
+      }
+    }
+  }
+
+  Redraw();
+}
+
+void SubwayMap::UpdateSunwarp(SubwaySunwarp from_sunwarp,
+                              SubwaySunwarp to_sunwarp) {
+  networks_.AddLink(GD_GetSubwayItemForSunwarp(from_sunwarp),
+                    GD_GetSubwayItemForSunwarp(to_sunwarp));
+}
+
+void SubwayMap::Zoom(bool in) {
+  wxPoint focus_point;
+
+  if (mouse_position_) {
+    focus_point = *mouse_position_;
+  } else {
+    focus_point = {GetSize().GetWidth() / 2, GetSize().GetHeight() / 2};
+  }
+
+  if (in) {
+    if (zoom_ < 3.0) {
+      SetZoom(zoom_ + 0.25, focus_point);
+    }
+  } else {
+    if (zoom_ > 1.0) {
+      SetZoom(zoom_ - 0.25, focus_point);
+    }
+  }
+}
+
+void SubwayMap::OnPaint(wxPaintEvent &event) {
+  if (GetSize() != rendered_.GetSize()) {
+    wxSize panel_size = GetSize();
+    wxSize image_size = map_image_.GetSize();
+
+    render_x_ = 0;
+    render_y_ = 0;
+    render_width_ = panel_size.GetWidth();
+    render_height_ = panel_size.GetHeight();
+
+    if (image_size.GetWidth() * panel_size.GetHeight() >
+        panel_size.GetWidth() * image_size.GetHeight()) {
+      render_height_ = (panel_size.GetWidth() * image_size.GetHeight()) /
+                       image_size.GetWidth();
+      render_y_ = (panel_size.GetHeight() - render_height_) / 2;
+    } else {
+      render_width_ = (image_size.GetWidth() * panel_size.GetHeight()) /
+                      image_size.GetHeight();
+      render_x_ = (panel_size.GetWidth() - render_width_) / 2;
+    }
+
+    SetZoomPos({zoom_x_, zoom_y_});
+
+    SetUpHelpButton();
+  }
+
+  wxBufferedPaintDC dc(this);
+  dc.SetBackground(*wxWHITE_BRUSH);
+  dc.Clear();
+
+  {
+    wxMemoryDC rendered_dc;
+    rendered_dc.SelectObject(rendered_);
+
+    int dst_x;
+    int dst_y;
+    int dst_w;
+    int dst_h;
+    int src_x;
+    int src_y;
+    int src_w;
+    int src_h;
+
+    int zoomed_width = render_width_ * zoom_;
+    int zoomed_height = render_height_ * zoom_;
+
+    if (zoomed_width <= GetSize().GetWidth()) {
+      dst_x = (GetSize().GetWidth() - zoomed_width) / 2;
+      dst_w = zoomed_width;
+      src_x = 0;
+      src_w = map_image_.GetWidth();
+    } else {
+      dst_x = 0;
+      dst_w = GetSize().GetWidth();
+      src_x = -zoom_x_ * map_image_.GetWidth() / render_width_ / zoom_;
+      src_w =
+          GetSize().GetWidth() * map_image_.GetWidth() / render_width_ / zoom_;
+    }
+
+    if (zoomed_height <= GetSize().GetHeight()) {
+      dst_y = (GetSize().GetHeight() - zoomed_height) / 2;
+      dst_h = zoomed_height;
+      src_y = 0;
+      src_h = map_image_.GetHeight();
+    } else {
+      dst_y = 0;
+      dst_h = GetSize().GetHeight();
+      src_y = -zoom_y_ * map_image_.GetWidth() / render_width_ / zoom_;
+      src_h =
+          GetSize().GetHeight() * map_image_.GetWidth() / render_width_ / zoom_;
+    }
+
+    wxGCDC gcdc(dc);
+    gcdc.GetGraphicsContext()->SetInterpolationQuality(wxINTERPOLATION_GOOD);
+    gcdc.StretchBlit(dst_x, dst_y, dst_w, dst_h, &rendered_dc, src_x, src_y,
+                     src_w, src_h);
+  }
+
+  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_);
+    if (subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) {
+      const std::map<std::string, bool> &report =
+          GetDoorRequirements(*subway_item.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);
+
+        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});
+
+        int left = std::min(item1_pos.x, item2_pos.x);
+        int top = std::min(item1_pos.y, item2_pos.y);
+        int right = std::max(item1_pos.x, item2_pos.x);
+        int bottom = std::max(item1_pos.y, item2_pos.y);
+
+        int halfwidth = right - left;
+        int halfheight = bottom - top;
+
+        if (halfwidth < 4 || halfheight < 4) {
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawLine(item1_pos, item2_pos);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawLine(item1_pos, item2_pos);
+        } else {
+          int ellipse_x;
+          int ellipse_y;
+          double start;
+          double end;
+
+          if (item1_pos.x > item2_pos.x) {
+            ellipse_y = top;
+
+            if (item1_pos.y > item2_pos.y) {
+              ellipse_x = left - halfwidth;
+
+              start = 0;
+              end = 90;
+            } else {
+              ellipse_x = left;
+
+              start = 90;
+              end = 180;
+            }
+          } else {
+            ellipse_y = top - halfheight;
+
+            if (item1_pos.y > item2_pos.y) {
+              ellipse_x = left - halfwidth;
+
+              start = 270;
+              end = 360;
+            } else {
+              ellipse_x = left;
+
+              start = 180;
+              end = 270;
+            }
+          }
+
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxBLACK, 4));
+          dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2,
+                             halfheight * 2, start, end);
+          dc.SetPen(*wxThePenList->FindOrCreatePen(*wxCYAN, 2));
+          dc.DrawEllipticArc(ellipse_x, ellipse_y, halfwidth * 2,
+                             halfheight * 2, start, end);
+        }
+      }
+    }
+  }
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseMove(wxMouseEvent &event) {
+  wxPoint mouse_pos = RenderPosToMapPos(event.GetPosition());
+
+  std::vector<int> hovered = tree_->query(
+      {static_cast<float>(mouse_pos.x), static_cast<float>(mouse_pos.y), 2, 2});
+  if (!hovered.empty()) {
+    actual_hover_= hovered[0];
+  } else {
+    actual_hover_ = std::nullopt;
+  }
+
+  if (!sticky_hover_ && actual_hover_ != hovered_item_) {
+    hovered_item_ = actual_hover_;
+
+    Refresh();
+  }
+
+  if (scroll_mode_) {
+    EvaluateScroll(event.GetPosition());
+  }
+
+  mouse_position_ = event.GetPosition();
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseScroll(wxMouseEvent &event) {
+  double new_zoom = zoom_;
+  if (event.GetWheelRotation() > 0) {
+    new_zoom = std::min(3.0, zoom_ + 0.25);
+  } else {
+    new_zoom = std::max(1.0, zoom_ - 0.25);
+  }
+
+  if (zoom_ != new_zoom) {
+    SetZoom(new_zoom, event.GetPosition());
+  }
+
+  event.Skip();
+}
+
+void SubwayMap::OnMouseLeave(wxMouseEvent &event) {
+  SetScrollSpeed(0, 0);
+  mouse_position_ = std::nullopt;
+}
+
+void SubwayMap::OnMouseClick(wxMouseEvent &event) {
+  bool finished = false;
+
+  if (actual_hover_) {
+    const SubwayItem &subway_item = GD_GetSubwayItem(*actual_hover_);
+    if ((subway_item.door && !GetDoorRequirements(*subway_item.door).empty()) ||
+        networks_.IsItemInNetwork(*hovered_item_)) {
+      if (actual_hover_ != hovered_item_) {
+        hovered_item_ = actual_hover_;
+
+        if (!hovered_item_) {
+          sticky_hover_ = false;
+        }
+
+        Refresh();
+      } else {
+        sticky_hover_ = !sticky_hover_;
+      }
+
+      finished = true;
+    }
+  }
+
+  if (!finished) {
+    if (scroll_mode_) {
+      scroll_mode_ = false;
+
+      SetScrollSpeed(0, 0);
+
+      SetCursor(wxCURSOR_ARROW);
+    } else if (event.GetPosition().x < GetSize().GetWidth() / 6 ||
+               event.GetPosition().x > 5 * GetSize().GetWidth() / 6 ||
+               event.GetPosition().y < GetSize().GetHeight() / 6 ||
+               event.GetPosition().y > 5 * GetSize().GetHeight() / 6) {
+      scroll_mode_ = true;
+
+      EvaluateScroll(event.GetPosition());
+
+      SetCursor(wxCURSOR_CROSS);
+    } else {
+      sticky_hover_ = false;
+    }
+  }
+}
+
+void SubwayMap::OnTimer(wxTimerEvent &event) {
+  SetZoomPos({zoom_x_ + scroll_x_, zoom_y_ + scroll_y_});
+  Refresh();
+}
+
+void SubwayMap::OnZoomSlide(wxCommandEvent &event) {
+  double new_zoom = 1.0 + 0.25 * zoom_slider_->GetValue();
+
+  if (new_zoom != zoom_) {
+    SetZoom(new_zoom, {GetSize().GetWidth() / 2, GetSize().GetHeight() / 2});
+  }
+}
+
+void SubwayMap::OnClickHelp(wxCommandEvent &event) {
+  wxMessageBox(
+      "Zoom in/out using the mouse wheel, Ctrl +/-, or the slider in the "
+      "corner.\nClick on a side of the screen to start panning. It will follow "
+      "your mouse. Click again to stop.\nHover over a door to see the "
+      "requirements to open it.\nHover over a warp or active painting to see "
+      "what it is connected to.\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.",
+      "Subway Map Help");
+}
+
+void SubwayMap::Redraw() {
+  rendered_ = wxBitmap(map_image_);
+
+  wxMemoryDC dc;
+  dc.SelectObject(rendered_);
+
+  wxGCDC gcdc(dc);
+
+  for (const SubwayItem &subway_item : GD_GetSubwayItems()) {
+    ItemDrawType draw_type = ItemDrawType::kNone;
+    const wxBrush *brush_color = wxGREY_BRUSH;
+    std::optional<wxColour> shade_color;
+
+    if (AP_HasEarlyColorHallways() &&
+        (subway_item.special == "starting_room_paintings" ||
+         subway_item.special == "early_color_hallways")) {
+      draw_type = ItemDrawType::kOwl;
+
+      if (subway_item.special == "starting_room_paintings") {
+        shade_color = wxColour(0, 255, 0, 128);
+      } else {
+        shade_color = wxColour(255, 0, 0, 128);
+      }
+    } else if (subway_item.special == "sun_painting") {
+      if (!AP_IsPilgrimageEnabled()) {
+        if (IsDoorOpen(*subway_item.door)) {
+          draw_type = ItemDrawType::kOwl;
+          shade_color = wxColour(0, 255, 0, 128);
+        } else {
+          draw_type = ItemDrawType::kBox;
+          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;
+          }
+        }
+
+        if (has_unchecked_painting || has_mapped_painting || has_codomain_painting) {
+          draw_type = ItemDrawType::kOwl;
+
+          if (has_checked_painting) {
+            if (has_mapped_painting) {
+              shade_color = wxColour(0, 255, 0, 128);
+            } else {
+              shade_color = wxColour(255, 0, 0, 128);
+            }
+          }
+        }
+      } else if (!subway_item.tags.empty()) {
+        draw_type = ItemDrawType::kOwl;
+      }
+    } else if (subway_item.door) {
+      draw_type = ItemDrawType::kBox;
+
+      if (IsDoorOpen(*subway_item.door)) {
+        brush_color = wxGREEN_BRUSH;
+      } else {
+        brush_color = wxRED_BRUSH;
+      }
+    }
+
+    wxPoint real_area_pos = {subway_item.x, subway_item.y};
+
+    int real_area_size =
+        (draw_type == ItemDrawType::kOwl ? OWL_ACTUAL_SIZE : AREA_ACTUAL_SIZE);
+
+    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));
+        gcdc.DrawRectangle(real_area_pos, {real_area_size, real_area_size});
+      }
+    }
+  }
+}
+
+void SubwayMap::SetUpHelpButton() {
+  help_button_->SetPosition({
+      GetSize().GetWidth() - help_button_->GetSize().GetWidth() - 15,
+      15,
+  });
+}
+
+void SubwayMap::EvaluateScroll(wxPoint pos) {
+  int scroll_x;
+  int scroll_y;
+  if (pos.x < GetSize().GetWidth() / 9) {
+    scroll_x = 20;
+  } else if (pos.x < GetSize().GetWidth() / 6) {
+    scroll_x = 5;
+  } else if (pos.x > 8 * GetSize().GetWidth() / 9) {
+    scroll_x = -20;
+  } else if (pos.x > 5 * GetSize().GetWidth() / 6) {
+    scroll_x = -5;
+  } else {
+    scroll_x = 0;
+  }
+  if (pos.y < GetSize().GetHeight() / 9) {
+    scroll_y = 20;
+  } else if (pos.y < GetSize().GetHeight() / 6) {
+    scroll_y = 5;
+  } else if (pos.y > 8 * GetSize().GetHeight() / 9) {
+    scroll_y = -20;
+  } else if (pos.y > 5 * GetSize().GetHeight() / 6) {
+    scroll_y = -5;
+  } else {
+    scroll_y = 0;
+  }
+
+  SetScrollSpeed(scroll_x, scroll_y);
+}
+
+wxPoint SubwayMap::MapPosToRenderPos(wxPoint pos) const {
+  return {static_cast<int>(pos.x * render_width_ * zoom_ /
+                               map_image_.GetSize().GetWidth() +
+                           zoom_x_),
+          static_cast<int>(pos.y * render_width_ * zoom_ /
+                               map_image_.GetSize().GetWidth() +
+                           zoom_y_)};
+}
+
+wxPoint SubwayMap::MapPosToVirtualPos(wxPoint pos) const {
+  return {static_cast<int>(pos.x * render_width_ * zoom_ /
+                           map_image_.GetSize().GetWidth()),
+          static_cast<int>(pos.y * render_width_ * zoom_ /
+                           map_image_.GetSize().GetWidth())};
+}
+
+wxPoint SubwayMap::RenderPosToMapPos(wxPoint pos) const {
+  return {
+      std::clamp(static_cast<int>((pos.x - zoom_x_) * map_image_.GetWidth() /
+                                  render_width_ / zoom_),
+                 0, map_image_.GetWidth() - 1),
+      std::clamp(static_cast<int>((pos.y - zoom_y_) * map_image_.GetWidth() /
+                                  render_width_ / zoom_),
+                 0, map_image_.GetHeight() - 1)};
+}
+
+void SubwayMap::SetZoomPos(wxPoint pos) {
+  if (render_width_ * zoom_ <= GetSize().GetWidth()) {
+    zoom_x_ = (GetSize().GetWidth() - render_width_ * zoom_) / 2;
+  } else {
+    zoom_x_ = std::clamp(
+        pos.x, GetSize().GetWidth() - static_cast<int>(render_width_ * zoom_),
+        0);
+  }
+  if (render_height_ * zoom_ <= GetSize().GetHeight()) {
+    zoom_y_ = (GetSize().GetHeight() - render_height_ * zoom_) / 2;
+  } else {
+    zoom_y_ = std::clamp(
+        pos.y, GetSize().GetHeight() - static_cast<int>(render_height_ * zoom_),
+        0);
+  }
+}
+
+void SubwayMap::SetScrollSpeed(int scroll_x, int scroll_y) {
+  bool should_timer = (scroll_x != 0 || scroll_y != 0);
+  if (should_timer != scroll_timer_->IsRunning()) {
+    if (should_timer) {
+      scroll_timer_->Start(1000 / 60);
+    } else {
+      scroll_timer_->Stop();
+    }
+  }
+
+  scroll_x_ = scroll_x;
+  scroll_y_ = scroll_y;
+}
+
+void SubwayMap::SetZoom(double zoom, wxPoint static_point) {
+  wxPoint map_pos = RenderPosToMapPos(static_point);
+  zoom_ = zoom;
+
+  wxPoint virtual_pos = MapPosToVirtualPos(map_pos);
+  SetZoomPos(-(virtual_pos - static_point));
+
+  Refresh();
+
+  zoom_slider_->SetValue((zoom - 1.0) / 0.25);
+}
+
+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};
+}
@@ -0,0 +1,92 @@
+#ifndef SUBWAY_MAP_H_BD2D843E
+#define SUBWAY_MAP_H_BD2D843E
+
+#include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include <wx/wx.h>
+#endif
+
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <quadtree/Quadtree.h>
+
+#include "game_data.h"
+#include "network_set.h"
+
+class SubwayMap : public wxPanel {
+ public:
+  SubwayMap(wxWindow *parent);
+
+  void OnConnect();
+  void UpdateIndicators();
+  void UpdateSunwarp(SubwaySunwarp from_sunwarp, SubwaySunwarp to_sunwarp);
+  void Zoom(bool in);
+
+ private:
+  void OnPaint(wxPaintEvent &event);
+  void OnMouseMove(wxMouseEvent &event);
+  void OnMouseScroll(wxMouseEvent &event);
+  void OnMouseLeave(wxMouseEvent &event);
+  void OnMouseClick(wxMouseEvent &event);
+  void OnTimer(wxTimerEvent &event);
+  void OnZoomSlide(wxCommandEvent &event);
+  void OnClickHelp(wxCommandEvent &event);
+
+  void Redraw();
+  void SetUpHelpButton();
+
+  wxPoint MapPosToRenderPos(wxPoint pos) const;
+  wxPoint MapPosToVirtualPos(wxPoint pos) const;
+  wxPoint RenderPosToMapPos(wxPoint pos) const;
+
+  void EvaluateScroll(wxPoint pos);
+
+  void SetZoomPos(wxPoint pos);
+  void SetScrollSpeed(int scroll_x, int scroll_y);
+  void SetZoom(double zoom, wxPoint static_point);
+
+  wxImage map_image_;
+  wxImage owl_image_;
+  wxBitmap unchecked_eye_;
+  wxBitmap checked_eye_;
+
+  wxBitmap rendered_;
+  int render_x_ = 0;
+  int render_y_ = 0;
+  int render_width_ = 1;
+  int render_height_ = 1;
+
+  double zoom_ = 1.0;
+  int zoom_x_ = 0; // in render space
+  int zoom_y_ = 0;
+
+  bool scroll_mode_ = false;
+  wxTimer* scroll_timer_;
+  int scroll_x_ = 0;
+  int scroll_y_ = 0;
+
+  wxSlider *zoom_slider_;
+
+  wxButton *help_button_;
+
+  std::optional<wxPoint> mouse_position_;
+
+  struct GetItemBox {
+    quadtree::Box<float> operator()(const int &id) const;
+  };
+  
+  std::unique_ptr<quadtree::Quadtree<int, GetItemBox>> tree_;
+  std::optional<int> hovered_item_;
+  std::optional<int> actual_hover_;
+  bool sticky_hover_ = false;
+
+  NetworkSet networks_;
+  std::set<std::string> checked_paintings_;
+};
+
+#endif /* end of include guard: SUBWAY_MAP_H_BD2D843E */
@@ -1,6 +1,8 @@
 #include "tracker_frame.h"
 
+#include <wx/aboutdlg.h>
 #include <wx/choicebk.h>
+#include <wx/notebook.h>
 #include <wx/webrequest.h>
 
 #include <nlohmann/json.hpp>
@@ -10,6 +12,7 @@
 #include "ap_state.h"
 #include "connection_dialog.h"
 #include "settings_dialog.h"
+#include "subway_map.h"
 #include "tracker_config.h"
 #include "tracker_panel.h"
 #include "version.h"
@@ -17,9 +20,12 @@
 enum TrackerFrameIds {
   ID_CONNECT = 1,
   ID_CHECK_FOR_UPDATES = 2,
-  ID_SETTINGS = 3
+  ID_SETTINGS = 3,
+  ID_ZOOM_IN = 4,
+  ID_ZOOM_OUT = 5,
 };
 
+wxDEFINE_EVENT(STATE_RESET, wxCommandEvent);
 wxDEFINE_EVENT(STATE_CHANGED, wxCommandEvent);
 wxDEFINE_EVENT(STATUS_CHANGED, wxCommandEvent);
 
@@ -35,12 +41,20 @@ TrackerFrame::TrackerFrame()
   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--");
+
+  zoom_in_menu_item_->Enable(false);
+  zoom_out_menu_item_->Enable(false);
+
   wxMenu *menuHelp = new wxMenu();
   menuHelp->Append(wxID_ABOUT);
   menuHelp->Append(ID_CHECK_FOR_UPDATES, "Check for Updates");
 
   wxMenuBar *menuBar = new wxMenuBar();
   menuBar->Append(menuFile, "&File");
+  menuBar->Append(menuView, "&View");
   menuBar->Append(menuHelp, "&Help");
 
   SetMenuBar(menuBar);
@@ -54,18 +68,26 @@ TrackerFrame::TrackerFrame()
   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_NOTEBOOK_PAGE_CHANGED, &TrackerFrame::OnChangePage, this);
+  Bind(STATE_RESET, &TrackerFrame::OnStateReset, this);
   Bind(STATE_CHANGED, &TrackerFrame::OnStateChanged, this);
   Bind(STATUS_CHANGED, &TrackerFrame::OnStatusChanged, this);
 
   wxChoicebook *choicebook = new wxChoicebook(this, wxID_ANY);
-  achievements_pane_ = new AchievementsPane(this);
+  achievements_pane_ = new AchievementsPane(choicebook);
   choicebook->AddPage(achievements_pane_, "Achievements");
 
-  tracker_panel_ = new TrackerPanel(this);
+  notebook_ = new wxNotebook(this, 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(tracker_panel_, wxSizerFlags().Expand().Proportion(3));
+  top_sizer->Add(notebook_, wxSizerFlags().Expand().Proportion(3));
 
   SetSizerAndFit(top_sizer);
   SetSize(1280, 728);
@@ -96,17 +118,23 @@ void TrackerFrame::SetStatusMessage(std::string message) {
   QueueEvent(event);
 }
 
+void TrackerFrame::ResetIndicators() {
+  QueueEvent(new wxCommandEvent(STATE_RESET));
+}
+
 void TrackerFrame::UpdateIndicators() {
   QueueEvent(new wxCommandEvent(STATE_CHANGED));
 }
 
 void TrackerFrame::OnAbout(wxCommandEvent &event) {
-  std::ostringstream message_text;
-  message_text << "Lingo Archipelago Tracker " << kTrackerVersion
-               << " by hatkirby";
-
-  wxMessageBox(message_text.str(), "About lingo-ap-tracker",
-               wxOK | wxICON_INFORMATION);
+  wxAboutDialogInfo about_info;
+  about_info.SetName("Lingo Archipelago Tracker");
+  about_info.SetVersion(kTrackerVersion.ToString());
+  about_info.AddDeveloper("hatkirby");
+  about_info.AddArtist("Brenton Wildes");
+  about_info.AddArtist("kinrah");
+
+  wxAboutBox(about_info);
 }
 
 void TrackerFrame::OnExit(wxCommandEvent &event) { Close(true); }
@@ -122,7 +150,8 @@ void TrackerFrame::OnConnect(wxCommandEvent &event) {
     std::deque<ConnectionDetails> new_history;
     new_history.push_back(GetTrackerConfig().connection_details);
 
-    for (const ConnectionDetails& details : GetTrackerConfig().connection_history) {
+    for (const ConnectionDetails &details :
+         GetTrackerConfig().connection_history) {
       if (details != GetTrackerConfig().connection_details) {
         new_history.push_back(details);
       }
@@ -158,9 +187,34 @@ void TrackerFrame::OnCheckForUpdates(wxCommandEvent &event) {
   CheckForUpdates(/*manual=*/true);
 }
 
+void TrackerFrame::OnZoomIn(wxCommandEvent &event) {
+  if (notebook_->GetSelection() == 1) {
+    subway_map_->Zoom(true);
+  }
+}
+
+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::OnStateReset(wxCommandEvent& event) {
+  tracker_panel_->UpdateIndicators();
+  achievements_pane_->UpdateIndicators();
+  subway_map_->OnConnect();
+  Refresh();
+}
+
 void TrackerFrame::OnStateChanged(wxCommandEvent &event) {
   tracker_panel_->UpdateIndicators();
   achievements_pane_->UpdateIndicators();
+  subway_map_->UpdateIndicators();
   Refresh();
 }
 
@@ -192,8 +246,10 @@ void TrackerFrame::CheckForUpdates(bool manual) {
         std::ostringstream message_text;
         message_text << "There is a newer version of Lingo AP Tracker "
                         "available. You have "
-                     << kTrackerVersion << ", and the latest version is "
-                     << latest_version << ". Would you like to update?";
+                     << 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) {
@@ -8,8 +8,12 @@
 #endif
 
 class AchievementsPane;
+class SubwayMap;
 class TrackerPanel;
+class wxBookCtrlEvent;
+class wxNotebook;
 
+wxDECLARE_EVENT(STATE_RESET, wxCommandEvent);
 wxDECLARE_EVENT(STATE_CHANGED, wxCommandEvent);
 wxDECLARE_EVENT(STATUS_CHANGED, wxCommandEvent);
 
@@ -19,6 +23,7 @@ class TrackerFrame : public wxFrame {
 
   void SetStatusMessage(std::string message);
 
+  void ResetIndicators();
   void UpdateIndicators();
 
  private:
@@ -27,14 +32,23 @@ class TrackerFrame : public wxFrame {
   void OnConnect(wxCommandEvent &event);
   void OnSettings(wxCommandEvent &event);
   void OnCheckForUpdates(wxCommandEvent &event);
+  void OnZoomIn(wxCommandEvent &event);
+  void OnZoomOut(wxCommandEvent &event);
+  void OnChangePage(wxBookCtrlEvent &event);
 
+  void OnStateReset(wxCommandEvent &event);
   void OnStateChanged(wxCommandEvent &event);
   void OnStatusChanged(wxCommandEvent &event);
 
   void CheckForUpdates(bool manual);
 
+  wxNotebook *notebook_;
   TrackerPanel *tracker_panel_;
   AchievementsPane *achievements_pane_;
+  SubwayMap *subway_map_;
+
+  wxMenuItem *zoom_in_menu_item_;
+  wxMenuItem *zoom_out_menu_item_;
 };
 
 #endif /* end of include guard: TRACKER_FRAME_H_86BD8DFB */
@@ -1,5 +1,7 @@
 #include "tracker_panel.h"
 
+#include <wx/dcbuffer.h>
+
 #include "ap_state.h"
 #include "area_popup.h"
 #include "game_data.h"
@@ -13,6 +15,8 @@ constexpr int AREA_EFFECTIVE_SIZE = AREA_ACTUAL_SIZE + AREA_BORDER_SIZE * 2;
 constexpr int PLAYER_SIZE = 96;
 
 TrackerPanel::TrackerPanel(wxWindow *parent) : wxPanel(parent, wxID_ANY) {
+  SetBackgroundStyle(wxBG_STYLE_PAINT);
+
   map_image_ = wxImage(GetAbsolutePath("assets/lingo_map.png").c_str(),
                        wxBITMAP_TYPE_PNG);
   if (!map_image_.IsOk()) {
@@ -54,7 +58,7 @@ void TrackerPanel::OnPaint(wxPaintEvent &event) {
     Redraw();
   }
 
-  wxPaintDC dc(this);
+  wxBufferedPaintDC dc(this);
   dc.DrawBitmap(rendered_, 0, 0);
 
   if (AP_GetPlayerPosition().has_value()) {
@@ -139,7 +143,8 @@ void TrackerPanel::Redraw() {
   for (AreaIndicator &area : areas_) {
     const MapArea &map_area = GD_GetMapArea(area.area_id);
     if (!AP_IsLocationVisible(map_area.classification) &&
-        !(map_area.hunt && GetTrackerConfig().show_hunt_panels)) {
+        !(map_area.hunt && GetTrackerConfig().show_hunt_panels) &&
+        !(AP_IsPaintingShuffle() && !map_area.paintings.empty())) {
       area.active = false;
       continue;
     } else {
@@ -167,6 +172,21 @@ void TrackerPanel::Redraw() {
       }
     }
 
+    if (AP_IsPaintingShuffle()) {
+      for (int painting_id : map_area.paintings) {
+        const PaintingExit &painting = GD_GetPaintingExit(painting_id);
+        if (!AP_IsPaintingChecked(painting.internal_id)) {
+          bool reachable = IsPaintingReachable(painting_id);
+
+          if (reachable) {
+            has_reachable_unchecked = true;
+          } else {
+            has_unreachable_unchecked = true;
+          }
+        }
+      }
+    }
+
     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)) *
@@ -12,9 +12,142 @@
 
 namespace {
 
+struct Requirements {
+  bool disabled = false;
+
+  std::set<int> doors;      // non-grouped, handles progressive
+  std::set<int> items;      // all other items
+  std::set<int> rooms;      // maybe
+  bool mastery = false;     // maybe
+  bool panel_hunt = false;  // maybe
+
+  void Merge(const Requirements& rhs) {
+    if (rhs.disabled) {
+      return;
+    }
+
+    for (int id : rhs.doors) {
+      doors.insert(id);
+    }
+    for (int id : rhs.items) {
+      items.insert(id);
+    }
+    for (int id : rhs.rooms) {
+      rooms.insert(id);
+    }
+    mastery = mastery || rhs.mastery;
+    panel_hunt = panel_hunt || rhs.panel_hunt;
+  }
+};
+
+class RequirementCalculator {
+ public:
+  void Reset() {
+    doors_.clear();
+    panels_.clear();
+  }
+
+  const Requirements& GetDoor(int door_id) {
+    if (!doors_.count(door_id)) {
+      Requirements requirements;
+      const Door& door_obj = GD_GetDoor(door_id);
+
+      if (door_obj.type == DoorType::kSunPainting) {
+        if (!AP_IsPilgrimageEnabled()) {
+          requirements.items.insert(door_obj.ap_item_id);
+        } else {
+          requirements.disabled = true;
+        }
+      } else if (door_obj.type == DoorType::kSunwarp) {
+        switch (AP_GetSunwarpAccess()) {
+          case kSUNWARP_ACCESS_NORMAL:
+            // Do nothing.
+            break;
+          case kSUNWARP_ACCESS_DISABLED:
+            requirements.disabled = true;
+            break;
+          case kSUNWARP_ACCESS_UNLOCK:
+            requirements.items.insert(door_obj.group_ap_item_id);
+            break;
+          case kSUNWARP_ACCESS_INDIVIDUAL:
+          case kSUNWARP_ACCESS_PROGRESSIVE:
+            requirements.doors.insert(door_obj.id);
+            break;
+        }
+      } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
+        requirements.rooms.insert(door_obj.room);
+
+        for (int panel_id : door_obj.panels) {
+          const Requirements& panel_reqs = GetPanel(panel_id);
+          requirements.Merge(panel_reqs);
+        }
+      } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
+                 !door_obj.group_name.empty()) {
+        requirements.items.insert(door_obj.group_ap_item_id);
+      } else {
+        requirements.doors.insert(door_obj.id);
+      }
+
+      doors_[door_id] = requirements;
+    }
+
+    return doors_[door_id];
+  }
+
+  const Requirements& GetPanel(int panel_id) {
+    if (!panels_.count(panel_id)) {
+      Requirements requirements;
+      const Panel& panel_obj = GD_GetPanel(panel_id);
+
+      requirements.rooms.insert(panel_obj.room);
+
+      if (panel_obj.name == "THE MASTER") {
+        requirements.mastery = true;
+      }
+
+      if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
+          AP_GetLevel2Requirement() > 1) {
+        requirements.panel_hunt = true;
+      }
+
+      for (int room_id : panel_obj.required_rooms) {
+        requirements.rooms.insert(room_id);
+      }
+
+      for (int door_id : panel_obj.required_doors) {
+        const Requirements& door_reqs = GetDoor(door_id);
+        requirements.Merge(door_reqs);
+      }
+
+      for (int panel_id : panel_obj.required_panels) {
+        const Requirements& panel_reqs = GetPanel(panel_id);
+        requirements.Merge(panel_reqs);
+      }
+
+      if (AP_IsColorShuffle()) {
+        for (LingoColor color : panel_obj.colors) {
+          requirements.items.insert(GD_GetItemIdForColor(color));
+        }
+      }
+
+      panels_[panel_id] = requirements;
+    }
+
+    return panels_[panel_id];
+  }
+
+ private:
+  std::map<int, Requirements> doors_;
+  std::map<int, Requirements> panels_;
+};
+
 struct TrackerState {
   std::map<int, bool> reachability;
+  std::set<int> reachable_doors;
+  std::set<int> reachable_paintings;
   std::mutex reachability_mutex;
+  RequirementCalculator requirements;
+  std::map<int, std::map<std::string, bool>> door_reports;
 };
 
 enum Decision { kYes, kNo, kMaybe };
@@ -41,6 +174,7 @@ class StateCalculator {
 
   void Calculate() {
     std::list<int> panel_boundary;
+    std::list<int> painting_boundary;
     std::list<Exit> flood_boundary;
     flood_boundary.push_back({.destination_room = options_.start});
 
@@ -48,6 +182,8 @@ class StateCalculator {
     while (reachable_changed) {
       reachable_changed = false;
 
+      std::list<Exit> new_boundary;
+
       std::list<int> new_panel_boundary;
       for (int panel_id : panel_boundary) {
         if (solveable_panels_.count(panel_id)) {
@@ -63,7 +199,33 @@ class StateCalculator {
         }
       }
 
-      std::list<Exit> new_boundary;
+      std::list<int> new_painting_boundary;
+      for (int painting_id : painting_boundary) {
+        if (reachable_paintings_.count(painting_id)) {
+          continue;
+        }
+
+        Decision painting_reachable = IsPaintingReachable(painting_id);
+        if (painting_reachable == kYes) {
+          reachable_paintings_.insert(painting_id);
+          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)) {
+            Exit painting_exit;
+            PaintingExit target_painting =
+                GD_GetPaintingExit(GD_GetPaintingByName(
+                    AP_GetPaintingMapping().at(cur_painting.internal_id)));
+            painting_exit.destination_room = target_painting.room;
+
+            new_boundary.push_back(painting_exit);
+          }
+        } else if (painting_reachable == kMaybe) {
+          new_painting_boundary.push_back(painting_id);
+        }
+      }
+
       for (const Exit& room_exit : flood_boundary) {
         if (reachable_rooms_.count(room_exit.destination_room)) {
           continue;
@@ -98,15 +260,8 @@ class StateCalculator {
           }
 
           if (AP_IsPaintingShuffle()) {
-            for (const PaintingExit& out_edge : room_obj.paintings) {
-              if (AP_GetPaintingMapping().count(out_edge.id)) {
-                Exit painting_exit;
-                painting_exit.destination_room = GD_GetRoomForPainting(
-                    AP_GetPaintingMapping().at(out_edge.id));
-                painting_exit.door = out_edge.door;
-
-                new_boundary.push_back(painting_exit);
-              }
+            for (int out_edge : room_obj.paintings) {
+              new_painting_boundary.push_back(out_edge);
             }
           }
 
@@ -155,6 +310,13 @@ class StateCalculator {
 
       flood_boundary = new_boundary;
       panel_boundary = new_panel_boundary;
+      painting_boundary = new_painting_boundary;
+    }
+
+    // Now that we know the full reachable area, let's make sure all doors are
+    // evaluated.
+    for (const Door& door : GD_GetDoors()) {
+      int discard = IsDoorReachable(door.id);
     }
   }
 
@@ -166,6 +328,14 @@ class StateCalculator {
 
   const std::set<int>& GetSolveablePanels() const { return solveable_panels_; }
 
+  const std::set<int>& GetReachablePaintings() const {
+    return reachable_paintings_;
+  }
+
+  const std::map<int, std::map<std::string, bool>>& GetDoorReports() const {
+    return door_report_;
+  }
+
  private:
   Decision IsNonGroupedDoorReachable(const Door& door_obj) {
     bool has_item = AP_HasItem(door_obj.ap_item_id);
@@ -182,68 +352,52 @@ class StateCalculator {
     return has_item ? kYes : kNo;
   }
 
-  Decision IsDoorReachable_Helper(int door_id) {
-    const Door& door_obj = GD_GetDoor(door_id);
-
-    if (!AP_IsPilgrimageEnabled() && door_obj.type == DoorType::kSunPainting) {
-      return AP_HasItem(door_obj.ap_item_id) ? kYes : kNo;
-    } else if (door_obj.type == DoorType::kSunwarp) {
-      switch (AP_GetSunwarpAccess()) {
-        case kSUNWARP_ACCESS_NORMAL:
-          return kYes;
-        case kSUNWARP_ACCESS_DISABLED:
-          return kNo;
-        case kSUNWARP_ACCESS_UNLOCK:
-          return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
-        case kSUNWARP_ACCESS_INDIVIDUAL:
-        case kSUNWARP_ACCESS_PROGRESSIVE:
-          return IsNonGroupedDoorReachable(door_obj);
-      }
-    } else if (AP_GetDoorShuffleMode() == kNO_DOORS || door_obj.skip_item) {
-      if (!reachable_rooms_.count(door_obj.room)) {
-        return kMaybe;
-      }
-
-      for (int panel_id : door_obj.panels) {
-        if (!solveable_panels_.count(panel_id)) {
-          return kMaybe;
-        }
-      }
-
-      return kYes;
-    } else if (AP_GetDoorShuffleMode() == kSIMPLE_DOORS &&
-               !door_obj.group_name.empty()) {
-      return AP_HasItem(door_obj.group_ap_item_id) ? kYes : kNo;
-    } else {
-      return IsNonGroupedDoorReachable(door_obj);
+  Decision AreRequirementsSatisfied(
+      const Requirements& reqs, std::map<std::string, bool>* report = nullptr) {
+    if (reqs.disabled) {
+      return kNo;
     }
-  }
 
-  Decision IsDoorReachable(int door_id) {
-    if (options_.parent) {
-      return options_.parent->IsDoorReachable(door_id);
-    }
+    Decision final_decision = kYes;
 
-    if (door_decisions_.count(door_id)) {
-      return door_decisions_.at(door_id);
+    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 (decision != kYes) {
+        final_decision = decision;
+      }
     }
 
-    Decision result = IsDoorReachable_Helper(door_id);
-    if (result != kMaybe) {
-      door_decisions_[door_id] = result;
+    for (int item_id : reqs.items) {
+      bool has_item = AP_HasItem(item_id);
+      if (report) {
+        (*report)[AP_GetItemName(item_id)] = has_item;
+      }
+
+      if (!has_item) {
+        final_decision = kNo;
+      }
     }
 
-    return result;
-  }
+    for (int room_id : reqs.rooms) {
+      bool reachable = reachable_rooms_.count(room_id);
 
-  Decision IsPanelReachable(int panel_id) {
-    const Panel& panel_obj = GD_GetPanel(panel_id);
+      if (report) {
+        std::string report_name = "Reach \"" + GD_GetRoom(room_id).name + "\"";
+        (*report)[report_name] = reachable;
+      }
 
-    if (!reachable_rooms_.count(panel_obj.room)) {
-      return kMaybe;
+      if (!reachable && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    if (panel_obj.name == "THE MASTER") {
+    if (reqs.mastery) {
       int achievements_accessible = 0;
 
       for (int achieve_id : GD_GetAchievementPanels()) {
@@ -256,12 +410,18 @@ class StateCalculator {
         }
       }
 
-      return (achievements_accessible >= AP_GetMasteryRequirement()) ? kYes
-                                                                     : kMaybe;
+      bool can_mastery =
+          (achievements_accessible >= AP_GetMasteryRequirement());
+      if (report) {
+        (*report)["Mastery"] = can_mastery;
+      }
+
+      if (!can_mastery && final_decision != kNo) {
+        final_decision = kMaybe;
+      }
     }
 
-    if ((panel_obj.name == "ANOTHER TRY" || panel_obj.name == "LEVEL 2") &&
-        AP_GetLevel2Requirement() > 1) {
+    if (reqs.panel_hunt) {
       int counting_panels_accessible = 0;
 
       for (int solved_panel_id : solveable_panels_) {
@@ -272,41 +432,58 @@ class StateCalculator {
         }
       }
 
-      return (counting_panels_accessible >= AP_GetLevel2Requirement() - 1)
-                 ? kYes
-                 : kMaybe;
-    }
+      bool can_level2 =
+          (counting_panels_accessible >= AP_GetLevel2Requirement() - 1);
+      if (report) {
+        std::string report_name =
+            std::to_string(AP_GetLevel2Requirement()) + " Panels";
+        (*report)[report_name] = can_level2;
+      }
 
-    for (int room_id : panel_obj.required_rooms) {
-      if (!reachable_rooms_.count(room_id)) {
-        return kMaybe;
+      if (!can_level2 && final_decision != kNo) {
+        final_decision = kMaybe;
       }
     }
 
-    for (int door_id : panel_obj.required_doors) {
-      Decision door_reachable = IsDoorReachable(door_id);
-      if (door_reachable == kNo) {
-        const Door& door_obj = GD_GetDoor(door_id);
-        return (door_obj.is_event || AP_GetDoorShuffleMode() == kNO_DOORS)
-                   ? kMaybe
-                   : kNo;
-      } else if (door_reachable == kMaybe) {
-        return kMaybe;
-      }
+    return final_decision;
+  }
+
+  Decision IsDoorReachable_Helper(int door_id) {
+    if (door_report_.count(door_id)) {
+      door_report_[door_id].clear();
+    } else {
+      door_report_[door_id] = {};
     }
 
-    for (int panel_id : panel_obj.required_panels) {
-      if (!solveable_panels_.count(panel_id)) {
-        return kMaybe;
-      }
+    return AreRequirementsSatisfied(GetState().requirements.GetDoor(door_id),
+                                    &door_report_[door_id]);
+  }
+
+  Decision IsDoorReachable(int door_id) {
+    if (options_.parent) {
+      return options_.parent->IsDoorReachable(door_id);
     }
 
-    if (AP_IsColorShuffle()) {
-      for (LingoColor color : panel_obj.colors) {
-        if (!AP_HasItem(GD_GetItemIdForColor(color))) {
-          return kNo;
-        }
-      }
+    if (door_decisions_.count(door_id)) {
+      return door_decisions_.at(door_id);
+    }
+
+    Decision result = IsDoorReachable_Helper(door_id);
+    if (result != kMaybe) {
+      door_decisions_[door_id] = result;
+    }
+
+    return result;
+  }
+
+  Decision IsPanelReachable(int panel_id) {
+    return AreRequirementsSatisfied(GetState().requirements.GetPanel(panel_id));
+  }
+
+  Decision IsPaintingReachable(int painting_id) {
+    const PaintingExit& painting = GD_GetPaintingExit(painting_id);
+    if (painting.door) {
+      return IsDoorReachable(*painting.door);
     }
 
     return kYes;
@@ -395,10 +572,17 @@ class StateCalculator {
   std::set<int> reachable_rooms_;
   std::map<int, Decision> door_decisions_;
   std::set<int> solveable_panels_;
+  std::set<int> reachable_paintings_;
+  std::map<int, std::map<std::string, bool>> door_report_;
 };
 
 }  // namespace
 
+void ResetReachabilityRequirements() {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+  GetState().requirements.Reset();
+}
+
 void RecalculateReachability() {
   StateCalculator state_calculator({.start = GD_GetRoomByName("Menu")});
   state_calculator.Calculate();
@@ -422,9 +606,23 @@ void RecalculateReachability() {
     }
   }
 
+  std::set<int> new_reachable_doors;
+  for (const auto& [door_id, decision] : state_calculator.GetDoorDecisions()) {
+    if (decision == kYes) {
+      new_reachable_doors.insert(door_id);
+    }
+  }
+
+  std::set<int> reachable_paintings = state_calculator.GetReachablePaintings();
+  std::map<int, std::map<std::string, bool>> door_reports =
+      state_calculator.GetDoorReports();
+
   {
     std::lock_guard reachability_guard(GetState().reachability_mutex);
     std::swap(GetState().reachability, new_reachability);
+    std::swap(GetState().reachable_doors, new_reachable_doors);
+    std::swap(GetState().reachable_paintings, reachable_paintings);
+    std::swap(GetState().door_reports, door_reports);
   }
 }
 
@@ -437,3 +635,21 @@ bool IsLocationReachable(int location_id) {
     return false;
   }
 }
+
+bool IsDoorOpen(int door_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().reachable_doors.count(door_id);
+}
+
+bool IsPaintingReachable(int painting_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().reachable_paintings.count(painting_id);
+}
+
+const std::map<std::string, bool>& GetDoorRequirements(int door_id) {
+  std::lock_guard reachability_guard(GetState().reachability_mutex);
+
+  return GetState().door_reports[door_id];
+}
@@ -1,8 +1,19 @@
 #ifndef TRACKER_STATE_H_8639BC90
 #define TRACKER_STATE_H_8639BC90
 
+#include <map>
+#include <string>
+
+void ResetReachabilityRequirements();
+
 void RecalculateReachability();
 
 bool IsLocationReachable(int location_id);
 
+bool IsDoorOpen(int door_id);
+
+bool IsPaintingReachable(int painting_id);
+
+const std::map<std::string, bool>& GetDoorRequirements(int door_id);
+
 #endif /* end of include guard: TRACKER_STATE_H_8639BC90 */
@@ -1,7 +1,7 @@
 #ifndef VERSION_H_C757E53C
 #define VERSION_H_C757E53C
 
-#include <iostream>
+#include <sstream>
 #include <regex>
 
 struct Version {
@@ -23,6 +23,12 @@ struct Version {
     }
   }
 
+  std::string ToString() const {
+    std::ostringstream output;
+    output << "v" << major << "." << minor << "." << revision;
+    return output.str();
+  }
+
   bool operator<(const Version& rhs) const {
     return (major < rhs.major) ||
            (major == rhs.major &&
@@ -31,10 +37,6 @@ struct Version {
   }
 };
 
-std::ostream& operator<<(std::ostream& out, const Version& ver) {
-  return out << "v" << ver.major << "." << ver.minor << "." << ver.revision;
-}
-
 constexpr const Version kTrackerVersion = Version(0, 9, 2);
 
 #endif /* end of include guard: VERSION_H_C757E53C */
\ No newline at end of file
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "Vector2.h"
+
+namespace quadtree
+{
+
+template<typename T>
+class Box
+{
+public:
+    T left;
+    T top;
+    T width; // Must be positive
+    T height; // Must be positive
+
+    constexpr Box(T Left = 0, T Top = 0, T Width = 0, T Height = 0) noexcept :
+        left(Left), top(Top), width(Width), height(Height)
+    {
+
+    }
+
+    constexpr Box(const Vector2<T>& position, const Vector2<T>& size) noexcept :
+        left(position.x), top(position.y), width(size.x), height(size.y)
+    {
+
+    }
+
+    constexpr T getRight() const noexcept
+    {
+        return left + width;
+    }
+
+    constexpr T getBottom() const noexcept
+    {
+        return top + height;
+    }
+
+    constexpr Vector2<T> getTopLeft() const noexcept
+    {
+        return Vector2<T>(left, top);
+    }
+
+    constexpr Vector2<T> getCenter() const noexcept
+    {
+        return Vector2<T>(left + width / 2, top + height / 2);
+    }
+
+    constexpr Vector2<T> getSize() const noexcept
+    {
+        return Vector2<T>(width, height);
+    }
+
+    constexpr bool contains(const Box<T>& box) const noexcept
+    {
+        return left <= box.left && box.getRight() <= getRight() &&
+            top <= box.top && box.getBottom() <= getBottom();
+    }
+
+    constexpr bool intersects(const Box<T>& box) const noexcept
+    {
+        return !(left >= box.getRight() || getRight() <= box.left ||
+            top >= box.getBottom() || getBottom() <= box.top);
+    }
+};
+
+}
\ No newline at end of file
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Pierre Vigier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,315 @@
+#pragma once
+
+#include <cassert>
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <type_traits>
+#include <vector>
+#include "Box.h"
+
+namespace quadtree
+{
+
+template<typename T, typename GetBox, typename Equal = std::equal_to<T>, typename Float = float>
+class Quadtree
+{
+    static_assert(std::is_convertible_v<std::invoke_result_t<GetBox, const T&>, Box<Float>>,
+        "GetBox must be a callable of signature Box<Float>(const T&)");
+    static_assert(std::is_convertible_v<std::invoke_result_t<Equal, const T&, const T&>, bool>,
+        "Equal must be a callable of signature bool(const T&, const T&)");
+    static_assert(std::is_arithmetic_v<Float>);
+
+public:
+    Quadtree(const Box<Float>& box, const GetBox& getBox = GetBox(),
+        const Equal& equal = Equal()) :
+        mBox(box), mRoot(std::make_unique<Node>()), mGetBox(getBox), mEqual(equal)
+    {
+
+    }
+
+    void add(const T& value)
+    {
+        add(mRoot.get(), 0, mBox, value);
+    }
+
+    void remove(const T& value)
+    {
+        remove(mRoot.get(), mBox, value);
+    }
+
+    std::vector<T> query(const Box<Float>& box) const
+    {
+        auto values = std::vector<T>();
+        query(mRoot.get(), mBox, box, values);
+        return values;
+    }
+
+    std::vector<std::pair<T, T>> findAllIntersections() const
+    {
+        auto intersections = std::vector<std::pair<T, T>>();
+        findAllIntersections(mRoot.get(), intersections);
+        return intersections;
+    }
+
+    Box<Float> getBox() const 
+    {
+        return mBox;
+    }
+    
+private:
+    static constexpr auto Threshold = std::size_t(16);
+    static constexpr auto MaxDepth = std::size_t(8);
+
+    struct Node
+    {
+        std::array<std::unique_ptr<Node>, 4> children;
+        std::vector<T> values;
+    };
+
+    Box<Float> mBox;
+    std::unique_ptr<Node> mRoot;
+    GetBox mGetBox;
+    Equal mEqual;
+
+    bool isLeaf(const Node* node) const
+    {
+        return !static_cast<bool>(node->children[0]);
+    }
+
+    Box<Float> computeBox(const Box<Float>& box, int i) const
+    {
+        auto origin = box.getTopLeft();
+        auto childSize = box.getSize() / static_cast<Float>(2);
+        switch (i)
+        {
+            // North West
+            case 0:
+                return Box<Float>(origin, childSize);
+            // Norst East
+            case 1:
+                return Box<Float>(Vector2<Float>(origin.x + childSize.x, origin.y), childSize);
+            // South West
+            case 2:
+                return Box<Float>(Vector2<Float>(origin.x, origin.y + childSize.y), childSize);
+            // South East
+            case 3:
+                return Box<Float>(origin + childSize, childSize);
+            default:
+                assert(false && "Invalid child index");
+                return Box<Float>();
+        }
+    }
+
+    int getQuadrant(const Box<Float>& nodeBox, const Box<Float>& valueBox) const
+    {
+        auto center = nodeBox.getCenter();
+        // West
+        if (valueBox.getRight() < center.x)
+        {
+            // North West
+            if (valueBox.getBottom() < center.y)
+                return 0;
+            // South West
+            else if (valueBox.top >= center.y)
+                return 2;
+            // Not contained in any quadrant
+            else
+                return -1;
+        }
+        // East
+        else if (valueBox.left >= center.x)
+        {
+            // North East
+            if (valueBox.getBottom() < center.y)
+                return 1;
+            // South East
+            else if (valueBox.top >= center.y)
+                return 3;
+            // Not contained in any quadrant
+            else
+                return -1;
+        }
+        // Not contained in any quadrant
+        else
+            return -1;
+    }
+
+    void add(Node* node, std::size_t depth, const Box<Float>& box, const T& value)
+    {
+        assert(node != nullptr);
+        assert(box.contains(mGetBox(value)));
+        if (isLeaf(node))
+        {
+            // Insert the value in this node if possible
+            if (depth >= MaxDepth || node->values.size() < Threshold)
+                node->values.push_back(value);
+            // Otherwise, we split and we try again
+            else
+            {
+                split(node, box);
+                add(node, depth, box, value);
+            }
+        }
+        else
+        {
+            auto i = getQuadrant(box, mGetBox(value));
+            // Add the value in a child if the value is entirely contained in it
+            if (i != -1)
+                add(node->children[static_cast<std::size_t>(i)].get(), depth + 1, computeBox(box, i), value);
+            // Otherwise, we add the value in the current node
+            else
+                node->values.push_back(value);
+        }
+    }
+
+    void split(Node* node, const Box<Float>& box)
+    {
+        assert(node != nullptr);
+        assert(isLeaf(node) && "Only leaves can be split");
+        // Create children
+        for (auto& child : node->children)
+            child = std::make_unique<Node>();
+        // Assign values to children
+        auto newValues = std::vector<T>(); // New values for this node
+        for (const auto& value : node->values)
+        {
+            auto i = getQuadrant(box, mGetBox(value));
+            if (i != -1)
+                node->children[static_cast<std::size_t>(i)]->values.push_back(value);
+            else
+                newValues.push_back(value);
+        }
+        node->values = std::move(newValues);
+    }
+
+    bool remove(Node* node, const Box<Float>& box, const T& value)
+    {
+        assert(node != nullptr);
+        assert(box.contains(mGetBox(value)));
+        if (isLeaf(node))
+        {
+            // Remove the value from node
+            removeValue(node, value);
+            return true;
+        }
+        else
+        {
+            // Remove the value in a child if the value is entirely contained in it
+            auto i = getQuadrant(box, mGetBox(value));
+            if (i != -1)
+            {
+                if (remove(node->children[static_cast<std::size_t>(i)].get(), computeBox(box, i), value))
+                    return tryMerge(node);
+            }
+            // Otherwise, we remove the value from the current node
+            else
+                removeValue(node, value);
+            return false;
+        }
+    }
+
+    void removeValue(Node* node, const T& value)
+    {
+        // Find the value in node->values
+        auto it = std::find_if(std::begin(node->values), std::end(node->values),
+            [this, &value](const auto& rhs){ return mEqual(value, rhs); });
+        assert(it != std::end(node->values) && "Trying to remove a value that is not present in the node");
+        // Swap with the last element and pop back
+        *it = std::move(node->values.back());
+        node->values.pop_back();
+    }
+
+    bool tryMerge(Node* node)
+    {
+        assert(node != nullptr);
+        assert(!isLeaf(node) && "Only interior nodes can be merged");
+        auto nbValues = node->values.size();
+        for (const auto& child : node->children)
+        {
+            if (!isLeaf(child.get()))
+                return false;
+            nbValues += child->values.size();
+        }
+        if (nbValues <= Threshold)
+        {
+            node->values.reserve(nbValues);
+            // Merge the values of all the children
+            for (const auto& child : node->children)
+            {
+                for (const auto& value : child->values)
+                    node->values.push_back(value);
+            }
+            // Remove the children
+            for (auto& child : node->children)
+                child.reset();
+            return true;
+        }
+        else
+            return false;
+    }
+
+    void query(Node* node, const Box<Float>& box, const Box<Float>& queryBox, std::vector<T>& values) const
+    {
+        assert(node != nullptr);
+        assert(queryBox.intersects(box));
+        for (const auto& value : node->values)
+        {
+            if (queryBox.intersects(mGetBox(value)))
+                values.push_back(value);
+        }
+        if (!isLeaf(node))
+        {
+            for (auto i = std::size_t(0); i < node->children.size(); ++i)
+            {
+                auto childBox = computeBox(box, static_cast<int>(i));
+                if (queryBox.intersects(childBox))
+                    query(node->children[i].get(), childBox, queryBox, values);
+            }
+        }
+    }
+
+    void findAllIntersections(Node* node, std::vector<std::pair<T, T>>& intersections) const
+    {
+        // Find intersections between values stored in this node
+        // Make sure to not report the same intersection twice
+        for (auto i = std::size_t(0); i < node->values.size(); ++i)
+        {
+            for (auto j = std::size_t(0); j < i; ++j)
+            {
+                if (mGetBox(node->values[i]).intersects(mGetBox(node->values[j])))
+                    intersections.emplace_back(node->values[i], node->values[j]);
+            }
+        }
+        if (!isLeaf(node))
+        {
+            // Values in this node can intersect values in descendants
+            for (const auto& child : node->children)
+            {
+                for (const auto& value : node->values)
+                    findIntersectionsInDescendants(child.get(), value, intersections);
+            }
+            // Find intersections in children
+            for (const auto& child : node->children)
+                findAllIntersections(child.get(), intersections);
+        }
+    }
+
+    void findIntersectionsInDescendants(Node* node, const T& value, std::vector<std::pair<T, T>>& intersections) const
+    {
+        // Test against the values stored in this node
+        for (const auto& other : node->values)
+        {
+            if (mGetBox(value).intersects(mGetBox(other)))
+                intersections.emplace_back(value, other);
+        }
+        // Test against values stored into descendants of this node
+        if (!isLeaf(node))
+        {
+            for (const auto& child : node->children)
+                findIntersectionsInDescendants(child.get(), value, intersections);
+        }
+    }
+};
+
+}
@@ -0,0 +1,47 @@
+#pragma once
+
+namespace quadtree
+{
+
+template<typename T>
+class Vector2
+{
+public:
+    T x;
+    T y;
+
+    constexpr Vector2<T>(T X = 0, T Y = 0) noexcept : x(X), y(Y)
+    {
+
+    }
+
+    constexpr Vector2<T>& operator+=(const Vector2<T>& other) noexcept
+    {
+        x += other.x;
+        y += other.y;
+        return *this;
+    }
+
+    constexpr Vector2<T>& operator/=(T t) noexcept
+    {
+        x /= t;
+        y /= t;
+        return *this;
+    }
+};
+
+template<typename T>
+constexpr Vector2<T> operator+(Vector2<T> lhs, const Vector2<T>& rhs) noexcept
+{
+    lhs += rhs;
+    return lhs;
+}
+
+template<typename T>
+constexpr Vector2<T> operator/(Vector2<T> vec, T t) noexcept
+{
+    vec /= t;
+    return vec;
+}
+
+}