40 files changed, 1786 insertions, 296 deletions

@@ -4,6 +4,7 @@ Archipelago init file for Lingo 2
 from typing import ClassVar
 
 from BaseClasses import ItemClassification, Item, Tutorial
+from Options import OptionError
 from settings import Group, UserFilePath
 from worlds.AutoWorld import WebWorld, World
 from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS
@@ -11,7 +12,7 @@ from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
 from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
 from .static_logic import Lingo2StaticLogic
-from ..LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
+from worlds.LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
 
 
 class Lingo2WebWorld(WebWorld):
@@ -33,6 +34,7 @@ class Lingo2Settings(Group):
         is_exe = True
 
     exe_file: ExecutableFile = ExecutableFile()
+    start_game: bool = True
 
 
 class Lingo2World(World):
@@ -75,15 +77,18 @@ class Lingo2World(World):
         if self.options.shuffle_worldports:
             if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
                 slot_value = self.multiworld.re_gen_passthrough["Lingo 2"]["port_pairings"]
-                self.port_pairings = {int(fp): int(tp) for fp, tp in slot_value.items()}
+                self.port_pairings = {
+                    self.static_logic.port_id_by_ap_id[int(fp)]: self.static_logic.port_id_by_ap_id[int(tp)]
+                    for fp, tp in slot_value.items()
+                }
 
                 connect_ports_from_ut(self.port_pairings, self)
             else:
                 shuffle_entrances(self)
 
-        from Utils import visualize_regions
+        #from Utils import visualize_regions
 
-        visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
+        #visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
 
     def create_items(self):
         pool = [self.create_item(name) for name in self.player_logic.real_items]
@@ -108,6 +113,11 @@ class Lingo2World(World):
         for i in range(0, item_difference):
             pool.append(self.create_item(self.get_filler_item_name()))
 
+        if not any(ItemClassification.progression in item.classification for item in pool):
+            raise OptionError(f"Lingo 2 player {self.player} has no progression items. Please enable at least one "
+                              f"option that would add progression gating to your world, such as Shuffle Doors or "
+                              f"Shuffle Letters.")
+
         self.multiworld.itempool += pool
 
     def create_item(self, name: str) -> Item:
@@ -123,7 +133,11 @@ class Lingo2World(World):
         slot_options = [
             "cyan_door_behavior",
             "daedalus_roof_access",
+            "enable_gift_maps",
+            "enable_icarus",
+            "endings_requirement",
             "keyholder_sanity",
+            "masteries_requirement",
             "shuffle_control_center_colors",
             "shuffle_doors",
             "shuffle_gallery_paintings",
@@ -141,7 +155,11 @@ class Lingo2World(World):
         }
 
         if self.options.shuffle_worldports:
-            slot_data["port_pairings"] = self.port_pairings
+            def get_port_ap_id(port_id):
+                return self.static_logic.objects.ports[port_id].ap_id
+
+            slot_data["port_pairings"] = {get_port_ap_id(from_id): get_port_ap_id(to_id)
+                                          for from_id, to_id in self.port_pairings.items()}
 
         return slot_data
 
@@ -0,0 +1,10 @@
+extends "res://scripts/nodes/allowNumbers.gd"
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        var item_id = gamedata.objects.get_special_ids()["Numbers"]
+        if ap.client.getItemAmount(item_id) >= 1:
+                global.allow_numbers = true
@@ -15,6 +15,11 @@ func _get_true_path(path):
                 return "lingo2/client/%s" % path
 
 
+func path_exists(path):
+        var true_path = _get_true_path(path)
+        return apworld_reader.file_exists(true_path)
+
+
 func load_script(path):
         var true_path = _get_true_path(path)
 
@@ -25,6 +25,8 @@ var _slot_data = {}
 var _accessible_locations = []
 var _accessible_worldports = []
 var _goal_accessible = false
+var _latched_doors = []
+var _hinted_locations = []
 
 signal could_not_connect
 signal connect_status
@@ -34,10 +36,13 @@ signal location_scout_received(location_id, item_name, player_name, flags, for_s
 signal text_message_received(message)
 signal item_sent_notification(message)
 signal hint_received(message)
+signal door_latched(id)
 signal accessible_locations_updated
 signal checked_locations_updated
+signal ignored_locations_updated(locations)
 signal checked_worldports_updated
 signal keyboard_update_received
+signal hinted_locations_updated
 
 
 func _init():
@@ -108,7 +113,7 @@ func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> vo
 
                         _checked_locations = []
                         for location in message["checked_locations"]:
-                                _checked_locations.append(int(message["checked_locations"]))
+                                _checked_locations.append(int(location))
 
                         client_connected.emit(_slot_data)
 
@@ -158,11 +163,7 @@ func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> vo
                 elif cmd == "LocationInfo":
                         for loc in message["locations"]:
                                 location_scout_received.emit(
-                                        int(loc["id"]),
-                                        loc["item"],
-                                        loc["player"],
-                                        int(loc["flags"]),
-                                        int(loc["for_self"])
+                                        int(loc["id"]), loc["item"], loc["player"], int(loc["flags"]), int(loc["self"])
                                 )
 
                 elif cmd == "AccessibleLocations":
@@ -187,6 +188,35 @@ func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> vo
 
                         keyboard_update_received.emit(updates)
 
+                elif cmd == "PathReply":
+                        var textclient = global.get_node("Textclient")
+                        textclient.display_logical_path(
+                                message["type"], int(message.get("id", null)), message["path"]
+                        )
+
+                elif cmd == "UpdateLatches":
+                        for id in message["latches"]:
+                                var iid = int(id)
+                                if not _latched_doors.has(iid):
+                                        _latched_doors.append(iid)
+
+                                door_latched.emit(iid)
+
+                elif cmd == "SetIgnoredLocations":
+                        var locs = []
+                        for id in message["locations"]:
+                                locs.append(int(id))
+
+                        ignored_locations_updated.emit(locs)
+
+                elif cmd == "UpdateHintedLocations":
+                        for id in message["locations"]:
+                                var iid = int(id)
+                                if !_hinted_locations.has(iid):
+                                        _hinted_locations.append(iid)
+
+                        hinted_locations_updated.emit()
+
 
 func connectToServer(server, un, pw):
         sendMessage([{"cmd": "Connect", "server": server, "player": un, "password": pw}])
@@ -253,6 +283,29 @@ func checkWorldport(port_id):
                 sendMessage([{"cmd": "CheckWorldport", "port_id": port_id}])
 
 
+func latchDoor(id):
+        if not _latched_doors.has(id):
+                _latched_doors.append(id)
+
+                sendMessage([{"cmd": "LatchDoor", "door": id}])
+
+
+func getLogicalPath(object_type, object_id):
+        var msg = {"cmd": "GetPath", "type": object_type}
+        if object_id != null:
+                msg["id"] = object_id
+
+        sendMessage([msg])
+
+
+func addIgnoredLocation(loc_id):
+        sendMessage([{"cmd": "IgnoreLocation", "id": loc_id}])
+
+
+func removeIgnoredLocation(loc_id):
+        sendMessage([{"cmd": "UnignoreLocation", "id": loc_id}])
+
+
 func sendQuit():
         sendMessage([{"cmd": "Quit"}])
 
@@ -1,7 +1,9 @@
 extends "res://scripts/nodes/door.gd"
 
+var door_id
 var item_id
 var item_amount
+var latched = false
 
 
 func _ready():
@@ -10,7 +12,7 @@ func _ready():
         )
 
         var gamedata = global.get_node("Gamedata")
-        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
         if door_id != null:
                 var ap = global.get_node("Archipelago")
                 var item_lock = ap.get_item_id_for_door(door_id)
@@ -27,6 +29,12 @@ func _ready():
                         self.excludeSenders = []
 
                         call_deferred("_readier")
+                else:
+                        var door_data = gamedata.objects.get_doors()[door_id]
+                        if door_data.has_latch() and door_data.get_latch():
+                                _check_latched.call_deferred(door_id)
+
+                                latched = true
 
         if global.map == "the_sun_temple":
                 if name == "spe_EndPlatform" or name == "spe_entry_2":
@@ -44,3 +52,24 @@ func _readier():
 
         if ap.client.getItemAmount(item_id) >= item_amount:
                 handleTriggered()
+
+
+func _check_latched(door_id):
+        var ap = global.get_node("Archipelago")
+
+        if ap.client._latched_doors.has(door_id):
+                triggered = total
+                handleTriggered()
+
+
+func handleTriggered():
+        super.handleTriggered()
+
+        if latched and ran:
+                var ap = global.get_node("Archipelago")
+                ap.client.latchDoor(door_id)
+
+
+func handleUntriggered():
+        if not latched or not ran:
+                super.handleUntriggered()
@@ -0,0 +1,32 @@
+extends CanvasLayer
+
+var _label
+
+var _disconnected = false
+
+
+func _ready():
+        _label = Label.new()
+        _label.name = "Label"
+        _label.offset_left = 20
+        _label.offset_top = 20
+        _label.horizontal_alignment = HORIZONTAL_ALIGNMENT_LEFT
+        _label.vertical_alignment = VERTICAL_ALIGNMENT_TOP
+        _label.theme = preload("res://assets/themes/baseUI.tres")
+        _label.add_theme_font_size_override("font_size", 36)
+        add_child(_label)
+
+
+func set_connection_lost(arg):
+        _disconnected = arg
+
+        _update_label()
+
+
+func _update_label():
+        var text = []
+
+        if _disconnected:
+                text.append("Disconnected from multiworld.")
+
+        _label.text = "\n".join(text)
@@ -15,6 +15,7 @@ var symbol_item_ids = []
 var anti_trap_ids = {}
 var location_name_by_id = {}
 var ending_display_name_by_name = {}
+var port_id_by_ap_id = {}
 
 var kSYMBOL_ITEMS
 
@@ -72,7 +73,13 @@ func load(data_bytes):
 
                 if door.has_ap_id():
                         door_id_by_ap_id[door.get_ap_id()] = door.get_id()
-                        location_name_by_id[door.get_ap_id()] = _get_door_location_name(door)
+
+                        if (
+                                door.get_type() == SCRIPT_proto.DoorType.STANDARD
+                                or door.get_type() == SCRIPT_proto.DoorType.LOCATION_ONLY
+                                or door.get_type() == SCRIPT_proto.DoorType.GRAVESTONE
+                        ):
+                                location_name_by_id[door.get_ap_id()] = _get_door_location_name(door)
 
         for painting in objects.get_paintings():
                 var room = objects.get_rooms()[painting.get_room_id()]
@@ -93,6 +100,9 @@ func load(data_bytes):
                 var map_data = port_id_by_map_node_path[map.get_name()]
                 map_data[port.get_path()] = port.get_id()
 
+                if port.has_ap_id():
+                        port_id_by_ap_id[port.get_ap_id()] = port.get_id()
+
         for progressive in objects.get_progressives():
                 progressive_id_by_ap_id[progressive.get_ap_id()] = progressive.get_id()
 
@@ -166,8 +176,7 @@ func get_door_ap_id(door_id):
 
 func get_door_map_name(door_id):
         var door = objects.get_doors()[door_id]
-        var room = objects.get_rooms()[door.get_room_id()]
-        var map = objects.get_maps()[room.get_map_id()]
+        var map = objects.get_maps()[door.get_map_id()]
         return map.get_name()
 
 
@@ -216,7 +225,11 @@ func _get_generated_door_location_name(door):
         if door.get_type() != SCRIPT_proto.DoorType.STANDARD:
                 return null
 
-        if door.get_keyholders().size() > 0 or door.get_endings().size() > 0 or door.has_complete_at():
+        if (
+                door.get_keyholders().size() > 0
+                or (door.has_white_ending() and door.get_white_ending())
+                or door.has_complete_at()
+        ):
                 return null
 
         if door.get_panels().size() > 4:
@@ -227,8 +240,11 @@ func _get_generated_door_location_name(door):
                 var panel = objects.get_panels()[panel_id.get_panel()]
                 var panel_room = objects.get_rooms()[panel.get_room_id()]
                 # It's okay if panel_display_name is not present because then it's coalesced with other unnamed areas.
-                if not map_areas.has(panel_room.get_panel_display_name()):
-                        map_areas.append(panel_room.get_panel_display_name())
+                var panel_display_name = ""
+                if panel_room.has_panel_display_name():
+                        panel_display_name = panel_room.get_panel_display_name()
+                if not map_areas.has(panel_display_name):
+                        map_areas.append(panel_display_name)
 
         if map_areas.size() > 1:
                 return null
@@ -264,7 +280,7 @@ func _get_generated_door_location_name(door):
 
 
 func _get_letter_location_name(letter):
-        var letter_level = 2 if letter.get_level2() else 1
+        var letter_level = 2 if (letter.has_level2() and letter.get_level2()) else 1
         var letter_name = "%s%d" % [letter.get_key().to_upper(), letter_level]
         return "%s - %s" % [_get_room_object_map_name(letter), letter_name]
 
@@ -6,3 +6,5 @@ func reset():
         var was_removed = ap.keyboard.reset_keyholders()
         if was_removed:
                 sfxPlayer.sfx_play("pickup")
+        
+        ap.client.requestSync()
@@ -191,9 +191,6 @@ func load_keyholders(map):
 
 
 func reset_keyholders():
-        if letters_in_keyholders.is_empty() and letters_blocked.is_empty():
-                return false
-
         var cleared_anything = not letters_in_keyholders.is_empty() or not letters_blocked.is_empty()
 
         if keyholder_state.has(global.map):
@@ -36,6 +36,7 @@ func _ready():
                 global.add_child(ap_instance)
 
                 # Let's also inject any scripts we need to inject now.
+                installScriptExtension(runtime.load_script("allowNumbers.gd"))
                 installScriptExtension(runtime.load_script("animationListener.gd"))
                 installScriptExtension(runtime.load_script("collectable.gd"))
                 installScriptExtension(runtime.load_script("door.gd"))
@@ -43,12 +44,14 @@ func _ready():
                 installScriptExtension(runtime.load_script("keyHolderChecker.gd"))
                 installScriptExtension(runtime.load_script("keyHolderResetterListener.gd"))
                 installScriptExtension(runtime.load_script("painting.gd"))
+                installScriptExtension(runtime.load_script("paintingAuto.gd"))
                 installScriptExtension(runtime.load_script("panel.gd"))
                 installScriptExtension(runtime.load_script("pauseMenu.gd"))
                 installScriptExtension(runtime.load_script("player.gd"))
                 installScriptExtension(runtime.load_script("saver.gd"))
                 installScriptExtension(runtime.load_script("teleport.gd"))
                 installScriptExtension(runtime.load_script("teleportListener.gd"))
+                installScriptExtension(runtime.load_script("unlockReaderListener.gd"))
                 installScriptExtension(runtime.load_script("visibilityListener.gd"))
                 installScriptExtension(runtime.load_script("worldport.gd"))
                 installScriptExtension(runtime.load_script("worldportListener.gd"))
@@ -66,6 +69,11 @@ func _ready():
                 messages_instance.SCRIPT_rainbowText = runtime.load_script("rainbowText.gd")
                 global.add_child(messages_instance)
 
+                var effects_script = runtime.load_script("effects.gd")
+                var effects_instance = effects_script.new()
+                effects_instance.name = "Effects"
+                global.add_child(effects_instance)
+
                 var textclient_script = runtime.load_script("textclient.gd")
                 var textclient_instance = textclient_script.new()
                 textclient_instance.name = "Textclient"
@@ -77,6 +85,13 @@ func _ready():
                 compass_overlay_instance.SCRIPT_compass = runtime.load_script("compass.gd")
                 global.add_child(compass_overlay_instance)
 
+                unlocks.data["advanced_mastery"] = ""
+                unlocks.data["charismatic_mastery"] = ""
+                unlocks.data["crystalline_mastery"] = ""
+                unlocks.data["fuzzy_mastery"] = ""
+                unlocks.data["icarus_mastery"] = ""
+                unlocks.data["stellar_mastery"] = ""
+
         var ap = global.get_node("Archipelago")
         var gamedata = global.get_node("Gamedata")
         ap.ap_connected.connect(connectionSuccessful)
@@ -218,11 +233,11 @@ func startGame():
 
         unlocks.resetCollectables()
         unlocks.resetData()
+        unlocks.loadCollectables()
+        unlocks.loadData()
 
         ap.setup_keys()
 
-        unlocks.loadCollectables()
-        unlocks.loadData()
         unlocks.unlockKey("capslock", 1)
 
         if ap.shuffle_worldports:
@@ -231,6 +246,7 @@ func startGame():
                 settings.worldport_fades = "never"
 
         clearResourceCache("res://objects/meshes/gridDoor.tscn")
+        clearResourceCache("res://objects/nodes/allowNumbers.tscn")
         clearResourceCache("res://objects/nodes/collectable.tscn")
         clearResourceCache("res://objects/nodes/door.tscn")
         clearResourceCache("res://objects/nodes/keyHolder.tscn")
@@ -238,6 +254,7 @@ func startGame():
         clearResourceCache("res://objects/nodes/listeners/keyHolderChecker.tscn")
         clearResourceCache("res://objects/nodes/listeners/keyHolderResetterListener.tscn")
         clearResourceCache("res://objects/nodes/listeners/teleportListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/unlockReaderListener.tscn")
         clearResourceCache("res://objects/nodes/listeners/visibilityListener.tscn")
         clearResourceCache("res://objects/nodes/listeners/worldportListener.tscn")
         clearResourceCache("res://objects/nodes/panel.tscn")
@@ -274,6 +291,9 @@ func versionMismatchDeclined():
         get_node("../Panel/AcceptDialog").hide()
         get_node("../Panel/connect_button").disabled = false
 
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+
 
 func historySelected(index):
         var ap = global.get_node("Archipelago")
@@ -28,6 +28,9 @@ var _item_locks = {}
 var _inverse_item_locks = {}
 var _held_letters = {}
 var _letters_setup = false
+var _already_connected = false
+var _ignored_locations = []
+var _map_scripts = {}
 
 const kSHUFFLE_LETTERS_VANILLA = 0
 const kSHUFFLE_LETTERS_UNLOCKED = 1
@@ -62,7 +65,11 @@ const kEndingNameByVictoryValue = {
 var apworld_version = [0, 0, 0]
 var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
 var daedalus_roof_access = false
+var enable_gift_maps = []
+var enable_icarus = false
+var endings_requirement = 0
 var keyholder_sanity = false
+var masteries_requirement = 0
 var port_pairings = {}
 var shuffle_control_center_colors = false
 var shuffle_doors = false
@@ -74,6 +81,8 @@ var strict_cyan_ending = false
 var strict_purple_ending = false
 var victory_condition = -1
 
+var color_by_material_path = {}
+
 signal could_not_connect
 signal connect_status
 signal ap_connected
@@ -111,6 +120,20 @@ func _init():
                 if data.size() > 6:
                         show_minimap = data[6]
 
+        # We need to create a mapping from material paths to the original colors of
+        # those materials. We force reload the materials, overwriting any custom
+        # textures, and create the mapping. We then reload the textures in case the
+        # player had a custom one enabled.
+        var directory = DirAccess.open("res://assets/materials")
+        for material_name in directory.get_files():
+                var material = ResourceLoader.load(
+                        "res://assets/materials/" + material_name, "", ResourceLoader.CACHE_MODE_REPLACE
+                )
+
+                color_by_material_path[material.resource_path] = Color(material.albedo_color)
+
+        settings.load_user_textures()
+
 
 func _ready():
         client = SCRIPT_client.new()
@@ -123,7 +146,10 @@ func _ready():
         client.hint_received.connect(_process_hint_received)
         client.accessible_locations_updated.connect(_on_accessible_locations_updated)
         client.checked_locations_updated.connect(_on_checked_locations_updated)
+        client.ignored_locations_updated.connect(_on_ignored_locations_updated)
+        client.hinted_locations_updated.connect(_on_hinted_locations_updated)
         client.checked_worldports_updated.connect(_on_checked_worldports_updated)
+        client.door_latched.connect(_on_door_latched)
 
         client.could_not_connect.connect(_client_could_not_connect)
         client.connect_status.connect(_client_connect_status)
@@ -178,6 +204,7 @@ func connectToServer():
         _location_scouts = {}
         _letters_setup = false
         _held_letters = {}
+        _already_connected = false
 
         client.connectToServer(ap_server, ap_user, ap_pass)
 
@@ -187,6 +214,11 @@ func getSaveFileName():
 
 
 func disconnect_from_ap():
+        _already_connected = false
+
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
         client.disconnect_from_ap()
 
 
@@ -230,6 +262,12 @@ func _process_item(item, amount):
                 if player != null:
                         player.evaluate_solvability.emit()
 
+        if item_id == gamedata.objects.get_special_ids()["A Job Well Done"]:
+                update_job_well_done_sign()
+
+        if item_id == gamedata.objects.get_special_ids()["Numbers"] and global.map == "the_fuzzy":
+                global.allow_numbers = true
+
         # Show a message about the item if it's new.
         if int(item["index"]) > _last_new_item:
                 _last_new_item = int(item["index"])
@@ -340,7 +378,7 @@ func _on_accessible_locations_updated():
 func _on_checked_locations_updated():
         var textclient_node = global.get_node("Textclient")
         if textclient_node != null:
-                textclient_node.update_locations()
+                textclient_node.update_locations(false)
 
 
 func _on_checked_worldports_updated():
@@ -350,15 +388,60 @@ func _on_checked_worldports_updated():
                 textclient_node.update_worldports()
 
 
+func _on_ignored_locations_updated(locations):
+        _ignored_locations = locations
+
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_hinted_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_door_latched(door_id):
+        var gamedata = global.get_node("Gamedata")
+        if gamedata.get_door_map_name(door_id) != global.map:
+                return
+
+        var receivers = gamedata.get_door_receivers(door_id)
+        var scene = get_tree().get_root().get_node_or_null("scene")
+        if scene != null:
+                for receiver in receivers:
+                        var rnode = scene.get_node_or_null(receiver)
+                        if rnode != null:
+                                rnode.handleTriggered()
+
+
 func _client_could_not_connect(message):
         could_not_connect.emit(message)
 
+        if global.loaded:
+                var effects = global.get_node("Effects")
+                effects.set_connection_lost(true)
+
+                var messages = global.get_node("Messages")
+                messages.showMessage("Connection to multiworld lost.")
+
 
 func _client_connect_status(message):
         connect_status.emit(message)
 
 
 func _client_connected(slot_data):
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
+        if _already_connected:
+                var messages = global.get_node("Messages")
+                messages.showMessage("Reconnected to multiworld!")
+                return
+
+        _already_connected = true
+
         var gamedata = global.get_node("Gamedata")
 
         _localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
@@ -381,7 +464,11 @@ func _client_connected(slot_data):
         # Read slot data.
         cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
         daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
+        enable_gift_maps = slot_data.get("enable_gift_maps", [])
+        enable_icarus = bool(slot_data.get("enable_icarus", false))
+        endings_requirement = int(slot_data.get("endings_requirement", 0))
         keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
+        masteries_requirement = int(slot_data.get("masteries_requirement", 0))
         shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
         shuffle_doors = bool(slot_data.get("shuffle_doors", false))
         shuffle_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false))
@@ -403,7 +490,9 @@ func _client_connected(slot_data):
                 var raw_pp = slot_data.get("port_pairings")
 
                 for p1 in raw_pp.keys():
-                        port_pairings[int(p1)] = int(raw_pp[p1])
+                        port_pairings[gamedata.port_id_by_ap_id[int(p1)]] = gamedata.port_id_by_ap_id[int(
+                                raw_pp[p1]
+                        )]
 
         # Set up item locks.
         _item_locks = {}
@@ -479,6 +568,9 @@ func start_batching_locations():
 
 
 func send_location(loc_id):
+        if client._checked_locations.has(loc_id):
+                return
+
         if _batch_locations:
                 _held_locations.append(loc_id)
         else:
@@ -577,3 +669,49 @@ func _process_key_item(key, level):
                 level += 1
 
         keyboard.collect_remote_letter(key, level)
+
+
+func update_job_well_done_sign():
+        if global.map != "daedalus":
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        var job_item = gamedata.objects.get_special_ids()["A Job Well Done"]
+        var jobs_done = client.getItemAmount(job_item)
+
+        var sign2 = get_tree().get_root().get_node_or_null("scene/Meshes/Miscellaneous/sign2")
+        var sign3 = get_tree().get_root().get_node_or_null("scene/Meshes/Miscellaneous/sign3")
+
+        if sign2 != null and sign3 != null:
+                if jobs_done == 0:
+                        sign2.text = "what are you doing"
+                        sign3.text = "?"
+                elif jobs_done == 1:
+                        sign2.text = "a job well done"
+                        sign3.text = "is its own reward"
+                else:
+                        sign2.text = "%d jobs well done" % jobs_done
+                        sign3.text = "are their own reward"
+
+                sign2.get_node("MeshInstance3D").mesh.text = sign2.text
+                sign3.get_node("MeshInstance3D").mesh.text = sign3.text
+
+
+func toggle_ignored_location(loc_id):
+        if loc_id in _ignored_locations:
+                client.removeIgnoredLocation(loc_id)
+        else:
+                client.addIgnoredLocation(loc_id)
+
+
+func get_map_script(map_name):
+        if !_map_scripts.has(map_name):
+                var runtime = global.get_node("Runtime")
+                var script_path = "maps/%s.gd" % map_name
+                if runtime.path_exists(script_path):
+                        var script = runtime.load_script(script_path)
+                        _map_scripts[map_name] = script.new()
+                else:
+                        _map_scripts[map_name] = null
+
+        return _map_scripts[map_name]
@@ -0,0 +1,85 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Remove the door blocking the trophy case.
+        root.get_node("/root/scene/Components/Doors/entry_18").queue_free()
+
+        # Set up mastery listeners for extra maps.
+        _set_up_mastery_listener(root, "advanced")
+        _set_up_mastery_listener(root, "charismatic")
+        _set_up_mastery_listener(root, "crystalline")
+        _set_up_mastery_listener(root, "fuzzy")
+        _set_up_mastery_listener(root, "icarus")
+        _set_up_mastery_listener(root, "stellar")
+
+        if ap.endings_requirement != 12 or ap.masteries_requirement != 0:
+                # Set up listeners for the potential White Ending requirements.
+                var merging_prefab = preload("res://objects/nodes/listeners/mergingListener.tscn")
+
+                var old_door = root.get_node("/root/scene/Components/Doors/entry_19")
+                var new_door = old_door.duplicate()
+                new_door.name = "entry_19_new"
+                new_door.senders.clear()
+                new_door.senderGroup.clear()
+                new_door.excludeSenders.clear()
+
+                if ap.endings_requirement == 12:
+                        new_door.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/Listeners"))
+                elif ap.endings_requirement > 0:
+                        if ap.masteries_requirement == 0:
+                                new_door.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/Listeners"))
+                                new_door.complete_at = ap.endings_requirement
+                        else:
+                                var endings_merge = merging_prefab.instantiate()
+                                endings_merge.name = "EndingsMerge"
+                                endings_merge.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/Listeners"))
+                                endings_merge.complete_at = ap.endings_requirement
+                                root.get_node("/root/scene/Components").add_child.call_deferred(endings_merge)
+                                new_door.senders.append(NodePath("/root/scene/Components/EndingsMerge"))
+
+                var max_masteries = 13 + ap.enable_gift_maps.size()
+                if ap.enable_icarus:
+                        max_masteries += 1
+
+                if ap.masteries_requirement == max_masteries:
+                        new_door.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/MasteryListeners"))
+                        new_door.excludeSenders.append(
+                                NodePath("/root/scene/Meshes/Trophies/MasteryListeners/unlockReaderListenerWhite")
+                        )
+                elif ap.masteries_requirement > 0:
+                        if ap.endings_requirement == 0:
+                                new_door.senderGroup.append(
+                                        NodePath("/root/scene/Meshes/Trophies/MasteryListeners")
+                                )
+                                new_door.excludeSenders.append(
+                                        NodePath(
+                                                "/root/scene/Meshes/Trophies/MasteryListeners/unlockReaderListenerWhite"
+                                        )
+                                )
+                                new_door.complete_at = ap.masteries_requirement
+                        else:
+                                var masteries_merge = merging_prefab.instantiate()
+                                masteries_merge.name = "MasteriesMerge"
+                                masteries_merge.senderGroup.append(
+                                        NodePath("/root/scene/Meshes/Trophies/MasteryListeners")
+                                )
+                                masteries_merge.excludeSenders.append(
+                                        NodePath(
+                                                "/root/scene/Meshes/Trophies/MasteryListeners/unlockReaderListenerWhite"
+                                        )
+                                )
+                                masteries_merge.complete_at = ap.masteries_requirement
+                                root.get_node("/root/scene/Components").add_child.call_deferred(masteries_merge)
+                                new_door.senders.append(NodePath("/root/scene/Components/MasteriesMerge"))
+
+                old_door.queue_free()
+                root.get_node("/root/scene/Components/Doors").add_child.call_deferred(new_door)
+
+
+func _set_up_mastery_listener(root, name):
+        var prefab = preload("res://objects/nodes/listeners/unlockReaderListener.tscn")
+        var url = prefab.instantiate()
+        url.name = "unlockReaderListenerMastery_%s" % name
+        url.key = "%s_mastery" % name
+        url.value = "unlocked"
+        root.get_node("/root/scene/Meshes/Trophies/MasteryListeners").add_child.call_deferred(url)
@@ -0,0 +1,85 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Teleport the direction panels when the stairs are there.
+        var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+
+        var dir1 = root.get_node("/root/scene/Panels/Castle Entrance/castle_direction_1")
+        var dir1_tpl = tpl_prefab.instantiate()
+        dir1_tpl.target_path = dir1
+        dir1_tpl.teleport_point = Vector3(59.5, 8, -6.5)
+        dir1_tpl.teleport_rotate = Vector3(-45, 0, 0)
+        dir1_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_south"))
+        dir1_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_north"))
+        dir1_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_west"))
+        dir1.add_child.call_deferred(dir1_tpl)
+
+        var dir2 = root.get_node("/root/scene/Panels/Castle Entrance/castle_direction_2")
+        var dir2_tpl = tpl_prefab.instantiate()
+        dir2_tpl.target_path = dir2
+        dir2_tpl.teleport_point = Vector3(59.5, 8, 6.5)
+        dir2_tpl.teleport_rotate = Vector3(-45, -180, 0)
+        dir2_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_south"))
+        dir2_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_north"))
+        dir2_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_west"))
+        dir2.add_child.call_deferred(dir2_tpl)
+
+        var dir3 = root.get_node("/root/scene/Panels/Castle Entrance/castle_direction_3")
+        var dir3_tpl = tpl_prefab.instantiate()
+        dir3_tpl.target_path = dir3
+        dir3_tpl.teleport_point = Vector3(54, 8, 0)
+        dir3_tpl.teleport_rotate = Vector3(-45, 90, 0)
+        dir3_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_south"))
+        dir3_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_north"))
+        dir3_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_west"))
+        dir3.add_child.call_deferred(dir3_tpl)
+
+        # Block off roof access in Daedalus.
+        if not ap.daedalus_roof_access:
+                _set_up_invis_wall(root, 75.5, 11, -24.5, 1, 10, 49)
+                _set_up_invis_wall(root, 51.5, 11, -17, 16, 10, 1)
+                _set_up_invis_wall(root, 46, 10, -9.5, 1, 10, 10)
+                _set_up_invis_wall(root, 67.5, 11, 17, 16, 10, 1)
+                _set_up_invis_wall(root, 50.5, 11, 14, 10, 10, 1)
+                _set_up_invis_wall(root, 39, 10, 18.5, 1, 10, 22)
+                _set_up_invis_wall(root, 20, 15, 18.5, 1, 10, 16)
+                _set_up_invis_wall(root, 11.5, 15, 3, 32, 10, 1)
+                _set_up_invis_wall(root, 11.5, 16, -20, 14, 20, 1)
+                _set_up_invis_wall(root, 14, 16, -26.5, 1, 20, 4)
+                _set_up_invis_wall(root, 28.5, 20.5, -26.5, 1, 15, 25)
+                _set_up_invis_wall(root, 40.5, 20.5, -11, 30, 15, 1)
+                _set_up_invis_wall(root, 50.5, 15, 5.5, 7, 10, 1)
+                _set_up_invis_wall(root, 83.5, 33.5, 5.5, 1, 7, 11)
+                _set_up_invis_wall(root, 83.5, 33.5, -5.5, 1, 7, 11)
+
+                var warp_exit_prefab = preload("res://objects/nodes/exit.tscn")
+                var warp_exit = warp_exit_prefab.instantiate()
+                warp_exit.name = "roof_access_blocker_warp_exit"
+                warp_exit.position = Vector3(58, 10, 0)
+                warp_exit.rotation_degrees.y = 90
+                root.get_node("/root/scene").add_child.call_deferred(warp_exit)
+
+                var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn")
+                var warp_enter = warp_enter_prefab.instantiate()
+                warp_enter.target = warp_exit
+                warp_enter.position = Vector3(76.5, 30, 1)
+                warp_enter.scale = Vector3(4, 1.5, 1)
+                warp_enter.rotation_degrees.y = 90
+                root.get_node("/root/scene").add_child.call_deferred(warp_enter)
+
+
+func _set_up_invis_wall(root, x, y, z, sx, sy, sz):
+        var prefab = preload("res://objects/nodes/block.tscn")
+        var newwall = prefab.instantiate()
+        newwall.position.x = x
+        newwall.position.y = y
+        newwall.position.z = z
+        newwall.scale.x = sz
+        newwall.scale.y = sy
+        newwall.scale.z = sx
+        newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material"))
+        newwall.visibility_range_end = 3
+        newwall.visibility_range_end_margin = 1
+        newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF
+        newwall.skeleton = ".."
+        root.get_node("/root/scene").add_child.call_deferred(newwall)
@@ -0,0 +1,38 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Add the mastery to Icarus.
+        if ap.enable_icarus:
+                var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+                var saver_prefab = preload("res://objects/nodes/saver.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+                var mastery = collectable_prefab.instantiate()
+                mastery.name = "collectable"
+                mastery.position = Vector3(0, -2000, 0)
+                mastery.unlock_type = "smiley"
+                mastery.material_override = load("res://assets/materials/gold.material")
+                root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+                var tpl = tpl_prefab.instantiate()
+                tpl.teleport_point = Vector3(56.25, 0, -5.5)
+                tpl.teleport_rotate = Vector3(0, 0, 0)
+                tpl.target_path = mastery
+                tpl.name = "Teleport"
+                tpl.senderGroup.append(NodePath("/root/scene/Panels"))
+                tpl.nested = true
+                mastery.add_child.call_deferred(tpl)
+
+                var usl = usl_prefab.instantiate()
+                usl.name = "unlockSetterListenerMastery"
+                usl.key = "icarus_mastery"
+                usl.value = "unlocked"
+                usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+                root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+                var saver = saver_prefab.instantiate()
+                saver.name = "saver_collectables"
+                saver.type = "collectables"
+                saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+                root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,36 @@
+func on_map_load(root):
+        # Add the mastery to The Advanced.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(0, -200, -5)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var tpl = tpl_prefab.instantiate()
+        tpl.teleport_point = Vector3(0, 2, -5)
+        tpl.teleport_rotate = Vector3(0, 0, 0)
+        tpl.target_path = mastery
+        tpl.name = "Teleport"
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_29"))
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_30"))
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_31"))
+        mastery.add_child.call_deferred(tpl)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "advanced_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,26 @@
+func on_map_load(root):
+        # Add the mastery to The Charismatic.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(-17, 2, -29)
+        mastery.rotation_degrees = Vector3(0, 45, 0)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "charismatic_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,34 @@
+func on_map_load(root):
+        # Add the mastery to The Crystalline.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(0, 13, 37)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var tpl = tpl_prefab.instantiate()
+        tpl.teleport_point = Vector3(0, 11.5, -20)
+        tpl.teleport_rotate = Vector3(0, 0, 180)
+        tpl.target_path = mastery
+        tpl.name = "Teleport"
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_3"))
+        mastery.add_child.call_deferred(tpl)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "crystalline_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,156 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Remove door behind X1.
+        var door_node = root.get_node("/root/scene/Components/Doors/exit_1")
+        door_node.handleTriggered()
+
+        # Display win condition.
+        var sign_prefab = preload("res://objects/nodes/sign.tscn")
+        var sign1 = sign_prefab.instantiate()
+        sign1.position = Vector3(-7, 5, -15.01)
+        sign1.text = "victory"
+        root.get_node("/root/scene").add_child.call_deferred(sign1)
+
+        var sign2 = sign_prefab.instantiate()
+        sign2.position = Vector3(-7, 4, -15.01)
+        sign2.text = "%s ending" % ap.kEndingNameByVictoryValue.get(ap.victory_condition, "?")
+
+        var sign2_color = ap.kEndingNameByVictoryValue.get(ap.victory_condition, "coral").to_lower()
+        if sign2_color == "white":
+                sign2_color = "silver"
+
+        sign2.material = load("res://assets/materials/%s.material" % sign2_color)
+        root.get_node("/root/scene").add_child.call_deferred(sign2)
+
+        # Add the gift map entry panel if needed.
+        if not ap.enable_gift_maps.is_empty():
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var wpl_prefab = preload("res://objects/nodes/listeners/worldportListener.tscn")
+
+                var giftmap_parent = Node.new()
+                giftmap_parent.name = "GiftMapEntrance"
+                root.get_node("/root/scene/Components").add_child.call_deferred(giftmap_parent)
+
+                var symbolless_player = ""
+                for i in range(ap.client.ap_user.length()):
+                        if "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".contains(
+                                ap.client.ap_user[i]
+                        ):
+                                symbolless_player = symbolless_player + ap.client.ap_user[i].to_lower()
+
+                var giftmap_panel = panel_prefab.instantiate()
+                giftmap_panel.name = "Panel"
+                giftmap_panel.position = Vector3(33.5, -190, 5.5)
+                giftmap_panel.rotation_degrees = Vector3(-45, 0, 0)
+                giftmap_panel.clue = "player"
+                giftmap_panel.answer = symbolless_player
+
+                if ap.enable_gift_maps.has("The Advanced"):
+                        var icely_panel = panel_prefab.instantiate()
+                        icely_panel.name = "IcelyPanel"
+                        icely_panel.answer = "icely"
+                        icely_panel.position = Vector3(33.5, -200, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../IcelyPanel"))
+                        giftmap_parent.add_child.call_deferred(icely_panel)
+
+                        var icely_wpl = wpl_prefab.instantiate()
+                        icely_wpl.name = "IcelyWpl"
+                        icely_wpl.exit = "the_advanced"
+                        icely_wpl.senders.append(NodePath("../IcelyPanel"))
+                        giftmap_parent.add_child.call_deferred(icely_wpl)
+
+                if ap.enable_gift_maps.has("The Charismatic"):
+                        var souvey_panel = panel_prefab.instantiate()
+                        souvey_panel.name = "SouveyPanel"
+                        souvey_panel.answer = "souvey"
+                        souvey_panel.position = Vector3(33.5, -210, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../SouveyPanel"))
+                        giftmap_parent.add_child.call_deferred(souvey_panel)
+
+                        var souvey_wpl = wpl_prefab.instantiate()
+                        souvey_wpl.name = "SouveyWpl"
+                        souvey_wpl.exit = "the_charismatic"
+                        souvey_wpl.senders.append(NodePath("../SouveyPanel"))
+                        giftmap_parent.add_child.call_deferred(souvey_wpl)
+
+                if ap.enable_gift_maps.has("The Crystalline"):
+                        var q_panel = panel_prefab.instantiate()
+                        q_panel.name = "QPanel"
+                        q_panel.answer = "q"
+                        q_panel.position = Vector3(33.5, -220, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../QPanel"))
+                        giftmap_parent.add_child.call_deferred(q_panel)
+
+                        var q_wpl = wpl_prefab.instantiate()
+                        q_wpl.name = "QWpl"
+                        q_wpl.exit = "the_crystalline"
+                        q_wpl.senders.append(NodePath("../QPanel"))
+                        giftmap_parent.add_child.call_deferred(q_wpl)
+
+                if ap.enable_gift_maps.has("The Fuzzy"):
+                        var gongus_panel = panel_prefab.instantiate()
+                        gongus_panel.name = "GongusPanel"
+                        gongus_panel.answer = "gongus"
+                        gongus_panel.position = Vector3(33.5, -260, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../GongusPanel"))
+                        giftmap_parent.add_child.call_deferred(gongus_panel)
+
+                        var kiwi_panel = panel_prefab.instantiate()
+                        kiwi_panel.name = "KiwiPanel"
+                        kiwi_panel.answer = "kiwi"
+                        kiwi_panel.position = Vector3(33.5, -270, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../KiwiPanel"))
+                        giftmap_parent.add_child.call_deferred(kiwi_panel)
+
+                        var fuzzy_wpl = wpl_prefab.instantiate()
+                        fuzzy_wpl.name = "FuzzyWpl"
+                        fuzzy_wpl.exit = "the_fuzzy"
+                        fuzzy_wpl.senders.append(NodePath("../GongusPanel"))
+                        fuzzy_wpl.senders.append(NodePath("../KiwiPanel"))
+                        fuzzy_wpl.complete_at = 1
+                        giftmap_parent.add_child.call_deferred(fuzzy_wpl)
+
+                if ap.enable_gift_maps.has("The Stellar"):
+                        var hatkirby_panel = panel_prefab.instantiate()
+                        hatkirby_panel.name = "HatkirbyPanel"
+                        hatkirby_panel.answer = "hatkirby"
+                        hatkirby_panel.position = Vector3(33.5, -230, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../HatkirbyPanel"))
+                        giftmap_parent.add_child.call_deferred(hatkirby_panel)
+
+                        var kirby_panel = panel_prefab.instantiate()
+                        kirby_panel.name = "KirbyPanel"
+                        kirby_panel.answer = "kirby"
+                        kirby_panel.position = Vector3(33.5, -240, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../KirbyPanel"))
+                        giftmap_parent.add_child.call_deferred(kirby_panel)
+
+                        var star_panel = panel_prefab.instantiate()
+                        star_panel.name = "StarPanel"
+                        star_panel.answer = "star"
+                        star_panel.position = Vector3(33.5, -250, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../StarPanel"))
+                        giftmap_parent.add_child.call_deferred(star_panel)
+
+                        var stellar_wpl = wpl_prefab.instantiate()
+                        stellar_wpl.name = "StellarWpl"
+                        stellar_wpl.exit = "the_stellar"
+                        stellar_wpl.senders.append(NodePath("../HatkirbyPanel"))
+                        stellar_wpl.senders.append(NodePath("../KirbyPanel"))
+                        stellar_wpl.senders.append(NodePath("../StarPanel"))
+                        stellar_wpl.complete_at = 1
+                        giftmap_parent.add_child.call_deferred(stellar_wpl)
+
+                giftmap_parent.add_child.call_deferred(giftmap_panel)
+
+                var giftmap_tpl = tpl_prefab.instantiate()
+                giftmap_tpl.name = "PanelTeleporter"
+                giftmap_tpl.teleport_point = Vector3(33.5, 1, 5.5)
+                giftmap_tpl.teleport_rotate = Vector3(-45, 0, 0)
+                giftmap_tpl.target_path = giftmap_panel
+                giftmap_tpl.senders.append(
+                        NodePath("/root/scene/Components/Listeners/unlockReaderListenerDoubles")
+                )
+                giftmap_parent.add_child.call_deferred(giftmap_tpl)
@@ -0,0 +1,25 @@
+func on_map_load(root):
+        # Add the mastery to The Fuzzy.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(0, 2, -20)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "fuzzy_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,51 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Add the strict cyan ending validation.
+        if ap.strict_cyan_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = "."
+                        panel.answer = "%s%s" % [word, word]
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, -11)
+                        tpl.teleport_rotate = Vector3(-45, 0, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senderGroup.append(NodePath("/root/scene/Panels/Rulers"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        root.get_node("/root/scene/Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the door that usually waits on the rulers. We can't set the
+                # senders here for some reason so we actually set them in the door ready
+                # function.
+                var entry1 = root.get_node("/root/scene/Components/Doors/entry_1")
+                var entry12 = entry1.duplicate()
+                entry12.name = "spe_entry_1"
+                entry1.get_parent().add_child.call_deferred(entry12)
+                entry1.queue_free()
@@ -0,0 +1,4 @@
+func on_map_load(root):
+        # Move the Plaza RTE trigger outside of the turtle.
+        var rte_trigger = root.get_node("/root/scene/Components/Warps/triggerArea")
+        rte_trigger.position.z = 0
@@ -0,0 +1,30 @@
+func on_map_load(root):
+        # Add the mastery to The Stellar.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var collectables = Node.new()
+        collectables.name = "Collectables"
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(2, 2, -31)
+        mastery.rotation_degrees = Vector3(0, 90, 0)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        collectables.add_child.call_deferred(mastery)
+        root.get_node("/root/scene/Components").add_child.call_deferred(collectables)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "stellar_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,56 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Add the strict purple ending validation.
+        if ap.strict_purple_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = ""
+                        panel.answer = word
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, 0)
+                        tpl.teleport_rotate = Vector3(-45, 180, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senders.append(NodePath("/root/scene/Panels/End/panel_24"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        root.get_node("/root/scene/Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the doors that usually wait on EQUINOX. We can't set the senders
+                # here for some reason so we actually set them in the door ready function.
+                var endplat = root.get_node("/root/scene/Components/Doors/EndPlatform")
+                var endplat2 = endplat.duplicate()
+                endplat2.name = "spe_EndPlatform"
+                endplat.get_parent().add_child.call_deferred(endplat2)
+                endplat.queue_free()
+
+                var entry2 = root.get_node("/root/scene/Components/Doors/entry_2")
+                var entry22 = entry2.duplicate()
+                entry22.name = "spe_entry_2"
+                entry2.get_parent().add_child.call_deferred(entry22)
+                entry2.queue_free()
@@ -0,0 +1,4 @@
+func on_map_load(root):
+        # Prevent the COLOR panel from disappearing.
+        var color_tpl = root.get_node("/root/scene/Panels/Assorted/panel_1/teleportListener")
+        color_tpl.target_path = color_tpl
@@ -0,0 +1,5 @@
+func on_map_load(root):
+        # Shrink the painting trigger in The Unyielding.
+        var trigger_area = root.get_node("/root/scene/Components/PaintingUnlocker/triggerArea")
+        trigger_area.position = Vector3(0, 0, -6)
+        trigger_area.scale = Vector3(6, 1, 6)
@@ -126,6 +126,7 @@ func _process(_delta):
 
 
 func _renderMap(gridmap):
+        var ap = global.get_node("Archipelago")
         var heights = {}
 
         var rendered = Image.create_empty(cell_width, cell_height, false, Image.FORMAT_RGBA8)
@@ -133,7 +134,7 @@ func _renderMap(gridmap):
 
         var meshes_node = get_tree().get_root().get_node("scene/Meshes")
         if meshes_node != null:
-                _renderMeshNode(gridmap, meshes_node, rendered)
+                _renderMeshNode(ap, gridmap, meshes_node, rendered)
 
         for pos in gridmap.get_used_cells():
                 var in_plane = Vector2i(pos.x, pos.z)
@@ -146,20 +147,22 @@ func _renderMap(gridmap):
                 var cell_item = gridmap.get_cell_item(pos)
                 var mesh = gridmap.mesh_library.get_item_mesh(cell_item)
                 var material = mesh.surface_get_material(0)
-                var color = material.albedo_color
+                var color = ap.color_by_material_path.get(material.resource_path, Color.TRANSPARENT)
 
                 rendered.set_pixel(pos.x - cell_left, pos.z - cell_top, color)
 
         return rendered
 
 
-func _renderMeshNode(gridmap, mesh, rendered):
+func _renderMeshNode(ap, gridmap, mesh, rendered):
         if mesh is MeshInstance3D:
                 var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
                 var global_tl = gridmap.to_global(local_tl)
                 var mesh_material = mesh.get_surface_override_material(0)
                 if mesh_material != null:
-                        var mesh_color = mesh_material.albedo_color
+                        var mesh_color = ap.color_by_material_path.get(
+                                mesh_material.resource_path, Color.TRANSPARENT
+                        )
 
                         for y in range(
                                 max(mesh.position.z - mesh.scale.z / 2 - global_tl.z, 0),
@@ -172,4 +175,4 @@ func _renderMeshNode(gridmap, mesh, rendered):
                                         rendered.set_pixel(x, y, mesh_color)
 
         for child in mesh.get_children():
-                _renderMeshNode(gridmap, child, rendered)
+                _renderMeshNode(ap, gridmap, child, rendered)
@@ -0,0 +1,43 @@
+extends "res://scripts/nodes/paintingAuto.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+        if item_id != null and activate_on_sender_complete:
+                enabled = false
+                if not hide_particles:
+                        get_node("Hinge/paintingColliders/TeleportParticles").emitting = false
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -19,6 +19,13 @@ func _ready():
 
         ap.start_batching_locations()
 
+        # Run map-specific initialization.
+        var map_script = ap.get_map_script(global.map)
+        if map_script != null:
+                map_script.on_map_load(get_tree().get_root())
+
+        ap.update_job_well_done_sign()
+
         # Set up door locations.
         var map_id = gamedata.map_id_by_name.get(global.map)
         for door in gamedata.objects.get_doors():
@@ -29,8 +36,12 @@ func _ready():
                         continue
 
                 if (
-                        door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
-                        or door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING
+                        not (door.has_legacy_location() and door.get_legacy_location())
+                        and (
+                                door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR
+                        )
                 ):
                         continue
 
@@ -153,165 +164,6 @@ func _ready():
 
                         get_parent().add_child.call_deferred(locationListener)
 
-        # Block off roof access in Daedalus.
-        if global.map == "daedalus" and not ap.daedalus_roof_access:
-                _set_up_invis_wall(75.5, 11, -24.5, 1, 10, 49)
-                _set_up_invis_wall(51.5, 11, -17, 16, 10, 1)
-                _set_up_invis_wall(46, 10, -9.5, 1, 10, 10)
-                _set_up_invis_wall(67.5, 11, 17, 16, 10, 1)
-                _set_up_invis_wall(50.5, 11, 14, 10, 10, 1)
-                _set_up_invis_wall(39, 10, 18.5, 1, 10, 22)
-                _set_up_invis_wall(20, 15, 18.5, 1, 10, 16)
-                _set_up_invis_wall(11.5, 15, 3, 32, 10, 1)
-                _set_up_invis_wall(11.5, 16, -20, 14, 20, 1)
-                _set_up_invis_wall(14, 16, -26.5, 1, 20, 4)
-                _set_up_invis_wall(28.5, 20.5, -26.5, 1, 15, 25)
-                _set_up_invis_wall(40.5, 20.5, -11, 30, 15, 1)
-                _set_up_invis_wall(50.5, 15, 5.5, 7, 10, 1)
-                _set_up_invis_wall(83.5, 33.5, 5.5, 1, 7, 11)
-                _set_up_invis_wall(83.5, 33.5, -5.5, 1, 7, 11)
-
-                var warp_exit_prefab = preload("res://objects/nodes/exit.tscn")
-                var warp_exit = warp_exit_prefab.instantiate()
-                warp_exit.name = "roof_access_blocker_warp_exit"
-                warp_exit.position = Vector3(58, 10, 0)
-                warp_exit.rotation_degrees.y = 90
-                get_parent().add_child.call_deferred(warp_exit)
-
-                var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn")
-                var warp_enter = warp_enter_prefab.instantiate()
-                warp_enter.target = warp_exit
-                warp_enter.position = Vector3(76.5, 30, 1)
-                warp_enter.scale = Vector3(4, 1.5, 1)
-                warp_enter.rotation_degrees.y = 90
-                get_parent().add_child.call_deferred(warp_enter)
-
-        if global.map == "the_entry":
-                # Remove door behind X1.
-                var door_node = get_tree().get_root().get_node("/root/scene/Components/Doors/exit_1")
-                door_node.handleTriggered()
-
-                # Display win condition.
-                var sign_prefab = preload("res://objects/nodes/sign.tscn")
-                var sign1 = sign_prefab.instantiate()
-                sign1.position = Vector3(-7, 5, -15.01)
-                sign1.text = "victory"
-                get_parent().add_child.call_deferred(sign1)
-
-                var sign2 = sign_prefab.instantiate()
-                sign2.position = Vector3(-7, 4, -15.01)
-                sign2.text = "%s ending" % ap.kEndingNameByVictoryValue.get(ap.victory_condition, "?")
-
-                var sign2_color = ap.kEndingNameByVictoryValue.get(ap.victory_condition, "coral").to_lower()
-                if sign2_color == "white":
-                        sign2_color = "silver"
-
-                sign2.material = load("res://assets/materials/%s.material" % sign2_color)
-                get_parent().add_child.call_deferred(sign2)
-
-        # Add the strict purple ending validation.
-        if global.map == "the_sun_temple" and ap.strict_purple_ending:
-                var panel_prefab = preload("res://objects/nodes/panel.tscn")
-                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
-                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
-
-                var previous_panel = null
-                var next_y = -100
-                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
-                for word in words:
-                        var panel = panel_prefab.instantiate()
-                        panel.position = Vector3(0, next_y, 0)
-                        next_y -= 10
-                        panel.clue = word
-                        panel.symbol = ""
-                        panel.answer = word
-                        panel.name = "EndCheck_%s" % word
-
-                        var tpl = tpl_prefab.instantiate()
-                        tpl.teleport_point = Vector3(0, 1, 0)
-                        tpl.teleport_rotate = Vector3(-45, 180, 0)
-                        tpl.target_path = panel
-                        tpl.name = "Teleport"
-
-                        if previous_panel == null:
-                                tpl.senders.append(NodePath("/root/scene/Panels/End/panel_24"))
-                        else:
-                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
-
-                        var reversing = reverse_prefab.instantiate()
-                        reversing.senders.append(NodePath(".."))
-                        reversing.name = "Reversing"
-                        tpl.senders.append(NodePath("../Reversing"))
-
-                        panel.add_child.call_deferred(tpl)
-                        panel.add_child.call_deferred(reversing)
-                        get_parent().get_node("Panels").add_child.call_deferred(panel)
-
-                        previous_panel = panel
-
-                # Duplicate the doors that usually wait on EQUINOX. We can't set the senders
-                # here for some reason so we actually set them in the door ready function.
-                var endplat = get_node("/root/scene/Components/Doors/EndPlatform")
-                var endplat2 = endplat.duplicate()
-                endplat2.name = "spe_EndPlatform"
-                endplat.get_parent().add_child.call_deferred(endplat2)
-                endplat.queue_free()
-
-                var entry2 = get_node("/root/scene/Components/Doors/entry_2")
-                var entry22 = entry2.duplicate()
-                entry22.name = "spe_entry_2"
-                entry2.get_parent().add_child.call_deferred(entry22)
-                entry2.queue_free()
-
-        # Add the strict cyan ending validation.
-        if global.map == "the_parthenon" and ap.strict_cyan_ending:
-                var panel_prefab = preload("res://objects/nodes/panel.tscn")
-                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
-                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
-
-                var previous_panel = null
-                var next_y = -100
-                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
-                for word in words:
-                        var panel = panel_prefab.instantiate()
-                        panel.position = Vector3(0, next_y, 0)
-                        next_y -= 10
-                        panel.clue = word
-                        panel.symbol = "."
-                        panel.answer = "%s%s" % [word, word]
-                        panel.name = "EndCheck_%s" % word
-
-                        var tpl = tpl_prefab.instantiate()
-                        tpl.teleport_point = Vector3(0, 1, -11)
-                        tpl.teleport_rotate = Vector3(-45, 0, 0)
-                        tpl.target_path = panel
-                        tpl.name = "Teleport"
-
-                        if previous_panel == null:
-                                tpl.senderGroup.append(NodePath("/root/scene/Panels/Rulers"))
-                        else:
-                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
-
-                        var reversing = reverse_prefab.instantiate()
-                        reversing.senders.append(NodePath(".."))
-                        reversing.name = "Reversing"
-                        tpl.senders.append(NodePath("../Reversing"))
-
-                        panel.add_child.call_deferred(tpl)
-                        panel.add_child.call_deferred(reversing)
-                        get_parent().get_node("Panels").add_child.call_deferred(panel)
-
-                        previous_panel = panel
-
-                # Duplicate the door that usually waits on the rulers. We can't set the
-                # senders here for some reason so we actually set them in the door ready
-                # function.
-                var entry1 = get_node("/root/scene/Components/Doors/entry_1")
-                var entry12 = entry1.duplicate()
-                entry12.name = "spe_entry_1"
-                entry1.get_parent().add_child.call_deferred(entry12)
-                entry1.queue_free()
-
         var minimap = ap.SCRIPT_minimap.new()
         minimap.name = "Minimap"
         minimap.visible = ap.show_minimap
@@ -325,22 +177,5 @@ func _ready():
         ap.stop_batching_locations()
 
 
-func _set_up_invis_wall(x, y, z, sx, sy, sz):
-        var prefab = preload("res://objects/nodes/block.tscn")
-        var newwall = prefab.instantiate()
-        newwall.position.x = x
-        newwall.position.y = y
-        newwall.position.z = z
-        newwall.scale.x = sz
-        newwall.scale.y = sy
-        newwall.scale.z = sx
-        newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material"))
-        newwall.visibility_range_end = 3
-        newwall.visibility_range_end_margin = 1
-        newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF
-        newwall.skeleton = ".."
-        get_parent().add_child.call_deferred(newwall)
-
-
 func _process(_dt):
         compass.update_rotation(global_rotation.y)
@@ -100,7 +100,7 @@ func _ready():
         server_box.offset_top = 295.0
         server_box.offset_right = 1144.0
         server_box.offset_bottom = 445.0
-        server_box.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        server_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
         server_box.caret_blink = true
         panel.add_child(server_box)
 
@@ -110,7 +110,7 @@ func _ready():
         player_box.offset_top = 477.0
         player_box.offset_right = 1144.0
         player_box.offset_bottom = 627.0
-        player_box.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        player_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
         player_box.caret_blink = true
         panel.add_child(player_box)
 
@@ -120,20 +120,16 @@ func _ready():
         password_box.offset_top = 659.0
         password_box.offset_right = 1144.0
         password_box.offset_bottom = 809.0
-        password_box.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        password_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
         password_box.caret_blink = true
         panel.add_child(password_box)
 
         var accept_dialog = AcceptDialog.new()
         accept_dialog.name = "AcceptDialog"
-        accept_dialog.offset_right = 83.0
-        accept_dialog.offset_bottom = 58.0
         panel.add_child(accept_dialog)
 
         var version_mismatch = ConfirmationDialog.new()
         version_mismatch.name = "VersionMismatch"
-        version_mismatch.offset_right = 83.0
-        version_mismatch.offset_bottom = 58.0
         panel.add_child(version_mismatch)
 
         var connection_history = MenuButton.new()
@@ -7,6 +7,10 @@ func _init(path):
         source_path = path
 
 
+func path_exists(path):
+        return FileAccess.file_exists("%s/%s" % [source_path, path])
+
+
 func load_script(path):
         return ResourceLoader.load("%s/%s" % [source_path, path])
 
@@ -4,7 +4,6 @@ var tabs
 var panel
 var label
 var entry
-var tracker_label
 var is_open = false
 
 var locations_overlay
@@ -12,11 +11,23 @@ var location_texture
 var worldport_texture
 var goal_texture
 
+var tracker_tree
+var tracker_loc_tree_item_by_id = {}
+var tracker_port_tree_item_by_id = {}
+var tracker_goal_tree_item = null
+var tracker_object_by_index = {}
+var tracker_object_by_ignored_index = {}
+var tracker_ignored_group = null
+
 var worldports_tab
 var worldports_tree
 var port_tree_item_by_map = {}
 var port_tree_item_by_map_port = {}
 
+const kLocation = 0
+const kWorldport = 1
+const kGoal = 2
+
 
 func _ready():
         process_mode = ProcessMode.PROCESS_MODE_ALWAYS
@@ -61,7 +72,7 @@ func _ready():
         label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
         label.size_flags_vertical = Control.SIZE_EXPAND_FILL
         label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
-        label.push_font_size(36)
+        label.push_font_size(30)
 
         var entry_style = StyleBoxFlat.new()
         entry_style.bg_color = Color(0.9, 0.9, 0.9, 1)
@@ -89,8 +100,20 @@ func _ready():
         tracker_margins.add_theme_constant_override("margin_bottom", 60)
         tabs.add_child(tracker_margins)
 
-        tracker_label = RichTextLabel.new()
-        tracker_margins.add_child(tracker_label)
+        tracker_tree = Tree.new()
+        tracker_tree.columns = 4
+        tracker_tree.hide_root = true
+        tracker_tree.add_theme_font_size_override("font_size", 24)
+        tracker_tree.add_theme_color_override("font_color", Color(0.8, 0.8, 0.8, 1))
+        tracker_tree.add_theme_constant_override("v_separation", 1)
+        tracker_tree.item_edited.connect(_on_tracker_button_clicked)
+        tracker_tree.set_column_expand(0, false)
+        tracker_tree.set_column_expand(1, true)
+        tracker_tree.set_column_expand(2, false)
+        tracker_tree.set_column_expand(3, false)
+        tracker_tree.set_column_custom_minimum_width(2, 200)
+        tracker_tree.set_column_custom_minimum_width(3, 200)
+        tracker_margins.add_child(tracker_tree)
 
         worldports_tab = MarginContainer.new()
         worldports_tab.name = "Worldports"
@@ -167,14 +190,10 @@ func text_entered(text):
         ap.client.say(cmd)
 
 
-func update_locations():
+func update_locations(reset_locations = true):
         var ap = global.get_node("Archipelago")
         var gamedata = global.get_node("Gamedata")
 
-        tracker_label.clear()
-        tracker_label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
-        tracker_label.push_font_size(24)
-
         locations_overlay.clear()
         locations_overlay.push_font(preload("res://assets/fonts/Lingo2.ttf"))
         locations_overlay.push_font_size(24)
@@ -182,58 +201,226 @@ func update_locations():
         locations_overlay.push_outline_color(Color(0, 0, 0, 1))
         locations_overlay.push_outline_size(2)
 
-        const kLocation = 0
-        const kWorldport = 1
-        const kGoal = 2
-
-        var location_names = []
-        var type_by_name = {}
+        var locations = []
         for location_id in ap.client._accessible_locations:
                 if not ap.client._checked_locations.has(location_id):
                         var location_name = gamedata.location_name_by_id.get(location_id, "(Unknown)")
-                        location_names.append(location_name)
-                        type_by_name[location_name] = kLocation
+                        (
+                                locations
+                                . append(
+                                        {
+                                                "name": location_name,
+                                                "type": kLocation,
+                                                "id": location_id,
+                                                "ignored": ap._ignored_locations.has(location_id),
+                                                "hint": ap.client._hinted_locations.has(location_id),
+                                        }
+                                )
+                        )
 
         for port_id in ap.client._accessible_worldports:
                 if not ap.client._checked_worldports.has(port_id):
                         var port_name = gamedata.get_worldport_display_name(port_id)
-                        location_names.append(port_name)
-                        type_by_name[port_name] = kWorldport
-
-        location_names.sort()
+                        (
+                                locations
+                                . append(
+                                        {
+                                                "name": port_name,
+                                                "type": kWorldport,
+                                                "id": port_id,
+                                                "ignored": false,
+                                                "hint": false,
+                                        }
+                                )
+                        )
+
+        locations.sort_custom(_cmp_tracker_objects)
 
         if ap.client._goal_accessible:
                 var location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
                         ap.victory_condition
                 ]]
-                location_names.push_front(location_name)
-                type_by_name[location_name] = kGoal
+                (
+                        locations
+                        . push_front(
+                                {
+                                        "name": location_name,
+                                        "type": kGoal,
+                                        "ignored": false,
+                                        "hint": false,
+                                }
+                        )
+                )
 
         var count = 0
-        for location_name in location_names:
-                tracker_label.append_text("[p]%s[/p]" % location_name)
-                if count < 18:
+        for location in locations:
+                if count < 18 and not location["ignored"]:
                         locations_overlay.push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT)
-                        locations_overlay.append_text(location_name)
+                        if location["hint"]:
+                                locations_overlay.push_color(Color("#fafad2"))
+                        locations_overlay.append_text(location["name"])
                         locations_overlay.append_text(" ")
-                        if type_by_name[location_name] == kLocation:
+                        if location["type"] == kLocation:
                                 locations_overlay.add_image(location_texture)
-                        elif type_by_name[location_name] == kWorldport:
+                        elif location["type"] == kWorldport:
                                 locations_overlay.add_image(worldport_texture)
-                        elif type_by_name[location_name] == kGoal:
+                        elif location["type"] == kGoal:
                                 locations_overlay.add_image(goal_texture)
+                        if location["hint"]:
+                                locations_overlay.pop()
                         locations_overlay.pop()
                 count += 1
 
         if count > 18:
                 locations_overlay.append_text("[p align=right][lb]...[rb][/p]")
 
+        if reset_locations:
+                reset_tracker_tab()
+
+                var root_ti = tracker_tree.create_item(null)
+
+                for location in locations:
+                        var loc_row
+
+                        if location["ignored"]:
+                                if tracker_ignored_group == null:
+                                        tracker_ignored_group = root_ti.create_child()
+                                        tracker_ignored_group.set_text(1, "Ignored Locations")
+                                        tracker_ignored_group.set_selectable(0, false)
+                                        tracker_ignored_group.set_selectable(1, false)
+                                        tracker_ignored_group.set_selectable(2, false)
+                                        tracker_ignored_group.set_selectable(3, false)
+
+                                loc_row = tracker_ignored_group.create_child()
+                        else:
+                                loc_row = root_ti.create_child()
+
+                        loc_row.set_cell_mode(0, TreeItem.CELL_MODE_ICON)
+                        loc_row.set_selectable(0, false)
+                        loc_row.set_text(1, location["name"])
+                        loc_row.set_selectable(1, false)
+                        if location["hint"]:
+                                loc_row.set_custom_color(1, Color("#fafad2"))
+                        loc_row.set_cell_mode(2, TreeItem.CELL_MODE_CUSTOM)
+                        loc_row.set_text(2, "Show Path")
+                        loc_row.set_custom_as_button(2, true)
+                        loc_row.set_editable(2, true)
+                        loc_row.set_selectable(2, false)
+                        loc_row.set_text_alignment(2, HORIZONTAL_ALIGNMENT_CENTER)
+                        loc_row.set_selectable(3, false)
+                        if location["type"] == kLocation:
+                                loc_row.set_cell_mode(3, TreeItem.CELL_MODE_CUSTOM)
+                                if location["ignored"]:
+                                        loc_row.set_text(3, "Unignore")
+                                else:
+                                        loc_row.set_text(3, "Ignore")
+                                loc_row.set_custom_as_button(3, true)
+                                loc_row.set_editable(3, true)
+                                loc_row.set_text_alignment(3, HORIZONTAL_ALIGNMENT_CENTER)
+
+                        if location["type"] == kLocation:
+                                loc_row.set_icon(0, location_texture)
+                                tracker_loc_tree_item_by_id[location["id"]] = loc_row
+                        elif location["type"] == kWorldport:
+                                loc_row.set_icon(0, worldport_texture)
+                                tracker_port_tree_item_by_id[location["id"]] = loc_row
+                        elif location["type"] == kGoal:
+                                loc_row.set_icon(0, goal_texture)
+                                tracker_goal_tree_item = loc_row
+
+                        if location["ignored"]:
+                                tracker_object_by_ignored_index[loc_row.get_index()] = location
+                        else:
+                                tracker_object_by_index[loc_row.get_index()] = location
+        else:
+                for loc_row in tracker_tree.get_root().get_children():
+                        loc_row.visible = false
+
+                for location_id in tracker_loc_tree_item_by_id.keys():
+                        if (
+                                ap.client._accessible_locations.has(location_id)
+                                and not ap.client._checked_locations.has(location_id)
+                        ):
+                                tracker_loc_tree_item_by_id[location_id].visible = true
+
+                for port_id in tracker_port_tree_item_by_id.keys():
+                        if (
+                                ap.client._accessible_worldports.has(port_id)
+                                and not ap.client._checked_worldports.has(port_id)
+                        ):
+                                tracker_port_tree_item_by_id[port_id].visible = true
+
+                if tracker_goal_tree_item != null and ap.client._goal_accessible:
+                        tracker_goal_tree_item.visible = true
+
+                if tracker_ignored_group != null:
+                        tracker_ignored_group.visible = true
+
+
+func _cmp_tracker_objects(a, b) -> bool:
+        if a["ignored"] != b["ignored"]:
+                return !a["ignored"]
+        elif a["hint"] != b["hint"]:
+                return a["hint"]
+        else:
+                return a["name"] < b["name"]
+
 
 func update_locations_visibility():
         var ap = global.get_node("Archipelago")
         locations_overlay.visible = ap.show_locations
 
 
+func _on_tracker_button_clicked():
+        var ap = global.get_node("Archipelago")
+
+        var edited_item = tracker_tree.get_edited()
+        var edited_index = edited_item.get_index()
+
+        if edited_item.get_parent() == tracker_tree.get_root():
+                if tracker_object_by_index.has(edited_index):
+                        var tracker_object = tracker_object_by_index[edited_index]
+                        if tracker_tree.get_edited_column() == 2:
+                                var type_str = ""
+                                if tracker_object["type"] == kLocation:
+                                        type_str = "location"
+                                elif tracker_object["type"] == kWorldport:
+                                        type_str = "worldport"
+                                elif tracker_object["type"] == kGoal:
+                                        type_str = "goal"
+                                ap.client.getLogicalPath(type_str, tracker_object.get("id", null))
+                        elif tracker_tree.get_edited_column() == 3:
+                                ap.toggle_ignored_location(tracker_object["id"])
+        elif edited_item.get_parent() == tracker_ignored_group:
+                # This is the ignored locations group.
+                if (
+                        tracker_object_by_ignored_index.has(edited_index)
+                        and tracker_tree.get_edited_column() == 3
+                ):
+                        var tracker_object = tracker_object_by_ignored_index[edited_index]
+                        ap.toggle_ignored_location(tracker_object["id"])
+
+
+func display_logical_path(object_type, object_id, paths):
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        var location_name = "(Unknown)"
+        if object_type == "location" and object_id != null:
+                location_name = gamedata.location_name_by_id.get(object_id, "(Unknown)")
+        elif object_type == "worldport" and object_id != null:
+                location_name = gamedata.get_worldport_display_name(object_id)
+        elif object_type == "goal":
+                location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
+                        ap.victory_condition
+                ]]
+
+        label.append_text("[p]Path to %s:[/p]" % location_name)
+        label.append_text("[ol]" + "\n".join(paths) + "[/ol]")
+
+        panel.visible = true
+
+
 func setup_worldports():
         tabs.set_tab_hidden(2, false)
 
@@ -308,3 +495,14 @@ func reset():
         port_tree_item_by_map.clear()
         port_tree_item_by_map_port.clear()
         worldports_tree.clear()
+        reset_tracker_tab()
+
+
+func reset_tracker_tab():
+        tracker_loc_tree_item_by_id.clear()
+        tracker_port_tree_item_by_id.clear()
+        tracker_goal_tree_item = null
+        tracker_object_by_index.clear()
+        tracker_object_by_ignored_index.clear()
+        tracker_ignored_group = null
+        tracker_tree.clear()
@@ -0,0 +1,46 @@
+extends "res://scripts/nodes/listeners/unlockReaderListener.gd"
+
+var item_id = null
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+        super._ready()
+
+
+func _readier():
+        if item_id != null:
+                var ap = global.get_node("Archipelago")
+
+                if ap.client.getItemAmount(item_id) >= item_amount:
+                        handleTriggered()
+        else:
+                super._readier()
+
+
+func handleTriggered():
+        if item_id != null:
+                emit_signal("trigger")
+        else:
+                super.handleTriggered()
@@ -2,7 +2,7 @@ extends "res://scripts/nodes/listeners/worldportListener.gd"
 
 
 func handleTriggered():
-        if exit == "menus/credits":
+        if exit.begins_with("menus/credits"):
                 return
 
         super.handleTriggered()
@@ -2,6 +2,7 @@ import asyncio
 import os
 import pkgutil
 import subprocess
+import sys
 from typing import Any
 
 import websockets
@@ -29,6 +30,16 @@ KEY_STORAGE_MAPPING = {
 REVERSE_KEY_STORAGE_MAPPING = {t: k for k, t in KEY_STORAGE_MAPPING.items()}
 
 
+# There is a distinction between an object's ID and its AP ID. The latter is stable between releases, whereas the former
+# can change and is also namespaced based on the object type. We should only store AP IDs in multiworld state (such as
+# slot data and data storage) to increase compatability between releases. The data we currently store is:
+# - Port pairings for worldport shuffle (slot data)
+# - Checked worldports for worldport shuffle (data storage)
+# - Latched doors (data storage)
+# The client generally deals in the actual object IDs rather than the stable IDs, although it does have to convert the
+# port pairing IDs when reading them from slot data. The context (this file here) does the work of converting back and
+# forth between the values. AP IDs are converted to IDs after reading them from data storage, and IDs are converted to
+# AP IDs before sending them to data storage.
 class Lingo2Manager:
     game_ctx: "Lingo2GameContext"
     client_ctx: "Lingo2ClientContext"
@@ -37,6 +48,8 @@ class Lingo2Manager:
     keyboard: dict[str, int]
     worldports: set[int]
     goaled: bool
+    latches: set[int]
+    hinted_locations: set[int]
 
     def __init__(self, game_ctx: "Lingo2GameContext", client_ctx: "Lingo2ClientContext"):
         self.game_ctx = game_ctx
@@ -45,7 +58,6 @@ class Lingo2Manager:
         self.client_ctx.manager = self
         self.tracker = Tracker(self)
         self.keyboard = {}
-        self.worldports = set()
 
         self.reset()
 
@@ -55,6 +67,8 @@ class Lingo2Manager:
 
         self.worldports = set()
         self.goaled = False
+        self.latches = set()
+        self.hinted_locations = set()
 
     def update_keyboard(self, new_keyboard: dict[str, int]) -> dict[str, int]:
         ret: dict[str, int] = {}
@@ -70,6 +84,7 @@ class Lingo2Manager:
 
         return ret
 
+    # Input should be real IDs, not AP IDs
     def update_worldports(self, new_worldports: set[int]) -> set[int]:
         ret = new_worldports.difference(self.worldports)
         self.worldports.update(new_worldports)
@@ -80,6 +95,18 @@ class Lingo2Manager:
 
         return ret
 
+    def update_latches(self, new_latches: set[int]) -> set[int]:
+        ret = new_latches.difference(self.latches)
+        self.latches.update(new_latches)
+
+        return ret
+
+    def update_hinted_locations(self, new_locs: set[int]) -> set[int]:
+        ret = new_locs.difference(self.hinted_locations)
+        self.hinted_locations.update(new_locs)
+
+        return ret
+
 
 class Lingo2GameContext:
     server: Endpoint | None
@@ -106,6 +133,17 @@ class Lingo2GameContext:
 
         async_start(self.send_msgs([msg]), name="game Connected")
 
+    def send_connection_refused(self, text):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ConnectionRefused",
+            "text": text,
+        }
+
+        async_start(self.send_msgs([msg]), name="game ConnectionRefused")
+
     def send_item_sent_notification(self, item_name, receiver_name, item_flags):
         if self.server is None:
             return
@@ -206,6 +244,7 @@ class Lingo2GameContext:
 
         async_start(self.send_msgs([msg]), name="update keyboard")
 
+    # Input should be real IDs, not AP IDs
     def send_update_worldports(self, worldports):
         if self.server is None:
             return
@@ -217,6 +256,54 @@ class Lingo2GameContext:
 
         async_start(self.send_msgs([msg]), name="update worldports")
 
+    def send_path_reply(self, object_type: str, object_id: int | None, path: list[str]):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "PathReply",
+            "type": object_type,
+            "path": path,
+        }
+
+        if object_id is not None:
+            msg["id"] = object_id
+
+        async_start(self.send_msgs([msg]), name="path reply")
+
+    def send_update_latches(self, latches):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateLatches",
+            "latches": latches,
+        }
+
+        async_start(self.send_msgs([msg]), name="update latches")
+
+    def send_ignored_locations(self, ignored_locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "SetIgnoredLocations",
+            "locations": ignored_locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="set ignored locations")
+
+    def send_update_hinted_locations(self, hinted_locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateHintedLocations",
+            "locations": hinted_locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="update hinted locations")
+
     async def send_msgs(self, msgs: list[Any]) -> None:
         """ `msgs` JSON serializable """
         if not self.server or not self.server.socket.open or self.server.socket.closed:
@@ -231,6 +318,7 @@ class Lingo2ClientContext(CommonContext):
     items_handling = 0b111
 
     slot_data: dict[str, Any] | None
+    hints_data_storage_key: str
     victory_data_storage_key: str
 
     def __init__(self, server_address: str | None = None, password: str | None = None):
@@ -242,8 +330,17 @@ class Lingo2ClientContext(CommonContext):
         return ui
 
     async def server_auth(self, password_requested: bool = False):
-        self.auth = self.username
-        await self.send_connect()
+        if password_requested and not self.password:
+            self.manager.game_ctx.send_connection_refused("Invalid password.")
+        else:
+            self.auth = self.username
+            await self.send_connect()
+
+    def handle_connection_loss(self, msg: str):
+        super().handle_connection_loss(msg)
+
+        exc_info = sys.exc_info()
+        self.manager.game_ctx.send_connection_refused(str(exc_info[1]))
 
     def on_package(self, cmd: str, args: dict):
         if cmd == "RoomInfo":
@@ -259,10 +356,12 @@ class Lingo2ClientContext(CommonContext):
             self.manager.tracker.set_checked_locations(self.checked_locations)
             self.manager.game_ctx.send_accessible_locations()
 
+            self.hints_data_storage_key = f"_read_hints_{self.team}_{self.slot}"
             self.victory_data_storage_key = f"_read_client_status_{self.team}_{self.slot}"
 
             self.set_notify(self.get_datastorage_key("keyboard1"), self.get_datastorage_key("keyboard2"),
-                            self.victory_data_storage_key)
+                            self.victory_data_storage_key, self.get_datastorage_key("latches"),
+                            self.get_datastorage_key("ignored_locations"))
             msg_batch = [{
                 "cmd": "Set",
                 "key": self.get_datastorage_key("keyboard1"),
@@ -275,6 +374,18 @@ class Lingo2ClientContext(CommonContext):
                 "default": 0,
                 "want_reply": True,
                 "operations": [{"operation": "default", "value": 0}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("latches"),
+                "default": [],
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": []}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("ignored_locations"),
+                "default": [],
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": []}]
             }]
 
             if self.slot_data.get("shuffle_worldports", False):
@@ -373,17 +484,29 @@ class Lingo2ClientContext(CommonContext):
             for k, v in args["keys"].items():
                 if k == self.victory_data_storage_key:
                     self.handle_status_update(v)
+                elif k == self.hints_data_storage_key:
+                    self.update_hints()
         elif cmd == "SetReply":
             if args["key"] == self.get_datastorage_key("keyboard1"):
                 self.handle_keyboard_update(1, args)
             elif args["key"] == self.get_datastorage_key("keyboard2"):
                 self.handle_keyboard_update(2, args)
             elif args["key"] == self.get_datastorage_key("worldports"):
-                updates = self.manager.update_worldports(set(args["value"]))
+                port_ids = set(Lingo2World.static_logic.port_id_by_ap_id[ap_id] for ap_id in args["value"])
+                updates = self.manager.update_worldports(port_ids)
                 if len(updates) > 0:
                     self.manager.game_ctx.send_update_worldports(updates)
             elif args["key"] == self.victory_data_storage_key:
                 self.handle_status_update(args["value"])
+            elif args["key"] == self.get_datastorage_key("latches"):
+                door_ids = set(Lingo2World.static_logic.door_id_by_ap_id[ap_id] for ap_id in args["value"])
+                updates = self.manager.update_latches(door_ids)
+                if len(updates) > 0:
+                    self.manager.game_ctx.send_update_latches(updates)
+            elif args["key"] == self.get_datastorage_key("ignored_locations"):
+                self.manager.game_ctx.send_ignored_locations(args["value"])
+            elif args["key"] == self.hints_data_storage_key:
+                self.update_hints()
 
     def get_datastorage_key(self, name: str):
         return f"Lingo2_{self.slot}_{name}"
@@ -449,14 +572,16 @@ class Lingo2ClientContext(CommonContext):
         if len(updates) > 0:
             self.manager.game_ctx.send_update_keyboard(updates)
 
+    # Input should be real IDs, not AP IDs
     async def update_worldports(self, updates: set[int]):
+        port_ap_ids = [Lingo2World.static_logic.objects.ports[port_id].ap_id for port_id in updates]
         await self.send_msgs([{
             "cmd": "Set",
             "key": self.get_datastorage_key("worldports"),
             "want_reply": True,
             "operations": [{
                 "operation": "update",
-                "value": updates
+                "value": port_ap_ids
             }]
         }])
 
@@ -465,6 +590,48 @@ class Lingo2ClientContext(CommonContext):
         self.manager.tracker.refresh_state()
         self.manager.game_ctx.send_accessible_locations()
 
+    async def update_latches(self, updates: set[int]):
+        door_ap_ids = [Lingo2World.static_logic.objects.doors[door_id].ap_id for door_id in updates]
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("latches"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": door_ap_ids
+            }]
+        }])
+
+    async def add_ignored_location(self, loc_id: int):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("ignored_locations"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": [loc_id]
+            }]
+        }])
+
+    async def remove_ignored_location(self, loc_id: int):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("ignored_locations"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "remove",
+                "value": loc_id
+            }]
+        }])
+
+    def update_hints(self):
+        hints = self.stored_data.get(self.hints_data_storage_key, [])
+
+        hinted_locations = set(hint["location"] for hint in hints if hint["finding_player"] == self.slot)
+        updates = self.manager.update_hinted_locations(hinted_locations)
+        if len(updates) > 0:
+            self.manager.game_ctx.send_update_hinted_locations(updates)
+
 
 async def pipe_loop(manager: Lingo2Manager):
     while not manager.client_ctx.exit_event.is_set():
@@ -489,6 +656,8 @@ async def process_game_cmd(manager: Lingo2Manager, args: dict):
     cmd = args["cmd"]
 
     if cmd == "Connect":
+        manager.client_ctx.seed_name = None
+
         server = args.get("server")
         player = args.get("player")
         password = args.get("password")
@@ -500,6 +669,8 @@ async def process_game_cmd(manager: Lingo2Manager, args: dict):
 
         async_start(manager.client_ctx.connect(server_address), name="client connect")
     elif cmd == "Disconnect":
+        manager.client_ctx.seed_name = None
+
         async_start(manager.client_ctx.disconnect(), name="client disconnect")
     elif cmd in ["Sync", "LocationChecks", "Say", "StatusUpdate", "LocationScouts"]:
         async_start(manager.client_ctx.send_msgs([args]), name="client forward")
@@ -509,14 +680,38 @@ async def process_game_cmd(manager: Lingo2Manager, args: dict):
             async_start(manager.client_ctx.update_keyboard(updates), name="client update keyboard")
     elif cmd == "CheckWorldport":
         port_id = args["port_id"]
+        port_ap_id = Lingo2World.static_logic.objects.ports[port_id].ap_id
         worldports = {port_id}
-        if str(port_id) in manager.client_ctx.slot_data["port_pairings"]:
-            worldports.add(manager.client_ctx.slot_data["port_pairings"][str(port_id)])
+
+        # Also check the reverse port if it's a two-way connection.
+        port_pairings = manager.client_ctx.slot_data["port_pairings"]
+        if str(port_ap_id) in port_pairings and\
+                port_pairings.get(str(port_pairings[str(port_ap_id)]), None) == port_ap_id:
+            worldports.add(Lingo2World.static_logic.port_id_by_ap_id[port_pairings[str(port_ap_id)]])
 
         updates = manager.update_worldports(worldports)
         if len(updates) > 0:
             async_start(manager.client_ctx.update_worldports(updates), name="client update worldports")
             manager.game_ctx.send_update_worldports(updates)
+    elif cmd == "GetPath":
+        path = None
+
+        if args["type"] == "location":
+            path = manager.tracker.get_path_to_location(args["id"])
+        elif args["type"] == "worldport":
+            path = manager.tracker.get_path_to_port(args["id"])
+        elif args["type"] == "goal":
+            path = manager.tracker.get_path_to_goal()
+
+        manager.game_ctx.send_path_reply(args["type"], args.get("id", None), path)
+    elif cmd == "LatchDoor":
+        updates = manager.update_latches({args["door"]})
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_latches(updates), name="client update latches")
+    elif cmd == "IgnoreLocation":
+        async_start(manager.client_ctx.add_ignored_location(args["id"]), name="client ignore loc")
+    elif cmd == "UnignoreLocation":
+        async_start(manager.client_ctx.remove_ignored_location(args["id"]), name="client unignore loc")
     elif cmd == "Quit":
         manager.client_ctx.exit_event.set()
 
@@ -564,9 +759,12 @@ async def run_game():
 
 def client_main(*launch_args: str) -> None:
     async def main(args):
-        async_start(run_game())
+        if settings.get_settings().lingo2_options.start_game:
+            async_start(run_game())
 
         client_ctx = Lingo2ClientContext(args.connect, args.password)
+        client_ctx.auth = args.name
+
         game_ctx = Lingo2GameContext()
         manager = Lingo2Manager(game_ctx, client_ctx)
 
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range, OptionSet
 
 
 class ShuffleDoors(DefaultOnToggle):
@@ -56,8 +56,7 @@ class ShuffleWorldports(Toggle):
     """
     Randomizes the connections between maps. This affects worldports only, which are the loading zones you walk into in
     order to change maps. This does not affect paintings, panels that teleport you, or certain other special connections
-    like the one between The Shop and Control Center. Connections that depend on placing letters in keyholders are also
-    currently not shuffled.
+    like the one between The Shop and Control Center.
     """
     display_name = "Shuffle Worldports"
 
@@ -92,6 +91,36 @@ class CyanDoorBehavior(Choice):
     option_item = 2
 
 
+class EnableIcarus(Toggle):
+    """
+    Controls whether Icarus is randomized. If disabled, which is the default, no locations or items will be created for
+    it, and its worldport will not be shuffled when worldport shuffle is on.
+    """
+    display_name = "Enable Icarus"
+
+
+class EnableGiftMaps(OptionSet):
+    """
+    Controls whether the beta tester gift maps are randomized. By default, these are not accessible at all from within
+    the randomizer. This option allows you to enter the maps, and creates items and locations for them. If worldport
+    shuffle is on, their worldports will be included in the randomization.
+
+    The gift maps are accessed via a panel in The Entry's Starting Room, which only appears if at least one gift map is
+    enabled. It is also treated like a cyan door, and will not appear until the condition specified in the Cyan Door
+    Behavior option is satisfied. Solving this panel with the name of one of the beta testers will teleport you to their
+    corresponding gift map.
+
+    In the base game, nothing happens once you complete a gift map. Masteries have been added to the gift maps in the
+    randomizer so that the player can be rewarded for completing them.
+
+    Note that the gift maps were originally only intended to be played by specific people, and as a result may be
+    frustrating or require knowledge of inside jokes. The Crystalline is particularly difficult as it requires
+    completing a parkour course.
+    """
+    display_name = "Enable Gift Maps"
+    valid_keys = ["The Advanced", "The Charismatic", "The Crystalline", "The Fuzzy", "The Stellar"]
+
+
 class DaedalusRoofAccess(Toggle):
     """
     If enabled, the player will be logically expected to be able to go from the castle entrance to any part of Daedalus
@@ -152,6 +181,26 @@ class VictoryCondition(Choice):
     option_white_ending = 12
 
 
+class EndingsRequirement(Range):
+    """The number of endings required to unlock White Ending."""
+    display_name = "Endings Requirement"
+    range_start = 0
+    range_end = 12
+    default = 12
+
+
+class MasteriesRequirement(Range):
+    """The number of masteries required to unlock White Ending.
+
+    There are only 13 masteries in the base game, but some of the other slot options may add more masteries to the
+    world. If the chosen number of masteries is higher than the total in your world, it will be automatically lowered to
+    the maximum."""
+    display_name = "Masteries Requirement"
+    range_start = 0
+    range_end = 19
+    default = 0
+
+
 class TrapPercentage(Range):
     """Replaces junk items with traps, at the specified rate."""
     display_name = "Trap Percentage"
@@ -170,8 +219,12 @@ class Lingo2Options(PerGameCommonOptions):
     shuffle_worldports: ShuffleWorldports
     keyholder_sanity: KeyholderSanity
     cyan_door_behavior: CyanDoorBehavior
+    enable_icarus: EnableIcarus
+    enable_gift_maps: EnableGiftMaps
     daedalus_roof_access: DaedalusRoofAccess
     strict_purple_ending: StrictPurpleEnding
     strict_cyan_ending: StrictCyanEnding
     victory_condition: VictoryCondition
+    endings_requirement: EndingsRequirement
+    masteries_requirement: MasteriesRequirement
     trap_percentage: TrapPercentage
@@ -4,7 +4,7 @@ from .generated import data_pb2 as data_pb2
 from .items import SYMBOL_ITEMS
 from typing import TYPE_CHECKING, NamedTuple
 
-from .options import VictoryCondition, ShuffleLetters, CyanDoorBehavior
+from .options import ShuffleLetters, CyanDoorBehavior
 
 if TYPE_CHECKING:
     from . import Lingo2World
@@ -73,7 +73,7 @@ class AccessRequirements:
         self.cyans = self.cyans or other.cyans
 
         for disjunction in other.or_logic:
-            self.or_logic.append(disjunction)
+            self.or_logic.append([sub_req.copy() for sub_req in disjunction])
 
         if other.complete_at is not None:
             # Merging multiple requirements that use complete_at sucks, and is part of why we want to minimize use of
@@ -84,7 +84,7 @@ class AccessRequirements:
 
                 left_req = AccessRequirements()
                 left_req.complete_at = self.complete_at
-                left_req.possibilities = self.possibilities
+                left_req.possibilities = [sub_req.copy() for sub_req in self.possibilities]
                 self.or_logic.append([left_req])
 
                 self.complete_at = None
@@ -92,11 +92,11 @@ class AccessRequirements:
 
                 right_req = AccessRequirements()
                 right_req.complete_at = other.complete_at
-                right_req.possibilities = other.possibilities
+                right_req.possibilities = [sub_req.copy() for sub_req in other.possibilities]
                 self.or_logic.append([right_req])
             else:
                 self.complete_at = other.complete_at
-                self.possibilities = other.possibilities
+                self.possibilities = [sub_req.copy() for sub_req in other.possibilities]
 
     def is_empty(self) -> bool:
         return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
@@ -202,6 +202,8 @@ class LetterBehavior(IntEnum):
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
+    shuffled_maps: set[int]
+
     locations_by_room: dict[int, list[PlayerLocation]]
     event_loc_item_by_room: dict[int, dict[str, str]]
 
@@ -214,6 +216,7 @@ class Lingo2PlayerLogic:
     real_items: list[str]
 
     double_letter_amount: dict[str, int]
+    goal_room_id: int
 
     def __init__(self, world: "Lingo2World"):
         self.world = world
@@ -226,9 +229,45 @@ class Lingo2PlayerLogic:
         self.real_items = list()
         self.double_letter_amount = dict()
 
+        def should_shuffle_map(game_map) -> bool:
+            if game_map.type == data_pb2.MapType.NORMAL_MAP:
+                return True
+            elif game_map.type == data_pb2.MapType.ICARUS:
+                return bool(world.options.enable_icarus)
+            elif game_map.type == data_pb2.MapType.GIFT_MAP:
+                if game_map.name == "the_advanced":
+                    return "The Advanced" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_charismatic":
+                    return "The Charismatic" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_crystalline":
+                    return "The Crystalline" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_fuzzy":
+                    return "The Fuzzy" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_stellar":
+                    return "The Stellar" in world.options.enable_gift_maps.value
+
+            return False
+
+        self.shuffled_maps = set(game_map.id for game_map in world.static_logic.objects.maps
+                                 if should_shuffle_map(game_map))
+
+        maximum_masteries = 13 + len(world.options.enable_gift_maps.value)
+        if world.options.enable_icarus:
+            maximum_masteries += 1
+
+        if world.options.masteries_requirement > maximum_masteries:
+            world.options.masteries_requirement.value = maximum_masteries
+
+        if "The Fuzzy" in world.options.enable_gift_maps.value:
+            self.real_items.append("Numbers")
+
         if self.world.options.shuffle_doors:
             for progressive in world.static_logic.objects.progressives:
                 for i in range(0, len(progressive.doors)):
+                    door = world.static_logic.objects.doors[progressive.doors[i]]
+                    if door.map_id not in self.shuffled_maps:
+                        continue
+
                     self.item_by_door[progressive.doors[i]] = (progressive.name, i + 1)
                     self.real_items.append(progressive.name)
 
@@ -245,14 +284,21 @@ class Lingo2PlayerLogic:
             else:
                 continue
 
-            for door in door_group.doors:
-                self.item_by_door[door] = (door_group.name, 1)
+            shuffleable_doors = [door_id for door_id in door_group.doors
+                                 if world.static_logic.objects.doors[door_id].map_id in self.shuffled_maps]
 
-            self.real_items.append(door_group.name)
+            if len(shuffleable_doors) > 0:
+                for door in shuffleable_doors:
+                    self.item_by_door[door] = (door_group.name, 1)
+
+                self.real_items.append(door_group.name)
 
         # We iterate through the doors in two parts because it is essential that we determine which doors are shuffled
         # before we calculate any access requirements.
         for door in world.static_logic.objects.doors:
+            if door.map_id not in self.shuffled_maps:
+                continue
+
             if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
                 continue
 
@@ -281,18 +327,28 @@ class Lingo2PlayerLogic:
                 if door_group.type != data_pb2.DoorGroupType.CYAN_DOORS:
                     continue
 
-                for door in door_group.doors:
-                    if not door in self.item_by_door:
+                shuffleable_doors = [door_id for door_id in door_group.doors
+                                     if world.static_logic.objects.doors[door_id].map_id in self.shuffled_maps
+                                     and door_id not in self.item_by_door]
+
+                if len(shuffleable_doors) > 0:
+                    for door in shuffleable_doors:
                         self.item_by_door[door] = (door_group.name, 1)
 
-                self.real_items.append(door_group.name)
+                    self.real_items.append(door_group.name)
 
         for door in world.static_logic.objects.doors:
+            if door.map_id not in self.shuffled_maps:
+                continue
+
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
                 self.locations_by_room.setdefault(door.room_id, []).append(PlayerLocation(door.ap_id,
                                                                                           self.get_door_reqs(door.id)))
 
         for letter in world.static_logic.objects.letters:
+            if world.static_logic.get_room_object_map_id(letter) not in self.shuffled_maps:
+                continue
+
             self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
                                                                                         AccessRequirements()))
             behavior = self.get_letter_behavior(letter.key, letter.level2)
@@ -312,27 +368,42 @@ class Lingo2PlayerLogic:
                 self.double_letter_amount[letter.key.upper()] = self.double_letter_amount.get(letter.key.upper(), 0) + 1
 
         for mastery in world.static_logic.objects.masteries:
+            if world.static_logic.get_room_object_map_id(mastery) not in self.shuffled_maps:
+                continue
+
             self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
                                                                                          AccessRequirements()))
 
+            if world.options.masteries_requirement > 0:
+                event_name = f"{world.static_logic.get_room_object_map_name(mastery)} - Mastery (Collected)"
+                self.event_loc_item_by_room.setdefault(mastery.room_id, {})[event_name] = "Mastery"
+
         for ending in world.static_logic.objects.endings:
-            # Don't create a location for your selected ending, and never create a location for White Ending.
+            if world.static_logic.get_room_object_map_id(ending) not in self.shuffled_maps:
+                continue
+
+            # Don't create a location for your selected ending. Also don't create a location for White Ending if it's
+            # necessarily in the postgame, i.e. it requires all 12 other endings.
             if world.options.victory_condition.current_key.removesuffix("_ending").upper() != ending.name\
-                    and ending.name != "WHITE":
+                    and (ending.name != "WHITE" or world.options.endings_requirement < 12):
                 self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
                                                                                             AccessRequirements()))
 
-            event_name = f"{ending.name.capitalize()} Ending (Achieved)"
-            item_name = event_name
-
             if world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
-                item_name = "Victory"
+                event_name = f"{ending.name.capitalize()} Ending (Goal)"
+                self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Victory"
+                self.goal_room_id = ending.room_id
 
-            self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = item_name
+            if ending.name != "WHITE":
+                event_name = f"{ending.name.capitalize()} Ending (Achieved)"
+                self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Ending"
 
         if self.world.options.keyholder_sanity:
             for keyholder in world.static_logic.objects.keyholders:
                 if keyholder.HasField("key"):
+                    if world.static_logic.get_room_object_map_id(keyholder) not in self.shuffled_maps:
+                        continue
+
                     reqs = AccessRequirements()
 
                     if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED:
@@ -440,7 +511,6 @@ class Lingo2PlayerLogic:
                 reqs.possibilities.append(panel_reqs)
 
         if door.HasField("control_center_color"):
-            # TODO: Logic for ensuring two CC states aren't needed at once.
             reqs.rooms.add("Control Center - Main Area")
             self.add_solution_reqs(reqs, door.control_center_color)
 
@@ -466,13 +536,12 @@ class Lingo2PlayerLogic:
         for room in door.rooms:
             reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
 
-        for ending_id in door.endings:
-            ending = self.world.static_logic.objects.endings[ending_id]
+        if door.white_ending:
+            if self.world.options.endings_requirement > 0:
+                reqs.progressives["Ending"] = self.world.options.endings_requirement.value
 
-            if self.world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
-                reqs.items.add("Victory")
-            else:
-                reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+            if self.world.options.masteries_requirement > 0:
+                reqs.progressives["Mastery"] = self.world.options.masteries_requirement.value
 
         for sub_door_id in door.doors:
             sub_reqs = self.get_door_open_reqs(sub_door_id)
@@ -534,3 +603,6 @@ class Lingo2PlayerLogic:
 
             if needed > 0:
                 reqs.letters[l] = max(reqs.letters.get(l, 0), needed)
+
+        if any(l.isnumeric() for l in solution):
+            reqs.items.add("Numbers")
@@ -62,6 +62,9 @@ def create_regions(world: "Lingo2World"):
     # locations. This allows us to reference the actual region objects in the access rules for the locations, which is
     # faster than having to look them up during access checking.
     for room in world.static_logic.objects.rooms:
+        if room.map_id not in world.player_logic.shuffled_maps:
+            continue
+
         region = create_region(room, world)
         regions[region.name] = region
         region_and_room.append((region, room))
@@ -97,7 +100,7 @@ def create_regions(world: "Lingo2World"):
 
         if connection.HasField("port"):
             port = world.static_logic.objects.ports[connection.port]
-            connection_name = f"{connection_name} (via port {port.name})"
+            connection_name = f"{connection_name} (via {port.display_name})"
 
             if world.options.shuffle_worldports and not port.no_shuffle:
                 continue
@@ -132,6 +135,12 @@ def create_regions(world: "Lingo2World"):
         reqs.simplify()
         reqs.remove_room(from_region)
 
+        if to_region in reqs.rooms:
+            # This connection can't ever increase access because you're required to have access to the other side in
+            # order for it to be usable. We will just not create the connection at all, in order to help GER figure out
+            # what regions are dead ends.
+            continue
+
         connection = Entrance(world.player, connection_name, regions[from_region])
         connection.access_rule = make_location_lambda(reqs, world, regions)
 
@@ -150,14 +159,46 @@ def shuffle_entrances(world: "Lingo2World"):
 
     port_id_by_name: dict[str, int] = {}
 
-    for port in world.static_logic.objects.ports:
-        if port.no_shuffle:
-            continue
+    shuffleable_ports = [port for port in world.static_logic.objects.ports
+                         if not port.no_shuffle
+                         and world.static_logic.get_room_object_map_id(port) in world.player_logic.shuffled_maps]
+
+    if len(shuffleable_ports) % 2 == 1:
+        # We have an odd number of shuffleable ports! Pick a port from a room that has more than one, and make it a
+        # redundant warp to another port.
+        redundant_rooms = set(room.id for room in world.static_logic.objects.rooms if len(room.ports) > 1)
+        redundant_ports = [port for port in shuffleable_ports if port.room_id in redundant_rooms]
+        chosen_port = world.random.choice(redundant_ports)
+
+        shuffleable_ports.remove(chosen_port)
+
+        chosen_destination = world.random.choice(shuffleable_ports)
+
+        world.port_pairings[chosen_port.id] = chosen_destination.id
+
+        from_region_name = world.static_logic.get_room_region_name(chosen_port.room_id)
+        to_region_name = world.static_logic.get_room_region_name(chosen_destination.room_id)
+
+        from_region = world.multiworld.get_region(from_region_name, world.player)
+        to_region = world.multiworld.get_region(to_region_name, world.player)
+
+        connection = Entrance(world.player, f"{from_region_name} - {chosen_port.display_name}", from_region)
+        from_region.exits.append(connection)
+        connection.connect(to_region)
+
+        if chosen_port.HasField("required_door"):
+            door_reqs = world.player_logic.get_door_open_reqs(chosen_port.required_door)
+            connection.access_rule = make_location_lambda(door_reqs, world, None)
+
+            for region in door_reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             connection)
 
+    for port in shuffleable_ports:
         port_region_name = world.static_logic.get_room_region_name(port.room_id)
         port_region = world.multiworld.get_region(port_region_name, world.player)
 
-        connection_name = f"{port_region_name} - {port.name}"
+        connection_name = f"{port_region_name} - {port.display_name}"
         port_id_by_name[connection_name] = port.id
 
         entrance = port_region.create_er_target(connection_name)
@@ -195,7 +236,7 @@ def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
         from_region = world.multiworld.get_region(from_region_name, world.player)
         to_region = world.multiworld.get_region(to_region_name, world.player)
 
-        connection = Entrance(world.player, f"{from_region_name} - {from_port.name}", from_region)
+        connection = Entrance(world.player, f"{from_region_name} - {from_port.display_name}", from_region)
 
         reqs = AccessRequirements()
         if from_port.HasField("required_door"):
@@ -1 +1 @@
-protobuf==3.20.3
+protobuf
@@ -15,6 +15,9 @@ class Lingo2StaticLogic:
 
     letter_weights: dict[str, int]
 
+    door_id_by_ap_id: dict[int, int]
+    port_id_by_ap_id: dict[int, int]
+
     def __init__(self):
         self.item_id_to_name = {}
         self.location_id_to_name = {}
@@ -68,6 +71,7 @@ class Lingo2StaticLogic:
                 self.location_name_groups.setdefault("Keyholders", []).append(location_name)
 
         self.item_id_to_name[self.objects.special_ids["A Job Well Done"]] = "A Job Well Done"
+        self.item_id_to_name[self.objects.special_ids["Numbers"]] = "Numbers"
 
         for symbol_name in SYMBOL_ITEMS.values():
             self.item_id_to_name[self.objects.special_ids[symbol_name]] = symbol_name
@@ -80,7 +84,11 @@ class Lingo2StaticLogic:
 
         for panel in self.objects.panels:
             for letter in panel.answer.upper():
-                self.letter_weights[letter] = self.letter_weights.get(letter, 0) + 1
+                if letter.isalpha():
+                    self.letter_weights[letter] = self.letter_weights.get(letter, 0) + 1
+
+        self.door_id_by_ap_id = {door.ap_id: door.id for door in self.objects.doors if door.HasField("ap_id")}
+        self.port_id_by_ap_id = {port.ap_id: port.id for port in self.objects.ports if port.HasField("ap_id")}
 
     def get_door_item_name(self, door: data_pb2.Door) -> str:
         return f"{self.get_map_object_map_name(door)} - {door.name}"
@@ -105,7 +113,7 @@ class Lingo2StaticLogic:
         if door.type != data_pb2.DoorType.STANDARD:
             return None
 
-        if len(door.keyholders) > 0 or len(door.endings) > 0 or door.HasField("complete_at"):
+        if len(door.keyholders) > 0 or door.white_ending or door.HasField("complete_at"):
             return None
 
         if len(door.panels) > 4:
@@ -166,6 +174,9 @@ class Lingo2StaticLogic:
         else:
             return game_map.display_name
 
+    def get_room_object_map_id(self, obj) -> int:
+        return self.objects.rooms[obj.room_id].map_id
+
     def get_data_version(self) -> list[int]:
         version = self.objects.version
         return [version.major, version.minor, version.patch]
@@ -1,6 +1,6 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterator
 
-from BaseClasses import MultiWorld, CollectionState, ItemClassification
+from BaseClasses import MultiWorld, CollectionState, ItemClassification, Region, Entrance
 from NetUtils import NetworkItem
 from . import Lingo2World, Lingo2Item
 from .regions import connect_ports_from_ut
@@ -47,7 +47,10 @@ class Tracker:
         self.world.create_regions()
 
         if self.world.options.shuffle_worldports:
-            port_pairings = {int(fp): int(tp) for fp, tp in slot_data["port_pairings"].items()}
+            port_pairings = {
+                self.world.static_logic.port_id_by_ap_id[int(fp)]: self.world.static_logic.port_id_by_ap_id[int(tp)]
+                for fp, tp in slot_data["port_pairings"].items()
+            }
             connect_ports_from_ut(port_pairings, self.world)
 
         self.refresh_state()
@@ -93,6 +96,7 @@ class Tracker:
                                           PLAYER_NUM), prevent_sweep=True)
 
         self.state.sweep_for_advancements()
+        self.state.update_reachable_regions(PLAYER_NUM)
 
         self.accessible_locations = set()
         self.accessible_worldports = set()
@@ -110,3 +114,34 @@ class Tracker:
                     elif hasattr(location, "goal") and location.goal:
                         if not self.manager.goaled:
                             self.goal_accessible = True
+
+    def get_path_to_location(self, location_id: int) -> list[str] | None:
+        location_name = self.world.location_id_to_name.get(location_id)
+        location = self.multiworld.get_location(location_name, PLAYER_NUM)
+        return self.get_logical_path(location.parent_region)
+
+    def get_path_to_port(self, port_id: int) -> list[str] | None:
+        port = self.world.static_logic.objects.ports[port_id]
+        region_name = self.world.static_logic.get_room_region_name(port.room_id)
+        region = self.multiworld.get_region(region_name, PLAYER_NUM)
+        return self.get_logical_path(region)
+
+    def get_path_to_goal(self):
+        room_id = self.world.player_logic.goal_room_id
+        region_name = self.world.static_logic.get_room_region_name(room_id)
+        region = self.multiworld.get_region(region_name, PLAYER_NUM)
+        return self.get_logical_path(region)
+
+    def get_logical_path(self, region: Region) -> list[str] | None:
+        if region not in self.state.path:
+            return None
+
+        def flist_to_iter(path_value) -> Iterator[str]:
+            while path_value:
+                region_or_entrance, path_value = path_value
+                yield region_or_entrance
+
+        reversed_path = self.state.path.get(region)
+        flat_path = reversed(list(map(str, flist_to_iter(reversed_path))))
+
+        return list(flat_path)[1::2]