70 files changed, 6563 insertions, 82 deletions

@@ -1,18 +1,40 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+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
+from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS
 from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
-from .regions import create_regions
+from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
 from .static_logic import Lingo2StaticLogic
+from worlds.LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
 
 
 class Lingo2WebWorld(WebWorld):
     rich_text_options_doc = True
     theme = "grass"
+    tutorials = [Tutorial(
+        "Multiworld Setup Guide",
+        "A guide to playing Lingo 2 with Archipelago.",
+        "English",
+        "en_Lingo_2.md",
+        "setup/en",
+        ["hatkirby"]
+    )]
+
+
+class Lingo2Settings(Group):
+    class ExecutableFile(UserFilePath):
+        """Path to the Lingo 2 executable"""
+        is_exe = True
+
+    exe_file: ExecutableFile = ExecutableFile()
+    start_game: bool = True
 
 
 class Lingo2World(World):
@@ -24,6 +46,9 @@ class Lingo2World(World):
     game = "Lingo 2"
     web = Lingo2WebWorld()
 
+    settings: ClassVar[Lingo2Settings]
+    settings_key = "lingo2_options"
+
     topology_present = True
 
     options_dataclass = Lingo2Options
@@ -32,18 +57,38 @@ class Lingo2World(World):
     static_logic = Lingo2StaticLogic()
     item_name_to_id = static_logic.item_name_to_id
     location_name_to_id = static_logic.location_name_to_id
+    item_name_groups = static_logic.item_name_groups
+    location_name_groups = static_logic.location_name_groups
+
+    for_tracker: ClassVar[bool] = False
 
     player_logic: Lingo2PlayerLogic
 
+    port_pairings: dict[int, int]
+
     def generate_early(self):
         self.player_logic = Lingo2PlayerLogic(self)
+        self.port_pairings = {}
 
     def create_regions(self):
         create_regions(self)
 
-        from Utils import visualize_regions
+    def connect_entrances(self):
+        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 = {
+                    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
 
-        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]
@@ -51,13 +96,33 @@ class Lingo2World(World):
         total_locations = sum(len(locs) for locs in self.player_logic.locations_by_room.values())
 
         item_difference = total_locations - len(pool)
+
+        if self.options.trap_percentage > 0:
+            num_traps = int(item_difference * self.options.trap_percentage / 100)
+            item_difference = item_difference - num_traps
+
+            trap_names = []
+            trap_weights = []
+            for letter_name, weight in self.static_logic.letter_weights.items():
+                trap_names.append(f"Anti {letter_name}")
+                trap_weights.append(weight)
+
+            bad_letters = self.random.choices(trap_names, weights=trap_weights, k=num_traps)
+            pool += [self.create_item(trap_name) for trap_name in bad_letters]
+
         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:
         return Lingo2Item(name, ItemClassification.filler if name == self.get_filler_item_name() else
+                                ItemClassification.trap if name in ANTI_COLLECTABLE_TRAPS else
                                 ItemClassification.progression,
                           self.item_name_to_id.get(name), self.player)
 
@@ -68,18 +133,54 @@ 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",
             "shuffle_letters",
+            "shuffle_symbols",
+            "shuffle_worldports",
+            "strict_cyan_ending",
+            "strict_purple_ending",
             "victory_condition",
         ]
 
-        slot_data = {
+        slot_data: dict[str, object] = {
             **self.options.as_dict(*slot_options),
+            "version": self.static_logic.get_data_version(),
         }
 
+        if self.options.shuffle_worldports:
+            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
 
     def get_filler_item_name(self) -> str:
         return "A Job Well Done"
+
+    # for the universal tracker, doesn't get called in standard gen
+    # docs: https://github.com/FarisTheAncient/Archipelago/blob/tracker/worlds/tracker/docs/re-gen-passthrough.md
+    @staticmethod
+    def interpret_slot_data(slot_data: dict[str, object]) -> dict[str, object]:
+        # returning slot_data so it regens, giving it back in multiworld.re_gen_passthrough
+        # we are using re_gen_passthrough over modifying the world here due to complexities with ER
+        return slot_data
+
+
+def launch_client(*args):
+    from .context import client_main
+    launch_component(client_main, name="Lingo2Client", args=args)
+
+
+icon_paths["lingo2_ico"] = f"ap:{__name__}/logo.png"
+component = Component("Lingo 2 Client", component_type=Type.CLIENT, func=launch_client,
+                      description="Open Lingo 2.", supports_uri=True, game_name="Lingo 2", icon="lingo2_ico")
+components.append(component)
@@ -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
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/listeners/animationListener.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()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,49 @@
+extends Node
+
+var apworld_reader
+
+
+func _init(path):
+        apworld_reader = ZIPReader.new()
+        apworld_reader.open(path)
+
+
+func _get_true_path(path):
+        if path.begins_with("../"):
+                return "lingo2/%s" % path.substr(3)
+        else:
+                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)
+
+        var script = GDScript.new()
+        script.source_code = apworld_reader.read_file(true_path).get_string_from_utf8()
+        script.reload()
+
+        return script
+
+
+func read_path(path):
+        var true_path = _get_true_path(path)
+        return apworld_reader.read_file(true_path)
+
+
+func load_script_as_scene(path, scene_name):
+        var script = load_script(path)
+        var instance = script.new()
+        instance.name = scene_name
+
+        get_tree().unload_current_scene()
+        _load_scene.call_deferred(instance)
+
+
+func _load_scene(instance):
+        get_tree().get_root().add_child(instance)
+        get_tree().current_scene = instance
@@ -0,0 +1,318 @@
+extends Node
+
+const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"}
+
+var SCRIPT_websocketserver
+
+var _server
+var _should_process = false
+
+var _remote_version = {"major": 0, "minor": 0, "build": 0}
+var _gen_version = {"major": 0, "minor": 0, "build": 0}
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+
+var _seed = ""
+var _team = 0
+var _slot = 0
+var _checked_locations = []
+var _checked_worldports = []
+var _received_indexes = []
+var _received_items = {}
+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
+signal client_connected(slot_data)
+signal item_received(item, amount)
+signal location_scout_received(location_id, item_name, player_name, flags, for_self)
+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():
+        set_process_mode(Node.PROCESS_MODE_ALWAYS)
+
+        global._print("Instantiated APClient")
+
+
+func _ready():
+        _server = SCRIPT_websocketserver.new()
+        _server.client_connected.connect(_on_web_socket_server_client_connected)
+        _server.client_disconnected.connect(_on_web_socket_server_client_disconnected)
+        _server.message_received.connect(_on_web_socket_server_message_received)
+        add_child(_server)
+        _server.listen(43182)
+
+
+func _reset_state():
+        _should_process = false
+        _received_items = {}
+        _received_indexes = []
+        _checked_worldports = []
+        _accessible_locations = []
+        _accessible_worldports = []
+        _goal_accessible = false
+
+
+func disconnect_from_ap():
+        sendMessage([{"cmd": "Disconnect"}])
+
+
+func _on_web_socket_server_client_connected(peer_id: int) -> void:
+        var peer: WebSocketPeer = _server.peers[peer_id]
+        print("Remote client connected: %d. Protocol: %s" % [peer_id, peer.get_selected_protocol()])
+        _server.send(-peer_id, "[%d] connected" % peer_id)
+
+
+func _on_web_socket_server_client_disconnected(peer_id: int) -> void:
+        var peer: WebSocketPeer = _server.peers[peer_id]
+        print(
+                (
+                        "Remote client disconnected: %d. Code: %d, Reason: %s"
+                        % [peer_id, peer.get_close_code(), peer.get_close_reason()]
+                )
+        )
+        _server.send(-peer_id, "[%d] disconnected" % peer_id)
+
+
+func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> void:
+        global._print("Got data from server: " + packet)
+        var json = JSON.new()
+        var jserror = json.parse(packet)
+        if jserror != OK:
+                global._print("Error parsing packet from AP: " + jserror.error_string)
+                return
+
+        for message in json.data:
+                var cmd = message["cmd"]
+                global._print("Received command: " + cmd)
+
+                if cmd == "Connected":
+                        _seed = message["seed_name"]
+                        _remote_version = message["version"]
+                        _gen_version = message["generator_version"]
+                        _team = message["team"]
+                        _slot = message["slot"]
+                        _slot_data = message["slot_data"]
+
+                        _checked_locations = []
+                        for location in message["checked_locations"]:
+                                _checked_locations.append(int(location))
+
+                        client_connected.emit(_slot_data)
+
+                elif cmd == "ConnectionRefused":
+                        could_not_connect.emit(message["text"])
+                        global._print("Connection to AP refused")
+
+                elif cmd == "UpdateLocations":
+                        for location in message["locations"]:
+                                var lint = int(location)
+                                if not _checked_locations.has(lint):
+                                        _checked_locations.append(lint)
+
+                        checked_locations_updated.emit()
+
+                elif cmd == "UpdateWorldports":
+                        for port_id in message["worldports"]:
+                                var lint = int(port_id)
+                                if not _checked_worldports.has(lint):
+                                        _checked_worldports.append(lint)
+
+                        checked_worldports_updated.emit()
+
+                elif cmd == "ItemReceived":
+                        for item in message["items"]:
+                                var index = int(item["index"])
+                                if _received_indexes.has(index):
+                                        # Do not re-process items.
+                                        continue
+
+                                _received_indexes.append(index)
+
+                                var item_id = int(item["id"])
+                                _received_items[item_id] = _received_items.get(item_id, 0) + 1
+
+                                item_received.emit(item, _received_items[item_id])
+
+                elif cmd == "TextMessage":
+                        text_message_received.emit(message["data"])
+
+                elif cmd == "ItemSentNotif":
+                        item_sent_notification.emit(message)
+
+                elif cmd == "HintReceived":
+                        hint_received.emit(message)
+
+                elif cmd == "LocationInfo":
+                        for loc in message["locations"]:
+                                location_scout_received.emit(
+                                        int(loc["id"]), loc["item"], loc["player"], int(loc["flags"]), int(loc["self"])
+                                )
+
+                elif cmd == "AccessibleLocations":
+                        _accessible_locations.clear()
+                        _accessible_worldports.clear()
+
+                        for loc in message["locations"]:
+                                _accessible_locations.append(int(loc))
+
+                        if "worldports" in message:
+                                for port_id in message["worldports"]:
+                                        _accessible_worldports.append(int(port_id))
+
+                        _goal_accessible = bool(message.get("goal", false))
+
+                        accessible_locations_updated.emit()
+
+                elif cmd == "UpdateKeyboard":
+                        var updates = {}
+                        for k in message["updates"]:
+                                updates[k] = int(message["updates"][k])
+
+                        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}])
+
+        ap_server = server
+        ap_user = un
+        ap_pass = pw
+
+        _should_process = true
+
+        connect_status.emit("Connecting...")
+
+
+func sendMessage(msg):
+        var payload = JSON.stringify(msg)
+        _server.send(0, payload)
+
+
+func connectToRoom():
+        connect_status.emit("Authenticating...")
+
+        sendMessage(
+                [
+                        {
+                                "cmd": "Connect",
+                                "password": ap_pass,
+                                "game": "Lingo 2",
+                                "name": ap_user,
+                        }
+                ]
+        )
+
+
+func requestSync():
+        sendMessage([{"cmd": "Sync"}])
+
+
+func sendLocation(loc_id):
+        sendMessage([{"cmd": "LocationChecks", "locations": [loc_id]}])
+
+
+func sendLocations(loc_ids):
+        sendMessage([{"cmd": "LocationChecks", "locations": loc_ids}])
+
+
+func say(textdata):
+        sendMessage([{"cmd": "Say", "text": textdata}])
+
+
+func completedGoal():
+        sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
+
+
+func scoutLocations(loc_ids):
+        sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}])
+
+
+func updateKeyboard(updates):
+        sendMessage([{"cmd": "UpdateKeyboard", "keyboard": updates}])
+
+
+func checkWorldport(port_id):
+        if not _checked_worldports.has(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"}])
+
+
+func hasItem(item_id):
+        return _received_items.has(item_id)
+
+
+func getItemAmount(item_id):
+        return _received_items.get(item_id, 0)
@@ -0,0 +1,16 @@
+extends "res://scripts/nodes/collectable.gd"
+
+
+func pickedUp():
+        if unlock_type == "key":
+                var ap = global.get_node("Archipelago")
+                if ap.get_letter_behavior(unlock_key, level == 2) == ap.kLETTER_BEHAVIOR_VANILLA:
+                        ap.keyboard.collect_local_letter(unlock_key, level)
+                else:
+                        ap.keyboard.update_unlocks()
+
+        super.pickedUp()
+
+
+func setScoutedText(text):
+        get_node("MeshInstance3D").mesh.text = text.replace(" ", "\n")
@@ -0,0 +1,66 @@
+extends Node2D
+
+const RADIUS = 48
+
+var _font
+
+
+func _ready():
+        _font = load("res://assets/fonts/Lingo2.ttf")
+
+
+func _draw():
+        draw_circle(Vector2.ZERO, RADIUS, Color(1.0, 1.0, 1.0, 0.8), true)
+        draw_circle(Vector2.ZERO, RADIUS, Color.BLACK, false)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "N",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI / 2)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "E",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "S",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI * 3.0 / 2.0)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "W",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO)
+        draw_colored_polygon(
+                PackedVector2Array(
+                        [Vector2(0, -RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)]
+                ),
+                Color.RED
+        )
+        draw_colored_polygon(
+                PackedVector2Array(
+                        [Vector2(0, RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)]
+                ),
+                Color.GRAY
+        )
@@ -0,0 +1,17 @@
+extends CanvasLayer
+
+var SCRIPT_compass
+
+var compass
+
+
+func _ready():
+        compass = SCRIPT_compass.new()
+        compass.position = Vector2(1840, 80)
+        add_child(compass)
+
+        visible = false
+
+
+func update_rotation(ry):
+        compass.rotation = ry
@@ -0,0 +1,75 @@
+extends "res://scripts/nodes/door.gd"
+
+var door_id
+var item_id
+var item_amount
+var latched = false
+
+
+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")
+        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")
+                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":
+                        senders = [NodePath("/root/scene/Panels/EndCheck_dog")]
+
+        if global.map == "the_parthenon":
+                if name == "spe_entry_1":
+                        senders = [NodePath("/root/scene/Panels/EndCheck_dog")]
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        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)
@@ -0,0 +1,302 @@
+extends Node
+
+var SCRIPT_proto
+
+var objects
+var door_id_by_map_node_path = {}
+var painting_id_by_map_node_path = {}
+var panel_id_by_map_node_path = {}
+var port_id_by_map_node_path = {}
+var door_id_by_ap_id = {}
+var map_id_by_name = {}
+var progressive_id_by_ap_id = {}
+var letter_id_by_ap_id = {}
+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
+
+
+func _init(proto_script):
+        SCRIPT_proto = proto_script
+
+        kSYMBOL_ITEMS = {
+                SCRIPT_proto.PuzzleSymbol.SUN: "Sun Symbol",
+                SCRIPT_proto.PuzzleSymbol.SPARKLES: "Sparkles Symbol",
+                SCRIPT_proto.PuzzleSymbol.ZERO: "Zero Symbol",
+                SCRIPT_proto.PuzzleSymbol.EXAMPLE: "Example Symbol",
+                SCRIPT_proto.PuzzleSymbol.BOXES: "Boxes Symbol",
+                SCRIPT_proto.PuzzleSymbol.PLANET: "Planet Symbol",
+                SCRIPT_proto.PuzzleSymbol.PYRAMID: "Pyramid Symbol",
+                SCRIPT_proto.PuzzleSymbol.CROSS: "Cross Symbol",
+                SCRIPT_proto.PuzzleSymbol.SWEET: "Sweet Symbol",
+                SCRIPT_proto.PuzzleSymbol.GENDER: "Gender Symbol",
+                SCRIPT_proto.PuzzleSymbol.AGE: "Age Symbol",
+                SCRIPT_proto.PuzzleSymbol.SOUND: "Sound Symbol",
+                SCRIPT_proto.PuzzleSymbol.ANAGRAM: "Anagram Symbol",
+                SCRIPT_proto.PuzzleSymbol.JOB: "Job Symbol",
+                SCRIPT_proto.PuzzleSymbol.STARS: "Stars Symbol",
+                SCRIPT_proto.PuzzleSymbol.NULL: "Null Symbol",
+                SCRIPT_proto.PuzzleSymbol.EVAL: "Eval Symbol",
+                SCRIPT_proto.PuzzleSymbol.LINGO: "Lingo Symbol",
+                SCRIPT_proto.PuzzleSymbol.QUESTION: "Question Symbol",
+        }
+
+
+func load(data_bytes):
+        objects = SCRIPT_proto.AllObjects.new()
+
+        var result_code = objects.from_bytes(data_bytes)
+        if result_code != SCRIPT_proto.PB_ERR.NO_ERRORS:
+                print("Could not load generated data: %d" % result_code)
+                return
+
+        for map in objects.get_maps():
+                map_id_by_name[map.get_name()] = map.get_id()
+
+        for door in objects.get_doors():
+                var map = objects.get_maps()[door.get_map_id()]
+
+                if not map.get_name() in door_id_by_map_node_path:
+                        door_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = door_id_by_map_node_path[map.get_name()]
+                for receiver in door.get_receivers():
+                        map_data[receiver] = door.get_id()
+
+                for painting_id in door.get_move_paintings():
+                        var painting = objects.get_paintings()[painting_id]
+                        map_data[painting.get_path()] = door.get_id()
+
+                if door.has_ap_id():
+                        door_id_by_ap_id[door.get_ap_id()] = door.get_id()
+
+                        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()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in painting_id_by_map_node_path:
+                        painting_id_by_map_node_path[map.get_name()] = {}
+
+                var _map_data = painting_id_by_map_node_path[map.get_name()]
+
+        for port in objects.get_ports():
+                var room = objects.get_rooms()[port.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in port_id_by_map_node_path:
+                        port_id_by_map_node_path[map.get_name()] = {}
+
+                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()
+
+        for letter in objects.get_letters():
+                letter_id_by_ap_id[letter.get_ap_id()] = letter.get_id()
+                location_name_by_id[letter.get_ap_id()] = _get_letter_location_name(letter)
+
+        for mastery in objects.get_masteries():
+                location_name_by_id[mastery.get_ap_id()] = _get_mastery_location_name(mastery)
+
+        for ending in objects.get_endings():
+                var location_name = _get_ending_location_name(ending)
+                location_name_by_id[ending.get_ap_id()] = location_name
+                ending_display_name_by_name[ending.get_name()] = location_name
+
+        for keyholder in objects.get_keyholders():
+                if keyholder.has_key():
+                        location_name_by_id[keyholder.get_ap_id()] = _get_keyholder_location_name(keyholder)
+
+        for panel in objects.get_panels():
+                var room = objects.get_rooms()[panel.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in panel_id_by_map_node_path:
+                        panel_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = panel_id_by_map_node_path[map.get_name()]
+                map_data[panel.get_path()] = panel.get_id()
+
+        for symbol_name in kSYMBOL_ITEMS.values():
+                symbol_item_ids.append(objects.get_special_ids()[symbol_name])
+
+        for special_name in objects.get_special_ids().keys():
+                if special_name.begins_with("Anti "):
+                        anti_trap_ids[objects.get_special_ids()[special_name]] = (
+                                special_name.substr(5).to_lower()
+                        )
+
+
+func get_door_for_map_node_path(map_name, node_path):
+        if not door_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = door_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_panel_for_map_node_path(map_name, node_path):
+        if not panel_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = panel_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_port_for_map_node_path(map_name, node_path):
+        if not port_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = port_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_door_ap_id(door_id):
+        var door = objects.get_doors()[door_id]
+        if door.has_ap_id():
+                return door.get_ap_id()
+        else:
+                return null
+
+
+func get_door_map_name(door_id):
+        var door = objects.get_doors()[door_id]
+        var map = objects.get_maps()[door.get_map_id()]
+        return map.get_name()
+
+
+func get_door_receivers(door_id):
+        var door = objects.get_doors()[door_id]
+        return door.get_receivers()
+
+
+func get_worldport_display_name(port_id):
+        var port = objects.get_ports()[port_id]
+        return "%s - %s" % [_get_room_object_map_name(port), port.get_display_name()]
+
+
+func _get_map_object_map_name(obj):
+        return objects.get_maps()[obj.get_map_id()].get_display_name()
+
+
+func _get_room_object_map_name(obj):
+        return _get_map_object_map_name(objects.get_rooms()[obj.get_room_id()])
+
+
+func _get_room_object_location_prefix(obj):
+        var room = objects.get_rooms()[obj.get_room_id()]
+        var game_map = objects.get_maps()[room.get_map_id()]
+
+        if room.has_panel_display_name():
+                return "%s (%s)" % [game_map.get_display_name(), room.get_panel_display_name()]
+        else:
+                return game_map.get_display_name()
+
+
+func _get_door_location_name(door):
+        var map_part = _get_room_object_location_prefix(door)
+
+        if door.has_location_name():
+                return "%s - %s" % [map_part, door.get_location_name()]
+
+        var generated_location_name = _get_generated_door_location_name(door)
+        if generated_location_name != null:
+                return generated_location_name
+
+        return "%s - %s" % [map_part, door.get_name()]
+
+
+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.has_white_ending() and door.get_white_ending())
+                or door.has_complete_at()
+        ):
+                return null
+
+        if door.get_panels().size() > 4:
+                return null
+
+        var map_areas = []
+        for panel_id in door.get_panels():
+                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.
+                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
+
+        var game_map = objects.get_maps()[door.get_map_id()]
+        var map_area = map_areas[0]
+        var map_part
+        if map_area == "":
+                map_part = game_map.get_display_name()
+        else:
+                map_part = "%s (%s)" % [game_map.get_display_name(), map_area]
+
+        var panel_names = []
+        for panel_id in door.get_panels():
+                var panel_data = objects.get_panels()[panel_id.get_panel()]
+                var panel_name
+                if panel_data.has_display_name():
+                        panel_name = panel_data.get_display_name()
+                else:
+                        panel_name = panel_data.get_name()
+
+                var location_part
+                if panel_id.has_answer():
+                        location_part = "%s/%s" % [panel_name, panel_id.get_answer().to_upper()]
+                else:
+                        location_part = panel_name
+
+                panel_names.append(location_part)
+
+        panel_names.sort()
+
+        return map_part + " - " + ", ".join(panel_names)
+
+
+func _get_letter_location_name(letter):
+        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]
+
+
+func _get_mastery_location_name(mastery):
+        return "%s - Mastery" % _get_room_object_map_name(mastery)
+
+
+func _get_ending_location_name(ending):
+        return (
+                "%s - %s Ending" % [_get_room_object_map_name(ending), ending.get_name().to_pascal_case()]
+        )
+
+
+func _get_keyholder_location_name(keyholder):
+        return (
+                "%s - %s Keyholder"
+                % [_get_room_object_location_prefix(keyholder), keyholder.get_key().to_upper()]
+        )
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/keyHolder.gd"
+
+
+func setFromAp(key, level):
+        if level > 0:
+                has_key = true
+                is_complete = "%s%d" % [key, level]
+                held_key = key
+                held_level = level
+                get_node("Hinge/Letter").mesh.text = held_key
+                get_node("Hinge/Letter2").mesh.text = held_key
+                setMaterial()
+                emit_signal("trigger")
+        else:
+                has_key = false
+                held_key = ""
+                held_level = 0
+                setMaterial()
+                get_node("Hinge/Letter").mesh.text = "-"
+                get_node("Hinge/Letter2").mesh.text = "-"
+                is_complete = ""
+                emit_signal("untrigger")
+
+
+func addKey(key):
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+        var ap = global.get_node("Archipelago")
+        ap.keyboard.put_in_keyholder(key, global.map, node_path)
+
+
+func removeKey():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+        var ap = global.get_node("Archipelago")
+        ap.keyboard.remove_from_keyholder(held_key, global.map, node_path)
@@ -0,0 +1,24 @@
+extends "res://scripts/nodes/listeners/keyHolderChecker.gd"
+
+
+func check():
+        var ap = global.get_node("Archipelago")
+        var matches = []
+        for map in ap.keyboard.keyholder_state.keys():
+                var nodes = ap.keyboard.keyholder_state[map]
+                for node in nodes.keys():
+                        matches.append([nodes[node], 1, map, "/root/scene/%s" % node])
+
+        var count = 0
+        for key_match in matches:
+                var active = (
+                        key_match[2] + String(key_match[3]).replace("/root/scene/Components/KeyHolders/", ".")
+                )
+                if map[active] == key_match[0]:
+                        emit_signal("trigger_letter", key_match[0], true)
+                        count += 1
+                else:
+                        emit_signal("trigger_letter", key_match[0], false)
+
+        if count > 25:
+                emit_signal("trigger")
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/keyHolderResetterListener.gd"
+
+
+func reset():
+        var ap = global.get_node("Archipelago")
+        var was_removed = ap.keyboard.reset_keyholders()
+        if was_removed:
+                sfxPlayer.sfx_play("pickup")
@@ -0,0 +1,231 @@
+extends Node
+
+const kALL_LETTERS = "abcdefghjiklmnopqrstuvwxyz"
+
+var letters_saved = {}
+var letters_in_keyholders = []
+var letters_blocked = []
+var letters_dynamic = {}
+var keyholder_state = {}
+
+var filename = ""
+
+
+func _init():
+        reset()
+
+
+func reset():
+        letters_saved.clear()
+        letters_in_keyholders.clear()
+        letters_blocked.clear()
+        letters_dynamic.clear()
+        keyholder_state.clear()
+
+
+func load_seed():
+        var ap = global.get_node("Archipelago")
+
+        reset()
+
+        filename = "user://archipelago_keys/%s_%d" % [ap.client._seed, ap.client._slot]
+
+        if FileAccess.file_exists(filename):
+                var ap_file = FileAccess.open(filename, FileAccess.READ)
+                var localdata = []
+                if ap_file != null:
+                        localdata = ap_file.get_var(true)
+                        ap_file.close()
+
+                if typeof(localdata) != TYPE_ARRAY:
+                        print("AP keyboard file is corrupted")
+                        localdata = []
+
+                if localdata.size() > 0:
+                        letters_saved = localdata[0]
+                if localdata.size() > 1:
+                        letters_in_keyholders = localdata[1]
+                if localdata.size() > 2:
+                        keyholder_state = localdata[2]
+
+        if not letters_saved.is_empty():
+                ap.client.updateKeyboard(letters_saved)
+
+        for k in kALL_LETTERS:
+                var level = 0
+
+                if ap.get_letter_behavior(k, false) == ap.kLETTER_BEHAVIOR_UNLOCKED:
+                        level += 1
+                if ap.get_letter_behavior(k, true) == ap.kLETTER_BEHAVIOR_UNLOCKED:
+                        level += 1
+
+                letters_dynamic[k] = level
+
+        update_unlocks()
+
+
+func save():
+        var dir = DirAccess.open("user://")
+        var folder = "archipelago_keys"
+        if not dir.dir_exists(folder):
+                dir.make_dir(folder)
+
+        var file = FileAccess.open(filename, FileAccess.WRITE)
+
+        var data = [
+                letters_saved,
+                letters_in_keyholders,
+                keyholder_state,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func update_unlocks():
+        unlocks.resetKeys()
+
+        var has_doubles = false
+
+        for k in kALL_LETTERS:
+                var level = 0
+
+                if not letters_in_keyholders.has(k):
+                        level = letters_saved.get(k, 0) + letters_dynamic.get(k, 0)
+
+                if level >= 2:
+                        level = 2
+                        has_doubles = true
+
+                if letters_blocked.has(k):
+                        level = 0
+
+                unlocks.unlockKey(k, level)
+
+        if has_doubles and unlocks.data["double_letters"] != "unlocked":
+                var ap = global.get_node("Archipelago")
+                if ap.cyan_door_behavior == ap.kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER:
+                        unlocks.setData("double_letters", "unlocked")
+
+
+func collect_local_letter(key, level):
+        var ap = global.get_node("Archipelago")
+        var true_level = 0
+
+        if ap.get_letter_behavior(key, false) == ap.kLETTER_BEHAVIOR_VANILLA:
+                true_level += 1
+        if level == 2 and ap.get_letter_behavior(key, true) == ap.kLETTER_BEHAVIOR_VANILLA:
+                true_level += 1
+
+        if true_level < letters_saved.get(key, 0):
+                return
+
+        letters_saved[key] = true_level
+
+        ap.client.updateKeyboard({key: true_level})
+
+        if letters_blocked.has(key):
+                letters_blocked.erase(key)
+
+        update_unlocks()
+        save()
+
+
+func collect_remote_letter(key, level):
+        if level < 0 or level > 2 or level < letters_dynamic.get(key, 0):
+                return
+
+        letters_dynamic[key] = level
+
+        if letters_blocked.has(key):
+                letters_blocked.erase(key)
+
+        update_unlocks()
+        save()
+
+
+func put_in_keyholder(key, map, kh_path):
+        if not keyholder_state.has(map):
+                keyholder_state[map] = {}
+
+        keyholder_state[map][kh_path] = key
+        letters_in_keyholders.append(key)
+
+        get_tree().get_root().get_node("scene").get_node(kh_path).setFromAp(
+                key, min(letters_saved.get(key, 0) + letters_dynamic.get(key, 0), 2)
+        )
+
+        update_unlocks()
+        save()
+
+
+func remove_from_keyholder(key, map, kh_path):
+        if not keyholder_state.has(map):
+                # This... shouldn't happen.
+                keyholder_state[map] = {}
+
+        keyholder_state[map].erase(kh_path)
+        letters_in_keyholders.erase(key)
+
+        get_tree().get_root().get_node("scene").get_node(kh_path).setFromAp(key, 0)
+
+        update_unlocks()
+        save()
+
+
+func block_letter(key):
+        if not letters_blocked.has(key):
+                letters_blocked.append(key)
+
+        update_unlocks()
+
+
+func load_keyholders(map):
+        if keyholder_state.has(map):
+                var khs = keyholder_state[map]
+
+                for path in khs.keys():
+                        var key = khs[path]
+                        get_tree().get_root().get_node("scene").get_node(path).setFromAp(
+                                key, min(letters_saved.get(key, 0) + letters_dynamic.get(key, 0), 2)
+                        )
+
+
+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):
+                for path in keyholder_state[global.map]:
+                        get_tree().get_root().get_node("scene").get_node(path).setFromAp(
+                                keyholder_state[global.map][path], 0
+                        )
+
+        keyholder_state.clear()
+        letters_in_keyholders.clear()
+        letters_blocked.clear()
+
+        update_unlocks()
+        save()
+
+        return cleared_anything
+
+
+func remote_keyboard_updated(updates):
+        var reverse = {}
+        var should_update = false
+
+        for k in updates:
+                if not letters_saved.has(k) or updates[k] > letters_saved[k]:
+                        letters_saved[k] = updates[k]
+                        should_update = true
+                elif updates[k] < letters_saved[k]:
+                        reverse[k] = letters_saved[k]
+
+        if should_update:
+                update_unlocks()
+
+        if not reverse.is_empty():
+                var ap = global.get_node("Archipelago")
+                ap.client.updateKeyboard(reverse)
@@ -0,0 +1,20 @@
+extends Receiver
+
+var location_id
+
+
+func _ready():
+        super._ready()
+
+
+func handleTriggered():
+        triggered += 1
+        if triggered >= total:
+                var ap = global.get_node("Archipelago")
+                ap.send_location(location_id)
+
+
+func handleUntriggered():
+        triggered -= 1
+        if triggered < total:
+                pass
@@ -0,0 +1,308 @@
+extends Node
+
+
+func _ready():
+        var runtime = global.get_node("Runtime")
+
+        # Some helpful logging.
+        if Steam.isSubscribed():
+                global._print("Provisioning successful! Build ID: %d" % Steam.getAppBuildId())
+        else:
+                global._print("Provisioning failed.")
+
+        # Undo the load screen removing our cursor
+        get_tree().get_root().set_disable_input(false)
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+
+        # Increase the WebSocket input buffer size so that we can download large
+        # data packages.
+        ProjectSettings.set_setting("network/limits/websocket_client/max_in_buffer_kb", 8192)
+
+        switcher.layer = 4
+
+        # Create the global AP manager, if it doesn't already exist.
+        if not global.has_node("Archipelago"):
+                var ap_script = runtime.load_script("manager.gd")
+                var ap_instance = ap_script.new()
+                ap_instance.name = "Archipelago"
+
+                ap_instance.SCRIPT_client = runtime.load_script("client.gd")
+                ap_instance.SCRIPT_keyboard = runtime.load_script("keyboard.gd")
+                ap_instance.SCRIPT_locationListener = runtime.load_script("locationListener.gd")
+                ap_instance.SCRIPT_minimap = runtime.load_script("minimap.gd")
+                ap_instance.SCRIPT_victoryListener = runtime.load_script("victoryListener.gd")
+                ap_instance.SCRIPT_websocketserver = runtime.load_script("vendor/WebSocketServer.gd")
+
+                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"))
+                installScriptExtension(runtime.load_script("keyHolder.gd"))
+                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"))
+
+                var proto_script = runtime.load_script("../generated/proto.gd")
+                var gamedata_script = runtime.load_script("gamedata.gd")
+                var gamedata_instance = gamedata_script.new(proto_script)
+                gamedata_instance.load(runtime.read_path("../generated/data.binpb"))
+                gamedata_instance.name = "Gamedata"
+                global.add_child(gamedata_instance)
+
+                var messages_script = runtime.load_script("messages.gd")
+                var messages_instance = messages_script.new()
+                messages_instance.name = "Messages"
+                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"
+                global.add_child(textclient_instance)
+
+                var compass_overlay_script = runtime.load_script("compass_overlay.gd")
+                var compass_overlay_instance = compass_overlay_script.new()
+                compass_overlay_instance.name = "Compass"
+                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)
+        ap.could_not_connect.connect(connectionUnsuccessful)
+        ap.connect_status.connect(connectionStatus)
+
+        # Populate textboxes with AP settings.
+        get_node("../Panel/server_box").text = ap.ap_server
+        get_node("../Panel/player_box").text = ap.ap_user
+        get_node("../Panel/password_box").text = ap.ap_pass
+
+        var history_box = get_node("../Panel/connection_history")
+        if ap.connection_history.is_empty():
+                history_box.disabled = true
+        else:
+                history_box.disabled = false
+
+                var i = 0
+                for details in ap.connection_history:
+                        history_box.get_popup().add_item("%s (%s)" % [details[1], details[0]], i)
+                        i += 1
+
+        history_box.get_popup().id_pressed.connect(historySelected)
+
+        # Show client version.
+        var version = gamedata.objects.get_version()
+        get_node("../Panel/title").text = (
+                "ARCHIPELAGO (%d.%d.%d)" % [version.get_major(), version.get_minor(), version.get_patch()]
+        )
+
+        # Increase font size in text boxes.
+        get_node("../Panel/server_box").add_theme_font_size_override("font_size", 36)
+        get_node("../Panel/player_box").add_theme_font_size_override("font_size", 36)
+        get_node("../Panel/password_box").add_theme_font_size_override("font_size", 36)
+
+        # Set up version mismatch dialog.
+        get_node("../Panel/VersionMismatch").confirmed.connect(startGame)
+        get_node("../Panel/VersionMismatch").get_cancel_button().pressed.connect(
+                versionMismatchDeclined
+        )
+
+        # Set up buttons.
+        get_node("../Panel/connect_button").pressed.connect(_connect_pressed)
+        get_node("../Panel/quit_button").pressed.connect(_back_pressed)
+
+
+func _connect_pressed():
+        get_node("../Panel/connect_button").disabled = true
+
+        var ap = global.get_node("Archipelago")
+        ap.ap_server = get_node("../Panel/server_box").text
+        ap.ap_user = get_node("../Panel/player_box").text
+        ap.ap_pass = get_node("../Panel/password_box").text
+        ap.saveSettings()
+
+        ap.connectToServer()
+
+
+func _back_pressed():
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+        ap.client.sendQuit()
+
+        get_tree().quit()
+
+
+# Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd
+func installScriptExtension(childScript: Resource):
+        # Force Godot to compile the script now.
+        # We need to do this here to ensure that the inheritance chain is
+        # properly set up, and multiple mods can chain-extend the same
+        # class multiple times.
+        # This is also needed to make Godot instantiate the extended class
+        # when creating singletons.
+        # The actual instance is thrown away.
+        childScript.new()
+
+        var parentScript = childScript.get_base_script()
+        var parentScriptPath = parentScript.resource_path
+        global._print("ModLoader: Installing script extension over %s" % parentScriptPath)
+        childScript.take_over_path(parentScriptPath)
+
+
+func connectionStatus(message):
+        var popup = get_node("../Panel/AcceptDialog")
+        popup.title = "Connecting to Archipelago"
+        popup.dialog_text = message
+        popup.exclusive = true
+        popup.get_ok_button().visible = false
+        popup.popup_centered()
+
+
+func connectionSuccessful():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        # Check for major version mismatch.
+        if ap.apworld_version[0] != gamedata.objects.get_version().get_major():
+                get_node("../Panel/AcceptDialog").exclusive = false
+
+                var popup = get_node("../Panel/VersionMismatch")
+                popup.title = "Version Mismatch!"
+                popup.dialog_text = (
+                        "This slot was generated using v%d.%d.%d of the Lingo 2 apworld,\nwhich has a different major version than this client (v%d.%d.%d).\nIt is highly recommended to play using the correct version of the client.\nYou may experience bugs or logic issues if you continue."
+                        % [
+                                ap.apworld_version[0],
+                                ap.apworld_version[1],
+                                ap.apworld_version[2],
+                                gamedata.objects.get_version().get_major(),
+                                gamedata.objects.get_version().get_minor(),
+                                gamedata.objects.get_version().get_patch()
+                        ]
+                )
+                popup.exclusive = true
+                popup.popup_centered()
+
+                return
+
+        startGame()
+
+
+func startGame():
+        var ap = global.get_node("Archipelago")
+
+        # Save connection details
+        var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass]
+        if ap.connection_history.has(connection_details):
+                ap.connection_history.erase(connection_details)
+        ap.connection_history.push_front(connection_details)
+        if ap.connection_history.size() > 10:
+                ap.connection_history.resize(10)
+        ap.saveSettings()
+
+        # Switch to the_entry
+        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+        global.user = ap.getSaveFileName()
+        global.universe = "lingo"
+        global.map = "the_entry"
+
+        unlocks.resetCollectables()
+        unlocks.resetData()
+        unlocks.loadCollectables()
+        unlocks.loadData()
+
+        ap.setup_keys()
+
+        unlocks.unlockKey("capslock", 1)
+
+        if ap.shuffle_worldports:
+                settings.worldport_fades = "default"
+        else:
+                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")
+        clearResourceCache("res://objects/nodes/listeners/animationListener.tscn")
+        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")
+        clearResourceCache("res://objects/nodes/player.tscn")
+        clearResourceCache("res://objects/nodes/saver.tscn")
+        clearResourceCache("res://objects/nodes/teleport.tscn")
+        clearResourceCache("res://objects/nodes/worldport.tscn")
+        clearResourceCache("res://objects/scenes/menus/pause_menu.tscn")
+
+        var paintings_dir = DirAccess.open("res://objects/meshes/paintings")
+        if paintings_dir:
+                paintings_dir.list_dir_begin()
+                var file_name = paintings_dir.get_next()
+                while file_name != "":
+                        if not paintings_dir.current_is_dir() and file_name.ends_with(".tscn"):
+                                clearResourceCache("res://objects/meshes/paintings/" + file_name)
+                        file_name = paintings_dir.get_next()
+
+        switcher.switch_map.call_deferred("res://objects/scenes/the_entry.tscn")
+
+
+func connectionUnsuccessful(error_message):
+        get_node("../Panel/connect_button").disabled = false
+
+        var popup = get_node("../Panel/AcceptDialog")
+        popup.title = "Could not connect to Archipelago"
+        popup.dialog_text = error_message
+        popup.exclusive = true
+        popup.get_ok_button().visible = true
+        popup.popup_centered()
+
+
+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")
+        var details = ap.connection_history[index]
+
+        get_node("../Panel/server_box").text = details[0]
+        get_node("../Panel/player_box").text = details[1]
+        get_node("../Panel/password_box").text = details[2]
+
+
+func clearResourceCache(path):
+        ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
@@ -0,0 +1,717 @@
+extends Node
+
+var SCRIPT_client
+var SCRIPT_keyboard
+var SCRIPT_locationListener
+var SCRIPT_minimap
+var SCRIPT_victoryListener
+var SCRIPT_websocketserver
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+var connection_history = []
+var show_compass = false
+var show_locations = false
+var show_minimap = false
+
+var client
+var keyboard
+
+var _localdata_file = ""
+var _last_new_item = -1
+var _batch_locations = false
+var _held_locations = []
+var _held_location_scouts = []
+var _location_scouts = {}
+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
+const kSHUFFLE_LETTERS_PROGRESSIVE = 2
+const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
+const kSHUFFLE_LETTERS_ITEM_CYAN = 4
+
+const kLETTER_BEHAVIOR_VANILLA = 0
+const kLETTER_BEHAVIOR_ITEM = 1
+const kLETTER_BEHAVIOR_UNLOCKED = 2
+
+const kCYAN_DOOR_BEHAVIOR_H2 = 0
+const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
+const kCYAN_DOOR_BEHAVIOR_ITEM = 2
+
+const kEndingNameByVictoryValue = {
+        0: "GRAY",
+        1: "PURPLE",
+        2: "MINT",
+        3: "BLACK",
+        4: "BLUE",
+        5: "CYAN",
+        6: "RED",
+        7: "PLUM",
+        8: "ORANGE",
+        9: "GOLD",
+        10: "YELLOW",
+        11: "GREEN",
+        12: "WHITE",
+}
+
+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
+var shuffle_gallery_paintings = false
+var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
+var shuffle_symbols = false
+var shuffle_worldports = false
+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
+
+
+func _init():
+        # Read AP settings from file, if there are any
+        if FileAccess.file_exists("user://ap_settings"):
+                var file = FileAccess.open("user://ap_settings", FileAccess.READ)
+                var data = file.get_var(true)
+                file.close()
+
+                if typeof(data) != TYPE_ARRAY:
+                        global._print("AP settings file is corrupted")
+                        data = []
+
+                if data.size() > 0:
+                        ap_server = data[0]
+
+                if data.size() > 1:
+                        ap_user = data[1]
+
+                if data.size() > 2:
+                        ap_pass = data[2]
+
+                if data.size() > 3:
+                        connection_history = data[3]
+
+                if data.size() > 4:
+                        show_compass = data[4]
+
+                if data.size() > 5:
+                        show_locations = data[5]
+
+                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()
+        client.SCRIPT_websocketserver = SCRIPT_websocketserver
+
+        client.item_received.connect(_process_item)
+        client.location_scout_received.connect(_process_location_scout)
+        client.text_message_received.connect(_process_text_message)
+        client.item_sent_notification.connect(_process_item_sent_notification)
+        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)
+        client.client_connected.connect(_client_connected)
+
+        add_child(client)
+
+        keyboard = SCRIPT_keyboard.new()
+        add_child(keyboard)
+        client.keyboard_update_received.connect(keyboard.remote_keyboard_updated)
+
+
+func saveSettings():
+        # Save the AP settings to disk.
+        var path = "user://ap_settings"
+        var file = FileAccess.open(path, FileAccess.WRITE)
+
+        var data = [
+                ap_server,
+                ap_user,
+                ap_pass,
+                connection_history,
+                show_compass,
+                show_locations,
+                show_minimap,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func saveLocaldata():
+        # Save the MW/slot specific settings to disk.
+        var dir = DirAccess.open("user://")
+        var folder = "archipelago_data"
+        if not dir.dir_exists(folder):
+                dir.make_dir(folder)
+
+        var file = FileAccess.open(_localdata_file, FileAccess.WRITE)
+
+        var data = [
+                _last_new_item,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func connectToServer():
+        _last_new_item = -1
+        _batch_locations = false
+        _held_locations = []
+        _held_location_scouts = []
+        _location_scouts = {}
+        _letters_setup = false
+        _held_letters = {}
+        _already_connected = false
+
+        client.connectToServer(ap_server, ap_user, ap_pass)
+
+
+func getSaveFileName():
+        return "zzAP_%s_%d" % [client._seed, client._slot]
+
+
+func disconnect_from_ap():
+        _already_connected = false
+
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
+        client.disconnect_from_ap()
+
+
+func get_item_id_for_door(door_id):
+        return _item_locks.get(door_id, null)
+
+
+func _process_item(item, amount):
+        var gamedata = global.get_node("Gamedata")
+
+        var item_id = int(item["id"])
+        var prog_id = null
+        if _inverse_item_locks.has(item_id):
+                for lock in _inverse_item_locks.get(item_id):
+                        if lock[1] != amount:
+                                continue
+
+                        if gamedata.progressive_id_by_ap_id.has(item_id):
+                                prog_id = lock[0]
+
+                        if gamedata.get_door_map_name(lock[0]) != global.map:
+                                continue
+
+                        # TODO: fix doors opening from door groups
+                        var receivers = gamedata.get_door_receivers(lock[0])
+                        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()
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(item_id, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                if not letter.has_level2() or not letter.get_level2():
+                        _process_key_item(letter.get_key(), amount)
+
+        if gamedata.symbol_item_ids.has(item_id):
+                var player = get_tree().get_root().get_node_or_null("scene/player")
+                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"])
+                saveLocaldata()
+
+                var full_item_name = item["text"]
+                if prog_id != null:
+                        var door = gamedata.objects.get_doors()[prog_id]
+                        full_item_name = "%s (%s)" % [full_item_name, door.get_name()]
+
+                var message
+                if "sender" in item:
+                        message = (
+                                "Received %s from %s"
+                                % [wrapInItemColorTags(full_item_name, item["flags"]), item["sender"]]
+                        )
+                else:
+                        message = "Found %s" % wrapInItemColorTags(full_item_name, item["flags"])
+
+                if gamedata.anti_trap_ids.has(item):
+                        keyboard.block_letter(gamedata.anti_trap_ids[item])
+
+                global._print(message)
+
+                global.get_node("Messages").showMessage(message)
+
+
+func _process_item_sent_notification(message):
+        var sentMsg = (
+                "Sent %s to %s"
+                % [
+                        wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                        message["receiver_name"]
+                ]
+        )
+        #if _hinted_locations.has(message["item"]["location"]):
+        #       sentMsg += " ([color=#fafad2]Hinted![/color])"
+        global.get_node("Messages").showMessage(sentMsg)
+
+
+func _process_hint_received(message):
+        var is_for = ""
+        if message["self"] == 0:
+                is_for = " for %s" % message["receiver_name"]
+
+        global.get_node("Messages").showMessage(
+                (
+                        "Hint: %s%s is on %s"
+                        % [
+                                wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                                is_for,
+                                message["location_name"]
+                        ]
+                )
+        )
+
+
+func _process_text_message(message):
+        var parts = []
+        for message_part in message:
+                if message_part["type"] == "text":
+                        parts.append(message_part["text"])
+                elif message_part["type"] == "player":
+                        if message_part["self"] == 1:
+                                parts.append("[color=#ee00ee]%s[/color]" % message_part["text"])
+                        else:
+                                parts.append("[color=#fafad2]%s[/color]" % message_part["text"])
+                elif message_part["type"] == "item":
+                        parts.append(wrapInItemColorTags(message_part["text"], int(message_part["flags"])))
+                elif message_part["type"] == "location":
+                        parts.append("[color=#00ff7f]%s[/color]" % message_part["text"])
+
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.parse_printjson("".join(parts))
+
+
+func _process_location_scout(location_id, item_name, player_name, flags, for_self):
+        _location_scouts[location_id] = {
+                "item": item_name, "player": player_name, "flags": flags, "for_self": for_self
+        }
+
+        if for_self and flags & 4 != 0:
+                # This is a trap for us, so let's not display it.
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        var map_id = gamedata.map_id_by_name.get(global.map)
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() == map_id:
+                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                letter.get_path()
+                        )
+                        if collectable != null:
+                                collectable.setScoutedText(item_name)
+
+
+func _on_accessible_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_checked_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations(false)
+
+
+func _on_checked_worldports_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+                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]
+        _last_new_item = -1
+
+        if FileAccess.file_exists(_localdata_file):
+                var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
+                var localdata = []
+                if ap_file != null:
+                        localdata = ap_file.get_var(true)
+                        ap_file.close()
+
+                if typeof(localdata) != TYPE_ARRAY:
+                        print("AP localdata file is corrupted")
+                        localdata = []
+
+                if localdata.size() > 0:
+                        _last_new_item = localdata[0]
+
+        # 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))
+        shuffle_letters = int(slot_data.get("shuffle_letters", 0))
+        shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
+        shuffle_worldports = bool(slot_data.get("shuffle_worldports", false))
+        strict_cyan_ending = bool(slot_data.get("strict_cyan_ending", false))
+        strict_purple_ending = bool(slot_data.get("strict_purple_ending", false))
+        victory_condition = int(slot_data.get("victory_condition", 0))
+
+        if slot_data.has("version"):
+                var version_msg = slot_data["version"]
+                apworld_version = [int(version_msg[0]), int(version_msg[1]), 0]
+                if version_msg.size() > 2:
+                        apworld_version[2] = int(version_msg[2])
+
+        port_pairings.clear()
+        if slot_data.has("port_pairings"):
+                var raw_pp = slot_data.get("port_pairings")
+
+                for p1 in raw_pp.keys():
+                        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 = {}
+
+        if shuffle_doors:
+                for door in gamedata.objects.get_doors():
+                        if (
+                                door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                        ):
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for progressive in gamedata.objects.get_progressives():
+                        for i in range(0, progressive.get_doors().size()):
+                                var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
+                                _item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]
+
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR:
+                                if shuffle_worldports:
+                                        continue
+                        elif door_group.get_type() != gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP:
+                                continue
+
+                        for door in door_group.get_doors():
+                                _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_control_center_colors:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for door_group in gamedata.objects.get_door_groups():
+                        if (
+                                door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR
+                                and not shuffle_worldports
+                        ):
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_gallery_paintings:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+        if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM:
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS:
+                                for door in door_group.get_doors():
+                                        if not _item_locks.has(door):
+                                                _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        # Create a reverse item locks map for processing items.
+        _inverse_item_locks = {}
+
+        for door_id in _item_locks.keys():
+                var lock = _item_locks.get(door_id)
+
+                if not _inverse_item_locks.has(lock[0]):
+                        _inverse_item_locks[lock[0]] = []
+
+                _inverse_item_locks[lock[0]].append([door_id, lock[1]])
+
+        if shuffle_worldports:
+                var textclient = global.get_node("Textclient")
+                textclient.setup_worldports()
+
+        ap_connected.emit()
+
+
+func start_batching_locations():
+        _batch_locations = true
+
+
+func send_location(loc_id):
+        if client._checked_locations.has(loc_id):
+                return
+
+        if _batch_locations:
+                _held_locations.append(loc_id)
+        else:
+                client.sendLocation(loc_id)
+
+
+func scout_location(loc_id):
+        if _location_scouts.has(loc_id):
+                return _location_scouts.get(loc_id)
+
+        if _batch_locations:
+                _held_location_scouts.append(loc_id)
+        else:
+                client.scoutLocation(loc_id)
+
+        return null
+
+
+func stop_batching_locations():
+        _batch_locations = false
+
+        if not _held_locations.is_empty():
+                client.sendLocations(_held_locations)
+                _held_locations.clear()
+
+        if not _held_location_scouts.is_empty():
+                client.scoutLocations(_held_location_scouts)
+                _held_location_scouts.clear()
+
+
+func colorForItemType(flags):
+        var int_flags = int(flags)
+        if int_flags & 1:  # progression
+                if int_flags & 2:  # proguseful
+                        return "#f0d200"
+                else:
+                        return "#bc51e0"
+        elif int_flags & 2:  # useful
+                return "#2b67ff"
+        elif int_flags & 4:  # trap
+                return "#d63a22"
+        else:  # filler
+                return "#14de9e"
+
+
+func wrapInItemColorTags(text, flags):
+        var int_flags = int(flags)
+        if int_flags & 1 and int_flags & 2:  # proguseful
+                return "[rainbow]%s[/rainbow]" % text
+        else:
+                return "[color=%s]%s[/color]" % [colorForItemType(flags), text]
+
+
+func get_letter_behavior(key, level2):
+        if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
+                return kLETTER_BEHAVIOR_UNLOCKED
+
+        if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
+                if level2:
+                        if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
+                                return kLETTER_BEHAVIOR_VANILLA
+                        else:
+                                return kLETTER_BEHAVIOR_ITEM
+                else:
+                        return kLETTER_BEHAVIOR_UNLOCKED
+
+        if not level2 and ["h", "i", "n", "t"].has(key):
+                # This differs from the equivalent function in the apworld. Logically it is
+                # the same as UNLOCKED since they are in the starting room, but VANILLA
+                # means the player still has to actually pick up the letters.
+                return kLETTER_BEHAVIOR_VANILLA
+
+        if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
+                return kLETTER_BEHAVIOR_ITEM
+
+        return kLETTER_BEHAVIOR_VANILLA
+
+
+func setup_keys():
+        keyboard.load_seed()
+
+        _letters_setup = true
+
+        for k in _held_letters.keys():
+                _process_key_item(k, _held_letters[k])
+
+        _held_letters.clear()
+
+
+func _process_key_item(key, level):
+        if not _letters_setup:
+                _held_letters[key] = max(_held_letters.get(key, 0), level)
+                return
+
+        if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN:
+                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)
@@ -0,0 +1,74 @@
+extends CanvasLayer
+
+var SCRIPT_rainbowText
+
+var _message_queue = []
+var _font
+var _container
+var _ordered_labels = []
+
+
+func _ready():
+        _container = VBoxContainer.new()
+        _container.set_name("Container")
+        _container.anchor_bottom = 1
+        _container.offset_left = 20.0
+        _container.offset_right = 1920.0
+        _container.offset_top = 0.0
+        _container.offset_bottom = -20.0
+        _container.alignment = BoxContainer.ALIGNMENT_END
+        _container.mouse_filter = Control.MOUSE_FILTER_IGNORE
+        self.add_child(_container)
+
+        _font = load("res://assets/fonts/Lingo2.ttf")
+
+
+func _add_message(text):
+        var new_label = RichTextLabel.new()
+        new_label.install_effect(SCRIPT_rainbowText.new())
+        new_label.push_font(_font)
+        new_label.push_font_size(36)
+        new_label.push_outline_color(Color(0, 0, 0, 1))
+        new_label.push_outline_size(2)
+        new_label.append_text(text)
+        new_label.fit_content = true
+
+        _container.add_child(new_label)
+        _ordered_labels.push_back(new_label)
+
+
+func showMessage(text):
+        if _ordered_labels.size() >= 9:
+                _message_queue.append(text)
+                return
+
+        _add_message(text)
+
+        if _ordered_labels.size() > 1:
+                return
+
+        var timeout = 10.0
+        while !_ordered_labels.is_empty():
+                await get_tree().create_timer(timeout).timeout
+
+                if !_ordered_labels.is_empty():
+                        var to_remove = _ordered_labels.pop_front()
+                        var to_tween = get_tree().create_tween().bind_node(to_remove)
+                        to_tween.tween_property(to_remove, "modulate:a", 0.0, 0.5)
+                        to_tween.tween_callback(to_remove.queue_free)
+
+                if !_message_queue.is_empty():
+                        var next_msg = _message_queue.pop_front()
+                        _add_message(next_msg)
+
+                if timeout > 4:
+                        timeout -= 3
+
+
+func clear():
+        _message_queue.clear()
+
+        for message_label in _ordered_labels:
+                message_label.queue_free()
+
+        _ordered_labels.clear()
@@ -0,0 +1,178 @@
+extends CanvasLayer
+
+var player
+var drawer
+var sprite
+var label
+
+var cell_left
+var cell_top
+var cell_right
+var cell_bottom
+var cell_width
+var cell_height
+var center_x_min
+var center_x_max
+var center_y_min
+var center_y_max
+
+
+func _ready():
+        player = get_tree().get_root().get_node("scene/player")
+
+        var svc = PanelContainer.new()
+        svc.anchor_left = 1.0
+        svc.anchor_top = 1.0
+        svc.anchor_right = 1.0
+        svc.anchor_bottom = 1.0
+        svc.offset_left = -320.0
+        svc.offset_top = -320.0
+        svc.offset_right = -64.0
+        svc.offset_bottom = -64.0
+        svc.clip_contents = true
+        add_child(svc)
+
+        var background_color = Color.WHITE
+
+        var world_env = get_tree().get_root().get_node("scene/WorldEnvironment")
+        if world_env != null and world_env.environment != null:
+                if world_env.environment.background_mode == Environment.BG_COLOR:
+                        background_color = world_env.environment.background_color
+                elif (
+                        world_env.environment.background_mode == Environment.BG_SKY
+                        and world_env.environment.sky != null
+                        and world_env.environment.sky.sky_material != null
+                ):
+                        var sky = world_env.environment.sky.sky_material
+                        if sky is PhysicalSkyMaterial:
+                                background_color = sky.ground_color
+                        elif sky is ProceduralSkyMaterial:
+                                background_color = sky.sky_top_color
+
+        var stylebox = StyleBoxFlat.new()
+        stylebox.bg_color = Color(background_color, 0.6)
+        svc.add_theme_stylebox_override("panel", stylebox)
+
+        drawer = Node2D.new()
+        svc.add_child(drawer)
+
+        var gridmap = get_tree().get_root().get_node("scene/GridMap")
+        if gridmap == null:
+                visible = false
+                return
+
+        cell_left = 0
+        cell_top = 0
+        cell_right = 0
+        cell_bottom = 0
+
+        for pos in gridmap.get_used_cells():
+                if pos.x < cell_left:
+                        cell_left = pos.x
+                if pos.x > cell_right:
+                        cell_right = pos.x
+                if pos.z < cell_top:
+                        cell_top = pos.z
+                if pos.z > cell_bottom:
+                        cell_bottom = pos.z
+
+        cell_width = cell_right - cell_left + 1
+        cell_height = cell_bottom - cell_top + 1
+
+        var rendered = _renderMap(gridmap)
+
+        var image_texture = ImageTexture.create_from_image(rendered)
+        sprite = Sprite2D.new()
+        sprite.texture = image_texture
+        sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
+        sprite.scale = Vector2(2, 2)
+        sprite.centered = false
+        drawer.add_child(sprite)
+
+        label = Label.new()
+        label.theme = preload("res://assets/themes/baseUI.tres")
+        label.add_theme_font_size_override("font_size", 32)
+        label.text = "@"
+        drawer.add_child(label)
+
+        #var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
+        #var global_tl = gridmap.to_global(local_tl)
+        #var local_br = gridmap.map_to_local(Vector3i(cell_right, 0, cell_bottom))
+        #var global_br = gridmap.to_global(local_br)
+
+        center_x_min = 0
+        center_x_max = cell_width - 128
+        center_y_min = 0
+        center_y_max = cell_height - 128
+
+        if center_x_max < center_x_min:
+                center_x_min = (center_x_min + center_x_max) / 2
+                center_x_max = center_x_min
+
+        if center_y_max < center_y_min:
+                center_y_min = (center_y_min + center_y_max) / 2
+                center_y_max = center_y_min
+
+
+func _process(_delta):
+        if visible == false:
+                return
+
+        drawer.position.x = clamp(player.position.x - cell_left - 64, center_x_min, center_x_max) * -2
+        drawer.position.y = clamp(player.position.z - cell_top - 64, center_y_min, center_y_max) * -2
+
+        label.position.x = (player.position.x - cell_left) * 2 - 16
+        label.position.y = (player.position.z - cell_top) * 2 - 16
+
+
+func _renderMap(gridmap):
+        var ap = global.get_node("Archipelago")
+        var heights = {}
+
+        var rendered = Image.create_empty(cell_width, cell_height, false, Image.FORMAT_RGBA8)
+        rendered.fill(Color.TRANSPARENT)
+
+        var meshes_node = get_tree().get_root().get_node("scene/Meshes")
+        if meshes_node != null:
+                _renderMeshNode(ap, gridmap, meshes_node, rendered)
+
+        for pos in gridmap.get_used_cells():
+                var in_plane = Vector2i(pos.x, pos.z)
+
+                if in_plane in heights and heights[in_plane] > pos.y:
+                        continue
+
+                heights[in_plane] = pos.y
+
+                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 = 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(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 = 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),
+                                min(mesh.position.z + mesh.scale.z / 2 - global_tl.z, cell_height)
+                        ):
+                                for x in range(
+                                        max(mesh.position.x - mesh.scale.x / 2 - global_tl.x, 0),
+                                        min(mesh.position.x + mesh.scale.x / 2 - global_tl.x, cell_width)
+                                ):
+                                        rendered.set_pixel(x, y, mesh_color)
+
+        for child in mesh.get_children():
+                _renderMeshNode(ap, gridmap, child, rendered)
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/painting.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()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -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()
@@ -0,0 +1,101 @@
+extends "res://scripts/nodes/panel.gd"
+
+var panel_logic = null
+var symbol_solvable = true
+
+var black = load("res://assets/materials/black.material")
+
+
+func _ready():
+        super._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 panel_id = gamedata.get_panel_for_map_node_path(global.map, node_path)
+        if panel_id != null:
+                var ap = global.get_node("Archipelago")
+                if ap.shuffle_symbols:
+                        if global.map == "the_entry" and node_path == "Panels/Entry/front_1":
+                                clue = "i"
+                                symbol = ""
+
+                                setField("clue", clue)
+                                setField("symbol", symbol)
+
+                panel_logic = gamedata.objects.get_panels()[panel_id]
+                checkSymbolSolvable()
+
+                if not symbol_solvable:
+                        get_tree().get_root().get_node("scene/player").evaluate_solvability.connect(
+                                evaluateSolvability
+                        )
+
+
+func checkSymbolSolvable():
+        var old_solvable = symbol_solvable
+        symbol_solvable = true
+
+        if panel_logic == null:
+                # There's no logic for this panel.
+                return
+
+        var ap = global.get_node("Archipelago")
+        if not ap.shuffle_symbols:
+                # Symbols aren't item-locked.
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        for symbol in panel_logic.get_symbols():
+                var item_name = gamedata.kSYMBOL_ITEMS.get(symbol)
+                var item_id = gamedata.objects.get_special_ids()[item_name]
+                if ap.client.getItemAmount(item_id) < 1:
+                        symbol_solvable = false
+                        break
+
+        if symbol_solvable != old_solvable:
+                if symbol_solvable:
+                        setField("clue", clue)
+                        setField("symbol", symbol)
+                        setField("answer", answer)
+                else:
+                        quad_mesh.surface_set_material(0, black)
+                        get_node("Hinge/clue").text = "missing"
+                        get_node("Hinge/answer").text = "symbols"
+
+
+func checkSolvable(key):
+        checkSymbolSolvable()
+        if not symbol_solvable:
+                return false
+
+        return super.checkSolvable(key)
+
+
+func evaluateSolvability():
+        checkSolvable("")
+
+
+func passedInput(key, skip_focus_check = false):
+        if not symbol_solvable:
+                return
+
+        super.passedInput(key, skip_focus_check)
+
+
+func focus():
+        if not symbol_solvable:
+                has_focus = false
+                return
+
+        super.focus()
+
+
+func unfocus():
+        if not symbol_solvable:
+                has_focus = false
+                return
+
+        super.unfocus()
@@ -0,0 +1,91 @@
+extends "res://scripts/ui/pauseMenu.gd"
+
+var compass_button
+var locations_button
+var minimap_button
+
+
+func _ready():
+        var ap_panel = Panel.new()
+        ap_panel.name = "Archipelago"
+        get_node("menu/settings/settingsInner/TabContainer").add_child(ap_panel)
+
+        var ap = global.get_node("Archipelago")
+
+        compass_button = CheckBox.new()
+        compass_button.text = "show compass"
+        compass_button.button_pressed = ap.show_compass
+        compass_button.position = Vector2(65, 100)
+        compass_button.theme = preload("res://assets/themes/baseUI.tres")
+        compass_button.add_theme_font_size_override("font_size", 60)
+        compass_button.pressed.connect(_toggle_compass)
+        ap_panel.add_child(compass_button)
+
+        locations_button = CheckBox.new()
+        locations_button.text = "show locations overlay"
+        locations_button.button_pressed = ap.show_locations
+        locations_button.position = Vector2(65, 200)
+        locations_button.theme = preload("res://assets/themes/baseUI.tres")
+        locations_button.add_theme_font_size_override("font_size", 60)
+        locations_button.pressed.connect(_toggle_locations)
+        ap_panel.add_child(locations_button)
+
+        minimap_button = CheckBox.new()
+        minimap_button.text = "show minimap"
+        minimap_button.button_pressed = ap.show_minimap
+        minimap_button.position = Vector2(65, 300)
+        minimap_button.theme = preload("res://assets/themes/baseUI.tres")
+        minimap_button.add_theme_font_size_override("font_size", 60)
+        minimap_button.pressed.connect(_toggle_minimap)
+        ap_panel.add_child(minimap_button)
+
+        super._ready()
+
+
+func _pause_game():
+        global.get_node("Textclient").dismiss()
+        super._pause_game()
+
+
+func _main_menu():
+        global.loaded = false
+        global.get_node("Archipelago").disconnect_from_ap()
+        global.get_node("Messages").clear()
+        global.get_node("Compass").visible = false
+        global.get_node("Textclient").reset()
+
+        autosplitter.reset()
+        _unpause_game()
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+        musicPlayer.stop()
+
+        var runtime = global.get_node("Runtime")
+        runtime.load_script_as_scene.call_deferred("settings_screen.gd", "settings_screen")
+
+
+func _toggle_compass():
+        var ap = global.get_node("Archipelago")
+        ap.show_compass = compass_button.button_pressed
+        ap.saveSettings()
+
+        var compass = global.get_node("Compass")
+        compass.visible = compass_button.button_pressed
+
+
+func _toggle_locations():
+        var ap = global.get_node("Archipelago")
+        ap.show_locations = locations_button.button_pressed
+        ap.saveSettings()
+
+        var textclient = global.get_node("Textclient")
+        textclient.update_locations_visibility()
+
+
+func _toggle_minimap():
+        var ap = global.get_node("Archipelago")
+        ap.show_minimap = minimap_button.button_pressed
+        ap.saveSettings()
+
+        var minimap = get_tree().get_root().get_node("scene/Minimap")
+        if minimap != null:
+                minimap.visible = ap.show_minimap
@@ -0,0 +1,181 @@
+extends "res://scripts/nodes/player.gd"
+
+signal evaluate_solvability
+
+var compass
+
+
+func _ready():
+        var khl_script = load("res://scripts/nodes/keyHolderListener.gd")
+
+        var pause_menu = get_node("pause_menu")
+        pause_menu.layer = 3
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        compass = global.get_node("Compass")
+        compass.visible = ap.show_compass
+
+        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():
+                if door.get_map_id() != map_id:
+                        continue
+
+                if not door.has_ap_id():
+                        continue
+
+                if (
+                        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
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = door.get_ap_id()
+                locationListener.name = "locationListener_%d" % door.get_ap_id()
+
+                for panel_ref in door.get_panels():
+                        var panel_data = gamedata.objects.get_panels()[panel_ref.get_panel()]
+                        var panel_path = panel_data.get_path()
+
+                        if panel_ref.has_answer():
+                                for proxy in panel_data.get_proxies():
+                                        if proxy.get_answer() == panel_ref.get_answer():
+                                                panel_path = proxy.get_path()
+                                                break
+
+                        locationListener.senders.append(NodePath("/root/scene/" + panel_path))
+
+                for keyholder_ref in door.get_keyholders():
+                        var keyholder_data = gamedata.objects.get_keyholders()[keyholder_ref.get_keyholder()]
+
+                        var khl = khl_script.new()
+                        khl.name = (
+                                "location_%d_keyholder_%d" % [door.get_ap_id(), keyholder_ref.get_keyholder()]
+                        )
+                        khl.answer = keyholder_ref.get_key()
+                        khl.senders.append(NodePath("/root/scene/" + keyholder_data.get_path()))
+                        get_parent().add_child.call_deferred(khl)
+
+                        locationListener.senders.append(NodePath("../" + khl.name))
+
+                for sender in door.get_senders():
+                        locationListener.senders.append(NodePath("/root/scene/" + sender))
+
+                if door.has_complete_at():
+                        locationListener.complete_at = door.get_complete_at()
+
+                get_parent().add_child.call_deferred(locationListener)
+
+        # Set up letter locations.
+        for letter in gamedata.objects.get_letters():
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = letter.get_ap_id()
+                locationListener.name = "locationListener_%d" % letter.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + letter.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+                if (
+                        ap.get_letter_behavior(letter.get_key(), letter.has_level2() and letter.get_level2())
+                        != ap.kLETTER_BEHAVIOR_VANILLA
+                ):
+                        var scout = ap.scout_location(letter.get_ap_id())
+                        if scout != null and not (scout["for_self"] and scout["flags"] & 4 != 0):
+                                var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                        letter.get_path()
+                                )
+                                if collectable != null:
+                                        collectable.setScoutedText.call_deferred(scout["item"])
+
+        # Set up mastery locations.
+        for mastery in gamedata.objects.get_masteries():
+                var room = gamedata.objects.get_rooms()[mastery.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = mastery.get_ap_id()
+                locationListener.name = "locationListener_%d" % mastery.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + mastery.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+        # Set up ending locations.
+        for ending in gamedata.objects.get_endings():
+                var room = gamedata.objects.get_rooms()[ending.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = ending.get_ap_id()
+                locationListener.name = "locationListener_%d" % ending.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + ending.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+                if ap.kEndingNameByVictoryValue.get(ap.victory_condition, null) == ending.get_name():
+                        var victoryListener = ap.SCRIPT_victoryListener.new()
+                        victoryListener.name = "victoryListener"
+                        victoryListener.senders.append(NodePath("/root/scene/" + ending.get_path()))
+
+                        get_parent().add_child.call_deferred(victoryListener)
+
+        # Set up keyholder locations, in keyholder sanity.
+        if ap.keyholder_sanity:
+                for keyholder in gamedata.objects.get_keyholders():
+                        if not keyholder.has_key():
+                                continue
+
+                        var room = gamedata.objects.get_rooms()[keyholder.get_room_id()]
+                        if room.get_map_id() != map_id:
+                                continue
+
+                        var locationListener = ap.SCRIPT_locationListener.new()
+                        locationListener.location_id = keyholder.get_ap_id()
+                        locationListener.name = "locationListener_%d" % keyholder.get_ap_id()
+
+                        var khl = khl_script.new()
+                        khl.name = "location_%d_keyholder" % keyholder.get_ap_id()
+                        khl.answer = keyholder.get_key()
+                        khl.senders.append(NodePath("/root/scene/" + keyholder.get_path()))
+                        get_parent().add_child.call_deferred(khl)
+
+                        locationListener.senders.append(NodePath("../" + khl.name))
+
+                        get_parent().add_child.call_deferred(locationListener)
+
+        var minimap = ap.SCRIPT_minimap.new()
+        minimap.name = "Minimap"
+        minimap.visible = ap.show_minimap
+        get_parent().add_child.call_deferred(minimap)
+
+        super._ready()
+
+        await get_tree().process_frame
+        await get_tree().process_frame
+
+        ap.stop_batching_locations()
+
+
+func _process(_dt):
+        compass.update_rotation(global_rotation.y)
@@ -0,0 +1,10 @@
+extends RichTextEffect
+
+var bbcode = "rainbow"
+
+
+func _process_custom_fx(char_fx: CharFXTransform):
+        char_fx.color = Color.from_hsv(
+                char_fx.elapsed_time - floor(char_fx.elapsed_time), 1.0, 1.0, 1.0
+        )
+        return true
@@ -0,0 +1,30 @@
+[gd_scene load_steps=11 format=2]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+
+func _ready():
+        var args = OS.get_cmdline_user_args()
+        var apworld_path = args[0]
+
+        var zip_reader = ZIPReader.new()
+        zip_reader.open(apworld_path)
+        
+        var runtime_script = GDScript.new()
+        runtime_script.source_code = zip_reader.read_file(\"lingo2/client/apworld_runtime.gd\").get_string_from_utf8()
+        runtime_script.reload()
+
+        zip_reader.close()
+
+        var runtime = runtime_script.new(apworld_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+"
+
+[node name="loader" type="Node2D"]
+script = SubResource( 2 )
@@ -0,0 +1,22 @@
+[gd_scene load_steps=11 format=2]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+
+func _ready():
+        var args = OS.get_cmdline_user_args()
+        var source_path = args[0]
+
+        var runtime_script = ResourceLoader.load(\"%s/source_runtime.gd\" % source_path)
+        var runtime = runtime_script.new(source_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+"
+
+[node name="loader" type="Node2D"]
+script = SubResource( 2 )
@@ -0,0 +1,23 @@
+extends "res://scripts/nodes/saver.gd"
+
+
+func levelLoaded():
+        if type == "keyholders":
+                var ap = global.get_node("Archipelago")
+                ap.keyboard.load_keyholders.call_deferred(global.map)
+        else:
+                reload.call_deferred()
+
+
+func reload():
+        # Just rewriting this whole thing so I can remove Chris's safeguard.
+        var file = FileAccess.open(path + type + ".save", FileAccess.READ)
+        if file:
+                var data = file.get_var(true)
+                file.close()
+                for datum in data:
+                        var saveable = get_node_or_null(datum[0])
+                        if saveable != null:
+                                saveable.is_complete = datum[1]
+                                if saveable.is_complete:
+                                        saveable.loadData(saveable.is_complete)
@@ -0,0 +1,149 @@
+extends Node
+
+
+func _ready():
+        var theme = preload("res://assets/themes/baseUI.tres")
+
+        var simple_style_box = StyleBoxFlat.new()
+        simple_style_box.bg_color = Color(0, 0, 0, 0)
+
+        var panel = Panel.new()
+        panel.name = "Panel"
+        panel.offset_right = 1920.0
+        panel.offset_bottom = 1080.0
+        add_child(panel)
+
+        var title = Label.new()
+        title.name = "title"
+        title.offset_left = 0.0
+        title.offset_top = 75.0
+        title.offset_right = 1920.0
+        title.offset_bottom = 225.0
+        title.text = "ARCHIPELAGO"
+        title.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+        title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        title.theme = theme
+        panel.add_child(title)
+
+        var connect_button = Button.new()
+        connect_button.name = "connect_button"
+        connect_button.offset_left = 255.0
+        connect_button.offset_top = 875.0
+        connect_button.offset_right = 891.0
+        connect_button.offset_bottom = 1025.0
+        connect_button.add_theme_color_override("font_color_hover", Color(1, 0.501961, 0, 1))
+        connect_button.text = "CONNECT"
+        connect_button.theme = theme
+        panel.add_child(connect_button)
+
+        var quit_button = Button.new()
+        quit_button.name = "quit_button"
+        quit_button.offset_left = 1102.0
+        quit_button.offset_top = 875.0
+        quit_button.offset_right = 1738.0
+        quit_button.offset_bottom = 1025.0
+        quit_button.add_theme_color_override("font_color_hover", Color(1, 0, 0, 1))
+        quit_button.text = "QUIT"
+        quit_button.theme = theme
+        panel.add_child(quit_button)
+
+        var credit2 = Label.new()
+        credit2.name = "credit2"
+        credit2.offset_left = -105.0
+        credit2.offset_top = 346.0
+        credit2.offset_right = 485.0
+        credit2.offset_bottom = 410.0
+        credit2.add_theme_stylebox_override("normal", simple_style_box)
+        credit2.text = "SERVER"
+        credit2.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit2.theme = theme
+        panel.add_child(credit2)
+
+        var credit3 = Label.new()
+        credit3.name = "credit3"
+        credit3.offset_left = -105.0
+        credit3.offset_top = 519.0
+        credit3.offset_right = 485.0
+        credit3.offset_bottom = 583.0
+        credit3.add_theme_stylebox_override("normal", simple_style_box)
+        credit3.text = "PLAYER"
+        credit3.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit3.theme = theme
+        panel.add_child(credit3)
+
+        var credit4 = Label.new()
+        credit4.name = "credit4"
+        credit4.offset_left = -105.0
+        credit4.offset_top = 704.0
+        credit4.offset_right = 485.0
+        credit4.offset_bottom = 768.0
+        credit4.add_theme_stylebox_override("normal", simple_style_box)
+        credit4.text = "PASSWORD"
+        credit4.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit4.theme = theme
+        panel.add_child(credit4)
+
+        var credit5 = Label.new()
+        credit5.name = "credit5"
+        credit5.offset_left = 1239.0
+        credit5.offset_top = 422.0
+        credit5.offset_right = 1829.0
+        credit5.offset_bottom = 486.0
+        credit5.add_theme_stylebox_override("normal", simple_style_box)
+        credit5.text = "OPTIONS"
+        credit5.theme = theme
+        panel.add_child(credit5)
+
+        var server_box = LineEdit.new()
+        server_box.name = "server_box"
+        server_box.offset_left = 502.0
+        server_box.offset_top = 295.0
+        server_box.offset_right = 1144.0
+        server_box.offset_bottom = 445.0
+        server_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
+        server_box.caret_blink = true
+        panel.add_child(server_box)
+
+        var player_box = LineEdit.new()
+        player_box.name = "player_box"
+        player_box.offset_left = 502.0
+        player_box.offset_top = 477.0
+        player_box.offset_right = 1144.0
+        player_box.offset_bottom = 627.0
+        player_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
+        player_box.caret_blink = true
+        panel.add_child(player_box)
+
+        var password_box = LineEdit.new()
+        password_box.name = "password_box"
+        password_box.offset_left = 502.0
+        password_box.offset_top = 659.0
+        password_box.offset_right = 1144.0
+        password_box.offset_bottom = 809.0
+        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"
+        panel.add_child(accept_dialog)
+
+        var version_mismatch = ConfirmationDialog.new()
+        version_mismatch.name = "VersionMismatch"
+        panel.add_child(version_mismatch)
+
+        var connection_history = MenuButton.new()
+        connection_history.name = "connection_history"
+        connection_history.offset_left = 1239.0
+        connection_history.offset_top = 276.0
+        connection_history.offset_right = 1829.0
+        connection_history.offset_bottom = 372.0
+        connection_history.text = "connection history"
+        connection_history.flat = false
+        panel.add_child(connection_history)
+
+        var runtime = global.get_node("Runtime")
+        var main_script = runtime.load_script("main.gd")
+        var main_node = main_script.new()
+        main_node.name = "Main"
+        add_child(main_node)
@@ -0,0 +1,33 @@
+extends Node
+
+var source_path
+
+
+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])
+
+
+func read_path(path):
+        return FileAccess.get_file_as_bytes("%s/%s" % [source_path, path])
+
+
+func load_script_as_scene(path, scene_name):
+        var script = load_script(path)
+        var instance = script.new()
+        instance.name = scene_name
+
+        get_tree().unload_current_scene()
+        _load_scene.call_deferred(instance)
+
+
+func _load_scene(instance):
+        get_tree().get_root().add_child(instance)
+        get_tree().current_scene = instance
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/teleport.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()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,49 @@
+extends "res://scripts/nodes/listeners/teleportListener.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()
+        )
+
+        if (
+                global.map == "daedalus"
+                and (
+                        node_path == "Components/Triggers/teleportListenerConnections"
+                        or node_path == "Components/Triggers/teleportListenerConnections2"
+                )
+        ):
+                # Effectively disable these.
+                teleport_point = target_path.position
+                return
+
+        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()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,508 @@
+extends CanvasLayer
+
+var tabs
+var panel
+var label
+var entry
+var is_open = false
+
+var locations_overlay
+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
+        layer = 2
+
+        locations_overlay = RichTextLabel.new()
+        locations_overlay.name = "LocationsOverlay"
+        locations_overlay.offset_top = 220
+        locations_overlay.offset_bottom = 720
+        locations_overlay.offset_left = 20
+        locations_overlay.anchor_right = 1.0
+        locations_overlay.offset_right = -10
+        locations_overlay.scroll_active = false
+        locations_overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
+        locations_overlay.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
+        add_child(locations_overlay)
+        update_locations_visibility()
+
+        tabs = TabContainer.new()
+        tabs.name = "Tabs"
+        tabs.offset_left = 100
+        tabs.offset_right = 1820
+        tabs.offset_top = 100
+        tabs.offset_bottom = 980
+        tabs.visible = false
+        tabs.theme = preload("res://assets/themes/baseUI.tres")
+        tabs.add_theme_font_size_override("font_size", 36)
+        add_child(tabs)
+
+        panel = MarginContainer.new()
+        panel.name = "Text Client"
+        panel.add_theme_constant_override("margin_top", 60)
+        panel.add_theme_constant_override("margin_left", 60)
+        panel.add_theme_constant_override("margin_right", 60)
+        panel.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(panel)
+
+        label = RichTextLabel.new()
+        label.set_name("Label")
+        label.scroll_following = true
+        label.selection_enabled = true
+        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(30)
+
+        var entry_style = StyleBoxFlat.new()
+        entry_style.bg_color = Color(0.9, 0.9, 0.9, 1)
+
+        entry = LineEdit.new()
+        entry.set_name("Entry")
+        entry.add_theme_font_override("font", preload("res://assets/fonts/Lingo2.ttf"))
+        entry.add_theme_font_size_override("font_size", 36)
+        entry.add_theme_color_override("font_color", Color(0, 0, 0, 1))
+        entry.add_theme_color_override("cursor_color", Color(0, 0, 0, 1))
+        entry.add_theme_stylebox_override("focus", entry_style)
+        entry.text_submitted.connect(text_entered)
+
+        var tc_arranger = VBoxContainer.new()
+        tc_arranger.add_child(label)
+        tc_arranger.add_child(entry)
+        tc_arranger.add_theme_constant_override("separation", 40)
+        panel.add_child(tc_arranger)
+
+        var tracker_margins = MarginContainer.new()
+        tracker_margins.name = "Locations"
+        tracker_margins.add_theme_constant_override("margin_top", 60)
+        tracker_margins.add_theme_constant_override("margin_left", 60)
+        tracker_margins.add_theme_constant_override("margin_right", 60)
+        tracker_margins.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(tracker_margins)
+
+        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"
+        worldports_tab.add_theme_constant_override("margin_top", 60)
+        worldports_tab.add_theme_constant_override("margin_left", 60)
+        worldports_tab.add_theme_constant_override("margin_right", 60)
+        worldports_tab.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(worldports_tab)
+        tabs.set_tab_hidden(2, true)
+
+        worldports_tree = Tree.new()
+        worldports_tree.columns = 2
+        worldports_tree.hide_root = true
+        worldports_tree.theme = preload("res://assets/themes/baseUI.tres")
+        worldports_tree.add_theme_font_size_override("font_size", 24)
+        worldports_tab.add_child(worldports_tree)
+
+        var runtime = global.get_node("Runtime")
+        var location_image = Image.new()
+        location_image.load_png_from_buffer(runtime.read_path("assets/location.png"))
+        location_texture = ImageTexture.create_from_image(location_image)
+
+        var worldport_image = Image.new()
+        worldport_image.load_png_from_buffer(runtime.read_path("assets/worldport.png"))
+        worldport_texture = ImageTexture.create_from_image(worldport_image)
+
+        var goal_image = Image.new()
+        goal_image.load_png_from_buffer(runtime.read_path("assets/goal.png"))
+        goal_texture = ImageTexture.create_from_image(goal_image)
+
+
+func _input(event):
+        if global.loaded and event is InputEventKey and event.pressed:
+                if event.keycode == KEY_TAB and !Input.is_key_pressed(KEY_SHIFT):
+                        if !get_tree().paused:
+                                is_open = true
+                                get_tree().paused = true
+                                Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+                                tabs.visible = true
+                                entry.grab_focus()
+                                get_viewport().set_input_as_handled()
+                        else:
+                                dismiss()
+                elif event.keycode == KEY_ESCAPE:
+                        if is_open:
+                                dismiss()
+                                get_viewport().set_input_as_handled()
+
+
+func dismiss():
+        if is_open:
+                get_tree().paused = false
+                Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+                tabs.visible = false
+                is_open = false
+
+
+func parse_printjson(text):
+        label.append_text("[p]" + text + "[/p]")
+
+
+func text_entered(text):
+        var ap = global.get_node("Archipelago")
+        var cmd = text.trim_suffix("\n")
+        entry.text = ""
+        if OS.is_debug_build():
+                if cmd.begins_with("/tp_map "):
+                        var new_map = cmd.substr(8)
+                        global.map = new_map
+                        global.sets_entry_point = false
+                        switcher.switch_map("res://objects/scenes/%s.tscn" % new_map)
+                        return
+
+        ap.client.say(cmd)
+
+
+func update_locations(reset_locations = true):
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        locations_overlay.clear()
+        locations_overlay.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        locations_overlay.push_font_size(24)
+        locations_overlay.push_color(Color(0.9, 0.9, 0.9, 1))
+        locations_overlay.push_outline_color(Color(0, 0, 0, 1))
+        locations_overlay.push_outline_size(2)
+
+        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)")
+                        (
+                                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)
+                        (
+                                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
+                ]]
+                (
+                        locations
+                        . push_front(
+                                {
+                                        "name": location_name,
+                                        "type": kGoal,
+                                        "ignored": false,
+                                        "hint": false,
+                                }
+                        )
+                )
+
+        var count = 0
+        for location in locations:
+                if count < 18 and not location["ignored"]:
+                        locations_overlay.push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT)
+                        if location["hint"]:
+                                locations_overlay.push_color(Color("#fafad2"))
+                        locations_overlay.append_text(location["name"])
+                        locations_overlay.append_text(" ")
+                        if location["type"] == kLocation:
+                                locations_overlay.add_image(location_texture)
+                        elif location["type"] == kWorldport:
+                                locations_overlay.add_image(worldport_texture)
+                        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)
+
+        var root_ti = worldports_tree.create_item(null)
+
+        var ports_by_map_id = {}
+        var display_names_by_map_id = {}
+        var display_names_by_port_id = {}
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+        for fpid in ap.port_pairings:
+                var port = gamedata.objects.get_ports()[fpid]
+                var room = gamedata.objects.get_rooms()[port.get_room_id()]
+
+                if not ports_by_map_id.has(room.get_map_id()):
+                        ports_by_map_id[room.get_map_id()] = []
+
+                        var map = gamedata.objects.get_maps()[room.get_map_id()]
+                        display_names_by_map_id[map.get_id()] = map.get_display_name()
+
+                ports_by_map_id[room.get_map_id()].append(fpid)
+                display_names_by_port_id[fpid] = port.get_display_name()
+
+        var sorted_map_ids = ports_by_map_id.keys().duplicate()
+        sorted_map_ids.sort_custom(
+                func(a, b): return display_names_by_map_id[a] < display_names_by_map_id[b]
+        )
+
+        for map_id in sorted_map_ids:
+                var map_ti = root_ti.create_child()
+                map_ti.set_text(0, display_names_by_map_id[map_id])
+                map_ti.visible = false
+                map_ti.collapsed = true
+                port_tree_item_by_map[map_id] = map_ti
+                port_tree_item_by_map_port[map_id] = {}
+
+                var port_ids = ports_by_map_id[map_id]
+                port_ids.sort_custom(
+                        func(a, b): return display_names_by_port_id[a] < display_names_by_port_id[b]
+                )
+
+                for port_id in port_ids:
+                        var port_ti = map_ti.create_child()
+                        port_ti.set_text(0, display_names_by_port_id[port_id])
+                        port_ti.set_text(1, gamedata.get_worldport_display_name(ap.port_pairings[port_id]))
+                        port_ti.visible = false
+                        port_tree_item_by_map_port[map_id][port_id] = port_ti
+
+        update_worldports()
+
+
+func update_worldports():
+        var ap = global.get_node("Archipelago")
+
+        for map_id in port_tree_item_by_map_port.keys():
+                var map_visible = false
+
+                for port_id in port_tree_item_by_map_port[map_id].keys():
+                        var ti = port_tree_item_by_map_port[map_id][port_id]
+                        ti.visible = ap.client._checked_worldports.has(port_id)
+
+                        if ti.visible:
+                                map_visible = true
+
+                port_tree_item_by_map[map_id].visible = map_visible
+
+
+func reset():
+        locations_overlay.clear()
+        tabs.set_tab_hidden(2, true)
+        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()
@@ -0,0 +1,21 @@
+WebSocketServer.gd:
+
+Copyright (c) 2014-present Godot Engine contributors. Copyright (c) 2007-2014
+Juan Linietsky, Ariel Manzur.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,173 @@
+class_name WebSocketServer
+extends Node
+
+signal message_received(peer_id: int, message: String)
+signal client_connected(peer_id: int)
+signal client_disconnected(peer_id: int)
+
+@export var handshake_headers := PackedStringArray()
+@export var supported_protocols := PackedStringArray()
+@export var handshake_timout := 3000
+@export var use_tls := false
+@export var tls_cert: X509Certificate
+@export var tls_key: CryptoKey
+@export var refuse_new_connections := false:
+        set(refuse):
+                if refuse:
+                        pending_peers.clear()
+
+
+class PendingPeer:
+        var connect_time: int
+        var tcp: StreamPeerTCP
+        var connection: StreamPeer
+        var ws: WebSocketPeer
+
+        func _init(p_tcp: StreamPeerTCP) -> void:
+                tcp = p_tcp
+                connection = p_tcp
+                connect_time = Time.get_ticks_msec()
+
+
+var tcp_server := TCPServer.new()
+var pending_peers: Array[PendingPeer] = []
+var peers: Dictionary
+
+
+func listen(port: int) -> int:
+        assert(not tcp_server.is_listening())
+        return tcp_server.listen(port)
+
+
+func stop() -> void:
+        tcp_server.stop()
+        pending_peers.clear()
+        peers.clear()
+
+
+func send(peer_id: int, message: String) -> int:
+        var type := typeof(message)
+        if peer_id <= 0:
+                # Send to multiple peers, (zero = broadcast, negative = exclude one).
+                for id: int in peers:
+                        if id == -peer_id:
+                                continue
+                        if type == TYPE_STRING:
+                                peers[id].send_text(message)
+                        else:
+                                peers[id].put_packet(message)
+                return OK
+
+        assert(peers.has(peer_id))
+        var socket: WebSocketPeer = peers[peer_id]
+        if type == TYPE_STRING:
+                return socket.send_text(message)
+        return socket.send(var_to_bytes(message))
+
+
+func get_message(peer_id: int) -> Variant:
+        assert(peers.has(peer_id))
+        var socket: WebSocketPeer = peers[peer_id]
+        if socket.get_available_packet_count() < 1:
+                return null
+        var pkt: PackedByteArray = socket.get_packet()
+        if socket.was_string_packet():
+                return pkt.get_string_from_utf8()
+        return bytes_to_var(pkt)
+
+
+func has_message(peer_id: int) -> bool:
+        assert(peers.has(peer_id))
+        return peers[peer_id].get_available_packet_count() > 0
+
+
+func _create_peer() -> WebSocketPeer:
+        var ws := WebSocketPeer.new()
+        ws.supported_protocols = supported_protocols
+        ws.handshake_headers = handshake_headers
+        return ws
+
+
+func poll() -> void:
+        if not tcp_server.is_listening():
+                return
+
+        while not refuse_new_connections and tcp_server.is_connection_available():
+                var conn: StreamPeerTCP = tcp_server.take_connection()
+                assert(conn != null)
+                pending_peers.append(PendingPeer.new(conn))
+
+        var to_remove := []
+
+        for p in pending_peers:
+                if not _connect_pending(p):
+                        if p.connect_time + handshake_timout < Time.get_ticks_msec():
+                                # Timeout.
+                                to_remove.append(p)
+                        continue  # Still pending.
+
+                to_remove.append(p)
+
+        for r: RefCounted in to_remove:
+                pending_peers.erase(r)
+
+        to_remove.clear()
+
+        for id: int in peers:
+                var p: WebSocketPeer = peers[id]
+                p.poll()
+
+                if p.get_ready_state() != WebSocketPeer.STATE_OPEN:
+                        client_disconnected.emit(id)
+                        to_remove.append(id)
+                        continue
+
+                while p.get_available_packet_count():
+                        message_received.emit(id, get_message(id))
+
+        for r: int in to_remove:
+                peers.erase(r)
+        to_remove.clear()
+
+
+func _connect_pending(p: PendingPeer) -> bool:
+        if p.ws != null:
+                # Poll websocket client if doing handshake.
+                p.ws.poll()
+                var state := p.ws.get_ready_state()
+                if state == WebSocketPeer.STATE_OPEN:
+                        var id := randi_range(2, 1 << 30)
+                        peers[id] = p.ws
+                        client_connected.emit(id)
+                        return true  # Success.
+                elif state != WebSocketPeer.STATE_CONNECTING:
+                        return true  # Failure.
+                return false  # Still connecting.
+        elif p.tcp.get_status() != StreamPeerTCP.STATUS_CONNECTED:
+                return true  # TCP disconnected.
+        elif not use_tls:
+                # TCP is ready, create WS peer.
+                p.ws = _create_peer()
+                p.ws.accept_stream(p.tcp)
+                return false  # WebSocketPeer connection is pending.
+
+        else:
+                if p.connection == p.tcp:
+                        assert(tls_key != null and tls_cert != null)
+                        var tls := StreamPeerTLS.new()
+                        tls.accept_stream(p.tcp, TLSOptions.server(tls_key, tls_cert))
+                        p.connection = tls
+                p.connection.poll()
+                var status: StreamPeerTLS.Status = p.connection.get_status()
+                if status == StreamPeerTLS.STATUS_CONNECTED:
+                        p.ws = _create_peer()
+                        p.ws.accept_stream(p.connection)
+                        return false  # WebSocketPeer connection is pending.
+                if status != StreamPeerTLS.STATUS_HANDSHAKING:
+                        return true  # Failure.
+
+                return false
+
+
+func _process(_delta: float) -> void:
+        poll()
@@ -0,0 +1,20 @@
+extends Receiver
+
+
+func _ready():
+        super._ready()
+
+
+func handleTriggered():
+        triggered += 1
+        if triggered >= total:
+                var ap = global.get_node("Archipelago")
+                ap.client.completedGoal()
+
+                global.get_node("Messages").showMessage("You have completed your goal!")
+
+
+func handleUntriggered():
+        triggered -= 1
+        if triggered < total:
+                pass
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/listeners/visibilityListener.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()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,61 @@
+extends "res://scripts/nodes/worldport.gd"
+
+var absolute_rotation = false
+var target_rotation = 0
+
+var port_id = null
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var ap = global.get_node("Archipelago")
+
+        if ap.shuffle_worldports:
+                var gamedata = global.get_node("Gamedata")
+                port_id = gamedata.get_port_for_map_node_path(global.map, node_path)
+                if port_id != null:
+                        if port_id in ap.port_pairings:
+                                var target_port = gamedata.objects.get_ports()[ap.port_pairings[port_id]]
+                                var target_room = gamedata.objects.get_rooms()[target_port.get_room_id()]
+                                var target_map = gamedata.objects.get_maps()[target_room.get_map_id()]
+
+                                exit = target_map.get_name()
+                                entry_point.x = target_port.get_destination().get_x()
+                                entry_point.y = target_port.get_destination().get_y()
+                                entry_point.z = target_port.get_destination().get_z()
+                                absolute_rotation = true
+                                target_rotation = target_port.get_rotation()
+                                sets_entry_point = true
+                                invisible = false
+                                fades = true
+                        else:
+                                port_id = null
+
+        if global.map == "icarus" and exit == "daedalus":
+                if not ap.daedalus_roof_access:
+                        entry_point = Vector3(58, 10, 0)
+
+        super._ready()
+
+
+func bodyEntered(body):
+        if body.is_in_group("player"):
+                if port_id != null:
+                        var ap = global.get_node("Archipelago")
+                        ap.client.checkWorldport(port_id)
+
+                if absolute_rotation:
+                        entry_rotate.y = target_rotation - body.rotation_degrees.y
+
+        super.bodyEntered(body)
+
+
+func changeScene():
+        var player = get_tree().get_root().get_node("scene/player")
+        if player != null:
+                player.playable = false
+
+        super.changeScene()
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/worldportListener.gd"
+
+
+func handleTriggered():
+        if exit.begins_with("menus/credits"):
+                return
+
+        super.handleTriggered()
@@ -0,0 +1,800 @@
+import asyncio
+import os
+import pkgutil
+import subprocess
+import sys
+from typing import Any
+
+import websockets
+
+import Utils
+import settings
+from BaseClasses import ItemClassification
+from CommonClient import CommonContext, server_loop, gui_enabled, logger, get_base_parser, handle_url_arg
+from NetUtils import Endpoint, decode, encode, ClientStatus
+from Utils import async_start
+from . import Lingo2World
+from .tracker import Tracker
+
+ALL_LETTERS = "abcdefghijklmnopqrstuvwxyz"
+MESSAGE_MAX_SIZE = 16*1024*1024
+PORT = 43182
+
+KEY_STORAGE_MAPPING = {
+    "a": (1, 0), "b": (1, 1), "c": (1, 2), "d": (1, 3), "e": (1, 4), "f": (1, 5), "g": (1, 6), "h": (1, 7), "i": (1, 8),
+    "j": (1, 9), "k": (1, 10), "l": (1, 11), "m": (1, 12), "n": (2, 0), "o": (2, 1), "p": (2, 2), "q": (2, 3),
+    "r": (2, 4), "s": (2, 5), "t": (2, 6), "u": (2, 7), "v": (2, 8), "w": (2, 9), "x": (2, 10), "y": (2, 11),
+    "z": (2, 12),
+}
+
+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"
+    tracker: Tracker
+
+    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
+        self.game_ctx.manager = self
+        self.client_ctx = client_ctx
+        self.client_ctx.manager = self
+        self.tracker = Tracker(self)
+        self.keyboard = {}
+
+        self.reset()
+
+    def reset(self):
+        for k in ALL_LETTERS:
+            self.keyboard[k] = 0
+
+        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] = {}
+
+        for k, v in new_keyboard.items():
+            if v > self.keyboard.get(k, 0):
+                self.keyboard[k] = v
+                ret[k] = v
+
+        if len(ret) > 0:
+            self.tracker.refresh_state()
+            self.game_ctx.send_accessible_locations()
+
+        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)
+
+        if len(ret) > 0:
+            self.tracker.refresh_state()
+            self.game_ctx.send_accessible_locations()
+
+        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
+    manager: Lingo2Manager
+
+    def __init__(self):
+        self.server = None
+
+    def send_connected(self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "Connected",
+            "user": self.manager.client_ctx.username,
+            "seed_name": self.manager.client_ctx.seed_name,
+            "version": self.manager.client_ctx.server_version,
+            "generator_version": self.manager.client_ctx.generator_version,
+            "team": self.manager.client_ctx.team,
+            "slot": self.manager.client_ctx.slot,
+            "checked_locations": self.manager.client_ctx.checked_locations,
+            "slot_data": self.manager.client_ctx.slot_data,
+        }
+
+        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
+
+        msg = {
+            "cmd": "ItemSentNotif",
+            "item_name": item_name,
+            "receiver_name": receiver_name,
+            "item_flags": item_flags,
+        }
+
+        async_start(self.send_msgs([msg]), name="item sent notif")
+
+    def send_hint_received(self, item_name, location_name, receiver_name, item_flags, for_self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "HintReceived",
+            "item_name": item_name,
+            "location_name": location_name,
+            "receiver_name": receiver_name,
+            "item_flags": item_flags,
+            "self": int(for_self),
+        }
+
+        async_start(self.send_msgs([msg]), name="hint received notif")
+
+    def send_item_received(self, items):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ItemReceived",
+            "items": items,
+        }
+
+        async_start(self.send_msgs([msg]), name="item received")
+
+    def send_location_info(self, locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "LocationInfo",
+            "locations": locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="location info")
+
+    def send_text_message(self, parts):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "TextMessage",
+            "data": parts,
+        }
+
+        async_start(self.send_msgs([msg]), name="notif")
+
+    def send_accessible_locations(self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "AccessibleLocations",
+            "locations": list(self.manager.tracker.accessible_locations),
+        }
+
+        if len(self.manager.tracker.accessible_worldports) > 0:
+            msg["worldports"] = list(self.manager.tracker.accessible_worldports)
+
+        if self.manager.tracker.goal_accessible and not self.manager.goaled:
+            msg["goal"] = True
+
+        async_start(self.send_msgs([msg]), name="accessible locations")
+
+    def send_update_locations(self, locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateLocations",
+            "locations": locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="update locations")
+
+    def send_update_keyboard(self, updates):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateKeyboard",
+            "updates": updates,
+        }
+
+        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
+
+        msg = {
+            "cmd": "UpdateWorldports",
+            "worldports": worldports,
+        }
+
+        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:
+            return
+        await self.server.socket.send(encode(msgs))
+
+
+class Lingo2ClientContext(CommonContext):
+    manager: Lingo2Manager
+
+    game = "Lingo 2"
+    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):
+        super().__init__(server_address, password)
+
+    def make_gui(self):
+        ui = super().make_gui()
+        ui.base_title = "Archipelago Lingo 2 Client"
+        return ui
+
+    async def server_auth(self, password_requested: bool = False):
+        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":
+            self.seed_name = args.get("seed_name", None)
+        elif cmd == "Connected":
+            self.slot_data = args.get("slot_data", None)
+
+            self.manager.reset()
+
+            self.manager.game_ctx.send_connected()
+
+            self.manager.tracker.setup_slot(self.slot_data)
+            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.get_datastorage_key("latches"),
+                            self.get_datastorage_key("ignored_locations"))
+            msg_batch = [{
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard1"),
+                "default": 0,
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": 0}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard2"),
+                "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):
+                self.set_notify(self.get_datastorage_key("worldports"))
+                msg_batch.append({
+                    "cmd": "Set",
+                    "key": self.get_datastorage_key("worldports"),
+                    "default": [],
+                    "want_reply": True,
+                    "operations": [{"operation": "default", "value": []}]
+                })
+
+            async_start(self.send_msgs(msg_batch), name="default keys")
+        elif cmd == "RoomUpdate":
+            if "checked_locations" in args:
+                self.manager.tracker.set_checked_locations(self.checked_locations)
+                self.manager.game_ctx.send_update_locations(args["checked_locations"])
+        elif cmd == "ReceivedItems":
+            self.manager.tracker.set_collected_items(self.items_received)
+
+            cur_index = 0
+            items = []
+
+            for item in args["items"]:
+                index = cur_index + args["index"]
+                cur_index += 1
+
+                item_msg = {
+                    "id": item.item,
+                    "index": index,
+                    "flags": item.flags,
+                    "text": self.item_names.lookup_in_slot(item.item, self.slot),
+                }
+
+                if item.player != self.slot:
+                    item_msg["sender"] = self.player_names.get(item.player)
+
+                items.append(item_msg)
+
+            self.manager.game_ctx.send_item_received(items)
+
+            if any(ItemClassification.progression in ItemClassification(item.flags) for item in args["items"]):
+                self.manager.game_ctx.send_accessible_locations()
+        elif cmd == "PrintJSON":
+            if "receiving" in args and "item" in args and args["item"].player == self.slot:
+                item_name = self.item_names.lookup_in_slot(args["item"].item, args["receiving"])
+                location_name = self.location_names.lookup_in_slot(args["item"].location, args["item"].player)
+                receiver_name = self.player_names.get(args["receiving"])
+
+                if args["type"] == "Hint" and not args.get("found", False):
+                    self.manager.game_ctx.send_hint_received(item_name, location_name, receiver_name, args["item"].flags,
+                                                             int(args["receiving"]) == self.slot)
+                elif args["receiving"] != self.slot:
+                    self.manager.game_ctx.send_item_sent_notification(item_name, receiver_name, args["item"].flags)
+
+            parts = []
+            for message_part in args["data"]:
+                if "type" not in message_part and "text" in message_part:
+                    parts.append({"type": "text", "text": message_part["text"]})
+                elif message_part["type"] == "player_id":
+                    parts.append({
+                        "type": "player",
+                        "text": self.player_names.get(int(message_part["text"])),
+                        "self": int(int(message_part["text"]) == self.slot),
+                    })
+                elif message_part["type"] == "item_id":
+                    parts.append({
+                        "type": "item",
+                        "text": self.item_names.lookup_in_slot(int(message_part["text"]), message_part["player"]),
+                        "flags": message_part["flags"],
+                    })
+                elif message_part["type"] == "location_id":
+                    parts.append({
+                        "type": "location",
+                        "text": self.location_names.lookup_in_slot(int(message_part["text"]),
+                                                                   message_part["player"])
+                    })
+                elif "text" in message_part:
+                    parts.append({"type": "text", "text": message_part["text"]})
+
+            self.manager.game_ctx.send_text_message(parts)
+        elif cmd == "LocationInfo":
+            locations = []
+
+            for location in args["locations"]:
+                locations.append({
+                    "id": location.location,
+                    "item": self.item_names.lookup_in_slot(location.item, location.player),
+                    "player": self.player_names.get(location.player),
+                    "flags": location.flags,
+                    "self": int(location.player) == self.slot,
+                })
+
+            self.manager.game_ctx.send_location_info(locations)
+        elif cmd == "Retrieved":
+            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"):
+                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}"
+
+    async def update_keyboard(self, updates: dict[str, int]):
+        kb1 = 0
+        kb2 = 0
+
+        for k, v in updates.items():
+            if v == 0:
+                continue
+
+            effect = 0
+            if v >= 1:
+                effect |= 1
+            if v == 2:
+                effect |= 2
+
+            pos = KEY_STORAGE_MAPPING[k]
+            if pos[0] == 1:
+                kb1 |= (effect << pos[1] * 2)
+            else:
+                kb2 |= (effect << pos[1] * 2)
+
+        msgs = []
+
+        if kb1 != 0:
+            msgs.append({
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard1"),
+                "want_reply": True,
+                "operations": [{
+                    "operation": "or",
+                    "value": kb1
+                }]
+            })
+
+        if kb2 != 0:
+            msgs.append({
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard2"),
+                "want_reply": True,
+                "operations": [{
+                    "operation": "or",
+                    "value": kb2
+                }]
+            })
+
+        if len(msgs) > 0:
+            await self.send_msgs(msgs)
+
+    def handle_keyboard_update(self, field: int, args: dict[str, Any]):
+        keys = {}
+        value = args["value"]
+
+        for i in range(0, 13):
+            if (value & (1 << (i * 2))) != 0:
+                keys[REVERSE_KEY_STORAGE_MAPPING[(field, i)]] = 1
+            if (value & (1 << (i * 2 + 1))) != 0:
+                keys[REVERSE_KEY_STORAGE_MAPPING[(field, i)]] = 2
+
+        updates = self.manager.update_keyboard(keys)
+        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": port_ap_ids
+            }]
+        }])
+
+    def handle_status_update(self, value: int):
+        self.manager.goaled = (value == ClientStatus.CLIENT_GOAL)
+        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():
+        try:
+            socket = await websockets.connect("ws://localhost", port=PORT, ping_timeout=None, ping_interval=None,
+                                              max_size=MESSAGE_MAX_SIZE)
+            manager.game_ctx.server = Endpoint(socket)
+            logger.info("Connected to Lingo 2!")
+            if manager.client_ctx.auth is not None:
+                manager.game_ctx.send_connected()
+                manager.game_ctx.send_accessible_locations()
+            async for data in manager.game_ctx.server.socket:
+                for msg in decode(data):
+                    await process_game_cmd(manager, msg)
+        except ConnectionRefusedError:
+            logger.info("Could not connect to Lingo 2.")
+        finally:
+            manager.game_ctx.server = None
+
+
+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")
+
+        if password != "":
+            server_address = f"{player}:{password}@{server}"
+        else:
+            server_address = f"{player}:None@{server}"
+
+        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")
+    elif cmd == "UpdateKeyboard":
+        updates = manager.update_keyboard(args["keyboard"])
+        if len(updates) > 0:
+            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}
+
+        # 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()
+
+
+async def run_game():
+    exe_file = settings.get_settings().lingo2_options.exe_file
+
+    # This ensures we can use Steam features without having to open the game
+    # through steam.
+    steam_appid_path = os.path.join(os.path.dirname(exe_file), "steam_appid.txt")
+    with open(steam_appid_path, "w") as said_handle:
+        said_handle.write("2523310")
+
+    if Lingo2World.zip_path is not None:
+        # This is a packaged apworld.
+        init_scene = pkgutil.get_data(__name__, "client/run_from_apworld.tscn")
+        init_path = Utils.local_path("data", "lingo2_init.tscn")
+
+        with open(init_path, "wb") as file_handle:
+            file_handle.write(init_scene)
+
+        subprocess.Popen(
+            [
+                exe_file,
+                "--scene",
+                init_path,
+                "--",
+                str(Lingo2World.zip_path.absolute()),
+            ],
+            cwd=os.path.dirname(exe_file),
+        )
+    else:
+        # The world is unzipped and being run in source.
+        subprocess.Popen(
+            [
+                exe_file,
+                "--scene",
+                Utils.local_path("worlds", "lingo2", "client", "run_from_source.tscn"),
+                "--",
+                Utils.local_path("worlds", "lingo2", "client"),
+            ],
+            cwd=os.path.dirname(exe_file),
+        )
+
+
+def client_main(*launch_args: str) -> None:
+    async def main(args):
+        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)
+
+        client_ctx.server_task = asyncio.create_task(server_loop(client_ctx), name="ServerLoop")
+
+        if gui_enabled:
+            client_ctx.run_gui()
+        client_ctx.run_cli()
+
+        pipe_task = asyncio.create_task(pipe_loop(manager), name="GameWatcher")
+
+        try:
+            await pipe_task
+        except Exception as e:
+            logger.exception(e)
+
+        await client_ctx.exit_event.wait()
+        client_ctx.ui.stop()
+        await client_ctx.shutdown()
+
+    Utils.init_logging("Lingo2Client", exception_logger="Client")
+    import colorama
+
+    parser = get_base_parser(description="Lingo 2 Archipelago Client")
+    parser.add_argument('--name', default=None, help="Slot Name to connect as.")
+    parser.add_argument("url", nargs="?", help="Archipelago connection url")
+    args = parser.parse_args(launch_args)
+
+    args = handle_url_arg(args, parser=parser)
+
+    colorama.just_fix_windows_console()
+    asyncio.run(main(args))
+    colorama.deinit()
@@ -0,0 +1,4 @@
+# Lingo 2
+
+See [the project README](https://code.fourisland.com/lingo2-archipelago/about/)
+for installation instructions and frequently asked questions. 
\ No newline at end of file
@@ -1,5 +1,31 @@
+from .generated import data_pb2 as data_pb2
 from BaseClasses import Item
 
 
 class Lingo2Item(Item):
     game: str = "Lingo 2"
+
+
+SYMBOL_ITEMS: dict[data_pb2.PuzzleSymbol, str] = {
+    data_pb2.PuzzleSymbol.SUN: "Sun Symbol",
+    data_pb2.PuzzleSymbol.SPARKLES: "Sparkles Symbol",
+    data_pb2.PuzzleSymbol.ZERO: "Zero Symbol",
+    data_pb2.PuzzleSymbol.EXAMPLE: "Example Symbol",
+    data_pb2.PuzzleSymbol.BOXES: "Boxes Symbol",
+    data_pb2.PuzzleSymbol.PLANET: "Planet Symbol",
+    data_pb2.PuzzleSymbol.PYRAMID: "Pyramid Symbol",
+    data_pb2.PuzzleSymbol.CROSS: "Cross Symbol",
+    data_pb2.PuzzleSymbol.SWEET: "Sweet Symbol",
+    data_pb2.PuzzleSymbol.GENDER: "Gender Symbol",
+    data_pb2.PuzzleSymbol.AGE: "Age Symbol",
+    data_pb2.PuzzleSymbol.SOUND: "Sound Symbol",
+    data_pb2.PuzzleSymbol.ANAGRAM: "Anagram Symbol",
+    data_pb2.PuzzleSymbol.JOB: "Job Symbol",
+    data_pb2.PuzzleSymbol.STARS: "Stars Symbol",
+    data_pb2.PuzzleSymbol.NULL: "Null Symbol",
+    data_pb2.PuzzleSymbol.EVAL: "Eval Symbol",
+    data_pb2.PuzzleSymbol.LINGO: "Lingo Symbol",
+    data_pb2.PuzzleSymbol.QUESTION: "Question Symbol",
+}
+
+ANTI_COLLECTABLE_TRAPS: list[str] = [f"Anti {letter}" for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
@@ -3,3 +3,6 @@ from BaseClasses import Location
 
 class Lingo2Location(Location):
     game: str = "Lingo 2"
+
+    port_id: int
+    goal: bool
@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle, Choice
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range, OptionSet
 
 
-class ShuffleDoors(Toggle):
+class ShuffleDoors(DefaultOnToggle):
     """If enabled, most doors will open from receiving an item rather than fulfilling the in-game requirements."""
     display_name = "Shuffle Doors"
 
@@ -16,6 +16,11 @@ class ShuffleControlCenterColors(Toggle):
     display_name = "Shuffle Control Center Colors"
 
 
+class ShuffleGalleryPaintings(Toggle):
+    """If enabled, gallery paintings will appear from receiving an item rather than by triggering them normally."""
+    display_name = "Shuffle Gallery Paintings"
+
+
 class ShuffleLetters(Choice):
     """
     Controls how letter unlocks are handled. Note that H1, I1, N1, and T1 will always be present at their vanilla
@@ -39,6 +44,23 @@ class ShuffleLetters(Choice):
     option_item_cyan = 4
 
 
+class ShuffleSymbols(Toggle):
+    """
+    If enabled, 19 items will be added to the pool, representing the different symbols that can appear on a panel.
+    Players will be prevented from solving puzzles with symbols on them until all of the required symbols are unlocked.
+    """
+    display_name = "Shuffle Symbols"
+
+
+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.
+    """
+    display_name = "Shuffle Worldports"
+
+
 class KeyholderSanity(Toggle):
     """
     If enabled, 26 locations will be created for placing each key into its respective Green Ending keyholder.
@@ -69,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
@@ -79,8 +131,40 @@ class DaedalusRoofAccess(Toggle):
     display_name = "Allow Daedalus Roof Access"
 
 
+class StrictPurpleEnding(DefaultOnToggle):
+    """
+    If enabled, the player will be required to have all purple (level 1) letters in order to get Purple Ending.
+    Otherwise, some of the letters may be skippable depending on the other options.
+    """
+    display_name = "Strict Purple Ending"
+
+
+class StrictCyanEnding(DefaultOnToggle):
+    """
+    If enabled, the player will be required to have all cyan (level 2) letters in order to get Cyan Ending. Otherwise,
+    at least J2, Q2, and V2 are skippable. Others may also be skippable depending on the options chosen.
+    """
+    display_name = "Strict Cyan Ending"
+
+
 class VictoryCondition(Choice):
-    """Victory condition."""
+    """
+    This option determines what your goal is.
+    
+    - **Gray Ending** (The Colorful)
+    - **Purple Ending** (The Sun Temple). This ordinarily requires all level 1 (purple) letters.
+    - **Mint Ending** (typing EXIT into the keyholders in Control Center)
+    - **Black Ending** (The Graveyard)
+    - **Blue Ending** (The Words)
+    - **Cyan Ending** (The Parthenon). This ordinarily requires almost all level 2 (cyan) letters.
+    - **Red Ending** (The Tower)
+    - **Plum Ending** (The Wondrous / The Door)
+    - **Orange Ending** (the castle in Daedalus)
+    - **Gold Ending** (The Gold). This involves going through the color rooms in Daedalus.
+    - **Yellow Ending** (The Gallery). This requires unlocking all gallery paintings.
+    - **Green Ending** (The Ancient). This requires filling all keyholders with specific letters.
+    - **White Ending** (Control Center). This combines every other ending.
+    """
     display_name = "Victory Condition"
     option_gray_ending = 0
     option_purple_ending = 1
@@ -97,12 +181,50 @@ 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"
+    range_start = 0
+    range_end = 100
+    default = 0
+
+
 @dataclass
 class Lingo2Options(PerGameCommonOptions):
     shuffle_doors: ShuffleDoors
     shuffle_control_center_colors: ShuffleControlCenterColors
+    shuffle_gallery_paintings: ShuffleGalleryPaintings
     shuffle_letters: ShuffleLetters
+    shuffle_symbols: ShuffleSymbols
+    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
@@ -1,9 +1,10 @@
 from enum import IntEnum, auto
 
 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
@@ -23,21 +24,38 @@ class AccessRequirements:
     items: set[str]
     progressives: dict[str, int]
     rooms: set[str]
-    symbols: set[str]
     letters: dict[str, int]
     cyans: bool
 
     # This is an AND of ORs.
     or_logic: list[list["AccessRequirements"]]
 
+    # When complete_at is set, at least that many of the requirements in possibilities must be accessible. This should
+    # only be used for doors with complete_at > 1, as or_logic is more efficient for complete_at == 1.
+    complete_at: int | None
+    possibilities: list["AccessRequirements"]
+
     def __init__(self):
         self.items = set()
         self.progressives = dict()
         self.rooms = set()
-        self.symbols = set()
         self.letters = dict()
         self.cyans = False
         self.or_logic = list()
+        self.complete_at = None
+        self.possibilities = list()
+
+    def copy(self) -> "AccessRequirements":
+        reqs = AccessRequirements()
+        reqs.items = self.items.copy()
+        reqs.progressives = self.progressives.copy()
+        reqs.rooms = self.rooms.copy()
+        reqs.letters = self.letters.copy()
+        reqs.cyans = self.cyans
+        reqs.or_logic = [[other_req.copy() for other_req in disjunction] for disjunction in self.or_logic]
+        reqs.complete_at = self.complete_at
+        reqs.possibilities = self.possibilities.copy()
+        return reqs
 
     def merge(self, other: "AccessRequirements"):
         for item in other.items:
@@ -49,16 +67,105 @@ class AccessRequirements:
         for room in other.rooms:
             self.rooms.add(room)
 
-        for symbol in other.symbols:
-            self.symbols.add(symbol)
-
         for letter, level in other.letters.items():
             self.letters[letter] = max(self.letters.get(letter, 0), level)
 
         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
+            # it. If both requirements use complete_at, we will cheat by using the or_logic field, which supports
+            # conjunctions of requirements.
+            if self.complete_at is not None:
+                print("Merging requirements with complete_at > 1. This is messy and should be avoided!")
+
+                left_req = AccessRequirements()
+                left_req.complete_at = self.complete_at
+                left_req.possibilities = [sub_req.copy() for sub_req in self.possibilities]
+                self.or_logic.append([left_req])
+
+                self.complete_at = None
+                self.possibilities = list()
+
+                right_req = AccessRequirements()
+                right_req.complete_at = other.complete_at
+                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 = [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
+                and not self.cyans and len(self.or_logic) == 0 and self.complete_at is None)
+
+    def __eq__(self, other: "AccessRequirements"):
+        return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and
+                self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and
+                self.complete_at == other.complete_at and self.possibilities == other.possibilities)
+
+    def simplify(self):
+        resimplify = False
+
+        if len(self.or_logic) > 0:
+            old_or_logic = self.or_logic
+
+            def remove_redundant(sub_reqs: "AccessRequirements"):
+                new_reqs = sub_reqs.copy()
+                new_reqs.letters = {l: v for l, v in new_reqs.letters.items() if self.letters.get(l, 0) < v}
+                if new_reqs != sub_reqs:
+                    return new_reqs
+                else:
+                    return sub_reqs
+
+            self.or_logic = []
+            for disjunction in old_or_logic:
+                new_disjunction = []
+                for ssr in disjunction:
+                    new_ssr = remove_redundant(ssr)
+                    if not new_ssr.is_empty():
+                        new_disjunction.append(new_ssr)
+                    else:
+                        new_disjunction.clear()
+                        break
+                if len(new_disjunction) == 1:
+                    self.merge(new_disjunction[0])
+                    resimplify = True
+                elif len(new_disjunction) > 1:
+                    if all(cjr == new_disjunction[0] for cjr in new_disjunction):
+                        self.merge(new_disjunction[0])
+                        resimplify = True
+                    else:
+                        self.or_logic.append(new_disjunction)
+
+        if resimplify:
+            self.simplify()
+
+    def get_referenced_rooms(self):
+        result = set(self.rooms)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                result = result.union(sub_req.get_referenced_rooms())
+
+        for sub_req in self.possibilities:
+            result = result.union(sub_req.get_referenced_rooms())
+
+        return result
+
+    def remove_room(self, room: str):
+        if room in self.rooms:
+            self.rooms.remove(room)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                sub_req.remove_room(room)
+
+        for sub_req in self.possibilities:
+            sub_req.remove_room(room)
 
     def __repr__(self):
         parts = []
@@ -68,15 +175,17 @@ class AccessRequirements:
             parts.append(f"progressives={self.progressives}")
         if len(self.rooms) > 0:
             parts.append(f"rooms={self.rooms}")
-        if len(self.symbols) > 0:
-            parts.append(f"symbols={self.symbols}")
         if len(self.letters) > 0:
             parts.append(f"letters={self.letters}")
         if self.cyans:
             parts.append(f"cyans=True")
         if len(self.or_logic) > 0:
             parts.append(f"or_logic={self.or_logic}")
-        return f"AccessRequirements({", ".join(parts)})"
+        if self.complete_at is not None:
+            parts.append(f"complete_at={self.complete_at}")
+        if len(self.possibilities) > 0:
+            parts.append(f"possibilities={self.possibilities}")
+        return "AccessRequirements(" + ", ".join(parts) + ")"
 
 
 class PlayerLocation(NamedTuple):
@@ -93,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]]
 
@@ -105,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
@@ -117,30 +229,76 @@ 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)
 
         for door_group in world.static_logic.objects.door_groups:
             if door_group.type == data_pb2.DoorGroupType.CONNECTOR:
-                if not self.world.options.shuffle_doors:
+                if not self.world.options.shuffle_doors or self.world.options.shuffle_worldports:
                     continue
             elif door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR:
-                if not self.world.options.shuffle_control_center_colors:
+                if not self.world.options.shuffle_control_center_colors or self.world.options.shuffle_worldports:
+                    continue
+            elif door_group.type == data_pb2.DoorGroupType.SHUFFLE_GROUP:
+                if not self.world.options.shuffle_doors:
                     continue
             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
 
@@ -155,6 +313,9 @@ class Lingo2PlayerLogic:
                     not self.world.options.shuffle_control_center_colors):
                 continue
 
+            if door.type == data_pb2.DoorType.GALLERY_PAINTING and not self.world.options.shuffle_gallery_paintings:
+                continue
+
             door_item_name = self.world.static_logic.get_door_item_name(door)
             self.item_by_door[door.id] = (door_item_name, 1)
             self.real_items.append(door_item_name)
@@ -166,29 +327,40 @@ 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)
             if behavior == LetterBehavior.VANILLA:
-                letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
-                event_name = f"{letter_name} (Collected)"
-                self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
-
-                if letter.level2:
-                    event_name = f"{letter_name} (Double Collected)"
+                if not world.for_tracker:
+                    letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
+                    event_name = f"{letter_name} (Collected)"
                     self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
+
+                    if letter.level2:
+                        event_name = f"{letter_name} (Double Collected)"
+                        self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
             elif behavior == LetterBehavior.ITEM:
                 self.real_items.append(letter.key.upper())
 
@@ -196,30 +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 ever create a location for White Ending. Don't even make an event for it if it's not the victory
-            # condition, since it is necessarily going to be in the postgame.
-            if ending.name == "WHITE":
-                if self.world.options.victory_condition != VictoryCondition.option_white_ending:
-                    continue
-            else:
+            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" 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:
@@ -228,6 +412,10 @@ class Lingo2PlayerLogic:
                     self.locations_by_room.setdefault(keyholder.room_id, []).append(PlayerLocation(keyholder.ap_id,
                                                                                                    reqs))
 
+        if self.world.options.shuffle_symbols:
+            for symbol_name in SYMBOL_ITEMS.values():
+                self.real_items.append(symbol_name)
+
     def get_panel_reqs(self, panel_id: int, answer: str | None) -> AccessRequirements:
         if answer is None:
             if panel_id not in self.panel_reqs:
@@ -250,25 +438,35 @@ class Lingo2PlayerLogic:
             self.add_solution_reqs(reqs, answer)
         elif len(panel.proxies) > 0:
             possibilities = []
+            already_filled = False
 
             for proxy in panel.proxies:
                 proxy_reqs = AccessRequirements()
                 self.add_solution_reqs(proxy_reqs, proxy.answer)
 
-                possibilities.append(proxy_reqs)
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
+                    break
 
-            if not any(proxy.answer == panel.answer for proxy in panel.proxies):
+            if not already_filled and not any(proxy.answer == panel.answer for proxy in panel.proxies):
                 proxy_reqs = AccessRequirements()
                 self.add_solution_reqs(proxy_reqs, panel.answer)
 
-                possibilities.append(proxy_reqs)
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
 
-            reqs.or_logic.append(possibilities)
+            if not already_filled:
+                reqs.or_logic.append(possibilities)
         else:
             self.add_solution_reqs(reqs, panel.answer)
 
-        for symbol in panel.symbols:
-            reqs.symbols.add(symbol)
+        if self.world.options.shuffle_symbols:
+            for symbol in panel.symbols:
+                reqs.items.add(SYMBOL_ITEMS.get(symbol))
 
         if panel.HasField("required_door"):
             door_reqs = self.get_door_open_reqs(panel.required_door)
@@ -291,21 +489,28 @@ class Lingo2PlayerLogic:
         door = self.world.static_logic.objects.doors[door_id]
         reqs = AccessRequirements()
 
-        # TODO: lavender_cubes, endings
         if not door.HasField("complete_at") or door.complete_at == 0:
             for proxy in door.panels:
                 panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
                 reqs.merge(panel_reqs)
         elif door.complete_at == 1:
-            reqs.or_logic.append([self.get_panel_reqs(proxy.panel,
-                                                      proxy.answer if proxy.HasField("answer") else None)
-                                  for proxy in door.panels])
+            disjunction = []
+            for proxy in door.panels:
+                proxy_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
+                if proxy_reqs.is_empty():
+                    disjunction.clear()
+                    break
+                else:
+                    disjunction.append(proxy_reqs)
+            if len(disjunction) > 0:
+                reqs.or_logic.append(disjunction)
         else:
-            # TODO: Handle complete_at > 1
-            pass
+            reqs.complete_at = door.complete_at
+            for proxy in door.panels:
+                panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
+                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)
 
@@ -313,7 +518,8 @@ class Lingo2PlayerLogic:
             if self.world.options.cyan_door_behavior == CyanDoorBehavior.option_collect_h2:
                 reqs.rooms.add("The Repetitive - Main Room")
             elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_any_double_letter:
-                reqs.cyans = True
+                if self.world.options.shuffle_letters != ShuffleLetters.option_unlocked:
+                    reqs.cyans = True
             elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_item:
                 # There shouldn't be any locations that are cyan doors.
                 pass
@@ -330,14 +536,19 @@ 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]
-            reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+        if door.white_ending:
+            if self.world.options.endings_requirement > 0:
+                reqs.progressives["Ending"] = self.world.options.endings_requirement.value
+
+            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)
             reqs.merge(sub_reqs)
 
+        reqs.simplify()
+
         return reqs
 
     # This gets the requirements to open a door within the world. When a door is shuffled, this means having the item
@@ -392,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")
@@ -1,6 +1,8 @@
 from typing import TYPE_CHECKING
 
+import BaseClasses
 from BaseClasses import Region, ItemClassification, Entrance
+from entrance_rando import randomize_entrances
 from .items import Lingo2Item
 from .locations import Lingo2Location
 from .player_logic import AccessRequirements
@@ -11,21 +13,42 @@ if TYPE_CHECKING:
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
+
+def create_locations(room, new_region: Region, world: "Lingo2World", regions: dict[str, Region]):
     for location in world.player_logic.locations_by_room.get(room.id, {}):
+        reqs = location.reqs.copy()
+        reqs.remove_room(new_region.name)
+
         new_location = Lingo2Location(world.player, world.static_logic.location_id_to_name[location.code],
                                       location.code, new_region)
-        new_location.access_rule = make_location_lambda(location.reqs, world)
+        new_location.access_rule = make_location_lambda(reqs, world, regions)
         new_region.locations.append(new_location)
 
     for event_name, item_name in world.player_logic.event_loc_item_by_room.get(room.id, {}).items():
         new_location = Lingo2Location(world.player, event_name, None, new_region)
+        if world.for_tracker and item_name == "Victory":
+            new_location.goal = True
+
         event_item = Lingo2Item(item_name, ItemClassification.progression, None, world.player)
         new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
-    return new_region
+    if world.for_tracker and world.options.shuffle_worldports:
+        for port_id in room.ports:
+            port = world.static_logic.objects.ports[port_id]
+            if port.no_shuffle:
+                continue
+
+            new_location = Lingo2Location(world.player, f"Worldport {port.id} Entered", None, new_region)
+            new_location.port_id = port.id
+
+            if port.HasField("required_door"):
+                new_location.access_rule = \
+                    make_location_lambda(world.player_logic.get_door_open_reqs(port.required_door), world, regions)
+
+            new_region.locations.append(new_location)
 
 
 def create_regions(world: "Lingo2World"):
@@ -33,19 +56,37 @@ def create_regions(world: "Lingo2World"):
         "Menu": Region("Menu", world.player, world.multiworld)
     }
 
+    region_and_room = []
+
+    # Create the regions in two stages. First, make the actual region objects and memoize them. Then, add all of the
+    # 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))
+
+    for (region, room) in region_and_room:
+        create_locations(room, region, world, regions)
 
     regions["Menu"].connect(regions["The Entry - Starting Room"], "Start Game")
 
-    # TODO: The requirements of the opposite trigger also matter.
     for connection in world.static_logic.objects.connections:
         if connection.roof_access and not world.options.daedalus_roof_access:
             continue
 
+        if connection.vanilla_only and world.options.shuffle_doors:
+            continue
+
         from_region = world.static_logic.get_room_region_name(connection.from_room)
         to_region = world.static_logic.get_room_region_name(connection.to_room)
+
+        if from_region not in regions or to_region not in regions:
+            continue
+
         connection_name = f"{from_region} -> {to_region}"
 
         reqs = AccessRequirements()
@@ -59,7 +100,10 @@ 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
 
             if port.HasField("required_door"):
                 reqs.merge(world.player_logic.get_door_open_reqs(port.required_door))
@@ -82,14 +126,131 @@ def create_regions(world: "Lingo2World"):
             else:
                 connection_name = f"{connection_name} (via panel {panel.name})"
 
-        if from_region in regions and to_region in regions:
-            connection = Entrance(world.player, connection_name, regions[from_region])
-            connection.access_rule = make_location_lambda(reqs, world)
+        if connection.HasField("purple_ending") and connection.purple_ending and world.options.strict_purple_ending:
+            world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyz")
+
+        if connection.HasField("cyan_ending") and connection.cyan_ending and world.options.strict_cyan_ending:
+            world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")
+
+        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)
 
-            regions[from_region].exits.append(connection)
-            connection.connect(regions[to_region])
+        regions[from_region].exits.append(connection)
+        connection.connect(regions[to_region])
 
-            for region in reqs.rooms:
-                world.multiworld.register_indirect_condition(regions[region], connection)
+        for region in reqs.get_referenced_rooms():
+            world.multiworld.register_indirect_condition(regions[region], connection)
 
     world.multiworld.regions += regions.values()
+
+
+def shuffle_entrances(world: "Lingo2World"):
+    er_entrances: list[Entrance] = []
+    er_exits: list[Entrance] = []
+
+    port_id_by_name: dict[str, int] = {}
+
+    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.display_name}"
+        port_id_by_name[connection_name] = port.id
+
+        entrance = port_region.create_er_target(connection_name)
+        entrance.randomization_type = BaseClasses.EntranceType.TWO_WAY
+
+        er_exit = port_region.create_exit(connection_name)
+        er_exit.randomization_type = BaseClasses.EntranceType.TWO_WAY
+
+        if port.HasField("required_door"):
+            door_reqs = world.player_logic.get_door_open_reqs(port.required_door)
+            er_exit.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),
+                                                             er_exit)
+
+        er_entrances.append(entrance)
+        er_exits.append(er_exit)
+
+    result = randomize_entrances(world, True, {0:[0]}, False, er_entrances,
+                                 er_exits)
+
+    for (f, to) in result.pairings:
+        world.port_pairings[port_id_by_name[f]] = port_id_by_name[to]
+
+
+def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
+    for fpid, tpid in port_pairings.items():
+        from_port = world.static_logic.objects.ports[fpid]
+        to_port = world.static_logic.objects.ports[tpid]
+
+        from_region_name = world.static_logic.get_room_region_name(from_port.room_id)
+        to_region_name = world.static_logic.get_room_region_name(to_port.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} - {from_port.display_name}", from_region)
+
+        reqs = AccessRequirements()
+        if from_port.HasField("required_door"):
+            reqs = world.player_logic.get_door_open_reqs(from_port.required_door).copy()
+
+        if world.for_tracker:
+            reqs.items.add(f"Worldport {fpid} Entered")
+
+        if not reqs.is_empty():
+            connection.access_rule = make_location_lambda(reqs, world, None)
+
+            for region in reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             connection)
+
+        from_region.exits.append(connection)
+        connection.connect(to_region)
@@ -1 +1 @@
-protobuf>=5.29.3
\ No newline at end of file
+protobuf==3.20.3
@@ -1,14 +1,15 @@
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
-from BaseClasses import CollectionState
+from BaseClasses import CollectionState, Region
 from .player_logic import AccessRequirements
 
 if TYPE_CHECKING:
     from . import Lingo2World
 
 
-def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirements, world: "Lingo2World") -> bool:
+def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirements, regions: list[Region],
+                                    world: "Lingo2World") -> bool:
     if not all(state.has(item, world.player) for item in reqs.items):
         return False
 
@@ -18,7 +19,8 @@ def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirem
     if not all(state.can_reach_region(region_name, world.player) for region_name in reqs.rooms):
         return False
 
-    # TODO: symbols
+    if not all(state.can_reach(region) for region in regions):
+        return False
 
     for letter_key, letter_level in reqs.letters.items():
         if not state.has(letter_key, world.player, letter_level):
@@ -30,11 +32,35 @@ def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirem
             return False
 
     if len(reqs.or_logic) > 0:
-        if not all(any(lingo2_can_satisfy_requirements(state, sub_reqs, world) for sub_reqs in subjunction)
+        if not all(any(lingo2_can_satisfy_requirements(state, sub_reqs, [], world) for sub_reqs in subjunction)
                    for subjunction in reqs.or_logic):
             return False
 
+    if reqs.complete_at is not None:
+        completed = 0
+        checked = 0
+        for possibility in reqs.possibilities:
+            checked += 1
+            if lingo2_can_satisfy_requirements(state, possibility, [], world):
+                completed += 1
+                if completed >= reqs.complete_at:
+                    break
+            elif len(reqs.possibilities) - checked + completed < reqs.complete_at:
+                # There aren't enough remaining possibilities for the check to pass.
+                return False
+        if completed < reqs.complete_at:
+            return False
+
     return True
 
-def make_location_lambda(reqs: AccessRequirements, world: "Lingo2World") -> Callable[[CollectionState], bool]:
-    return lambda state: lingo2_can_satisfy_requirements(state, reqs, world)
+def make_location_lambda(reqs: AccessRequirements, world: "Lingo2World",
+                         regions: dict[str, Region] | None) -> Callable[[CollectionState], bool]:
+    # Replace required rooms with regions for the top level requirement, which saves looking up the regions during rule
+    # checking.
+    if regions is not None:
+        required_regions = [regions[room_name] for room_name in reqs.rooms]
+    else:
+        required_regions = [world.multiworld.get_region(room_name, world.player) for room_name in reqs.rooms]
+    new_reqs = reqs.copy()
+    new_reqs.rooms.clear()
+    return lambda state: lingo2_can_satisfy_requirements(state, new_reqs, required_regions, world)
@@ -1,6 +1,8 @@
 from .generated import data_pb2 as data_pb2
+from .items import SYMBOL_ITEMS, ANTI_COLLECTABLE_TRAPS
 import pkgutil
 
+
 class Lingo2StaticLogic:
     item_id_to_name: dict[int, str]
     location_id_to_name: dict[int, str]
@@ -8,9 +10,20 @@ class Lingo2StaticLogic:
     item_name_to_id: dict[str, int]
     location_name_to_id: dict[str, int]
 
+    item_name_groups: dict[str, list[str]]
+    location_name_groups: dict[str, list[str]]
+
+    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 = {}
+        self.item_name_groups = {}
+        self.location_name_groups = {}
+        self.letter_weights = {}
 
         file = pkgutil.get_data(__name__, "generated/data.binpb")
         self.objects = data_pb2.AllObjects()
@@ -29,17 +42,21 @@ class Lingo2StaticLogic:
             letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
             location_name = f"{self.get_room_object_map_name(letter)} - {letter_name}"
             self.location_id_to_name[letter.ap_id] = location_name
+            self.location_name_groups.setdefault("Letters", []).append(location_name)
 
             if not letter.level2:
                 self.item_id_to_name[letter.ap_id] = letter.key.upper()
+                self.item_name_groups.setdefault("Letters", []).append(letter.key.upper())
 
         for mastery in self.objects.masteries:
             location_name = f"{self.get_room_object_map_name(mastery)} - Mastery"
             self.location_id_to_name[mastery.ap_id] = location_name
+            self.location_name_groups.setdefault("Masteries", []).append(location_name)
 
         for ending in self.objects.endings:
             location_name = f"{self.get_room_object_map_name(ending)} - {ending.name.title()} Ending"
             self.location_id_to_name[ending.ap_id] = location_name
+            self.location_name_groups.setdefault("Endings", []).append(location_name)
 
         for progressive in self.objects.progressives:
             self.item_id_to_name[progressive.ap_id] = progressive.name
@@ -51,12 +68,27 @@ class Lingo2StaticLogic:
             if keyholder.HasField("key"):
                 location_name = f"{self.get_room_object_location_prefix(keyholder)} - {keyholder.key.upper()} Keyholder"
                 self.location_id_to_name[keyholder.ap_id] = location_name
+                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
+
+        for trap_name in ANTI_COLLECTABLE_TRAPS:
+            self.item_id_to_name[self.objects.special_ids[trap_name]] = trap_name
 
         self.item_name_to_id = {name: ap_id for ap_id, name in self.item_id_to_name.items()}
         self.location_name_to_id = {name: ap_id for ap_id, name in self.location_id_to_name.items()}
 
+        for panel in self.objects.panels:
+            for letter in panel.answer.upper():
+                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}"
 
@@ -80,7 +112,7 @@ class Lingo2StaticLogic:
         if door.type != data_pb2.DoorType.STANDARD:
             return None
 
-        if len(door.keyholders) > 0 or len(door.endings) > 0:
+        if len(door.keyholders) > 0 or door.white_ending or door.HasField("complete_at"):
             return None
 
         if len(door.panels) > 4:
@@ -116,7 +148,7 @@ class Lingo2StaticLogic:
                        for panel_id in door.panels]
         panel_names.sort()
 
-        return f"{map_part} - {", ".join(panel_names)}"
+        return map_part + " - " + ", ".join(panel_names)
 
     def get_door_location_name_by_id(self, door_id: int) -> str:
         door = self.objects.doors[door_id]
@@ -140,3 +172,10 @@ class Lingo2StaticLogic:
             return f"{game_map.display_name} ({room.panel_display_name})"
         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]
@@ -0,0 +1,146 @@
+from typing import TYPE_CHECKING, Iterator
+
+from BaseClasses import MultiWorld, CollectionState, ItemClassification, Region, Entrance
+from NetUtils import NetworkItem
+from . import Lingo2World, Lingo2Item
+from .regions import connect_ports_from_ut
+from .options import Lingo2Options, ShuffleLetters
+
+if TYPE_CHECKING:
+    from .context import Lingo2Manager
+
+PLAYER_NUM = 1
+
+
+class Tracker:
+    manager: "Lingo2Manager"
+
+    multiworld: MultiWorld
+    world: Lingo2World
+
+    collected_items: dict[int, int]
+    checked_locations: set[int]
+    accessible_locations: set[int]
+    accessible_worldports: set[int]
+    goal_accessible: bool
+
+    state: CollectionState
+
+    def __init__(self, manager: "Lingo2Manager"):
+        self.manager = manager
+        self.collected_items = {}
+        self.checked_locations = set()
+        self.accessible_locations = set()
+        self.accessible_worldports = set()
+        self.goal_accessible = False
+
+    def setup_slot(self, slot_data):
+        Lingo2World.for_tracker = True
+
+        self.multiworld = MultiWorld(players=PLAYER_NUM)
+        self.world = Lingo2World(self.multiworld, PLAYER_NUM)
+        self.multiworld.worlds[1] = self.world
+        self.world.options = Lingo2Options(**{k: t(slot_data.get(k, t.default))
+                                              for k, t in Lingo2Options.type_hints.items()})
+
+        self.world.generate_early()
+        self.world.create_regions()
+
+        if self.world.options.shuffle_worldports:
+            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()
+
+    def set_checked_locations(self, checked_locations: set[int]):
+        self.checked_locations = checked_locations.copy()
+
+    def set_collected_items(self, network_items: list[NetworkItem]):
+        self.collected_items = {}
+
+        for item in network_items:
+            self.collected_items[item.item] = self.collected_items.get(item.item, 0) + 1
+
+        self.refresh_state()
+
+    def refresh_state(self):
+        self.state = CollectionState(self.multiworld)
+
+        for item_id, item_amount in self.collected_items.items():
+            for i in range(item_amount):
+                self.state.collect(Lingo2Item(Lingo2World.static_logic.item_id_to_name.get(item_id),
+                                              ItemClassification.progression, item_id, PLAYER_NUM), prevent_sweep=True)
+
+        for k, v in self.manager.keyboard.items():
+            # Unless all level 1 letters are pre-unlocked, H1 I1 N1 and T1 act differently between the generator and
+            # game. The generator considers them to be unlocked, which means they are not included in logic
+            # requirements, and only one item/event is needed to unlock their level 2 forms. The game considers them to
+            # be vanilla, which means you still have to pick them up in the Starting Room in order for them to appear on
+            # your keyboard. This also means that whether or not you have the level 1 forms should be synced to the
+            # multiworld. The tracker specifically should collect one fewer item for these letters in this scenario.
+            tv = v
+            if k in "hint" and self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla,
+                                                                      ShuffleLetters.option_progressive]:
+                tv = max(0, v - 1)
+
+            if tv > 0:
+                for i in range(tv):
+                    self.state.collect(Lingo2Item(k.upper(), ItemClassification.progression, None, PLAYER_NUM),
+                                       prevent_sweep=True)
+
+        for port_id in self.manager.worldports:
+            self.state.collect(Lingo2Item(f"Worldport {port_id} Entered", ItemClassification.progression, None,
+                                          PLAYER_NUM), prevent_sweep=True)
+
+        self.state.sweep_for_advancements()
+
+        self.accessible_locations = set()
+        self.accessible_worldports = set()
+        self.goal_accessible = False
+
+        for region in self.state.reachable_regions[PLAYER_NUM]:
+            for location in region.locations:
+                if location.access_rule(self.state):
+                    if location.address is not None:
+                        if location.address not in self.checked_locations:
+                            self.accessible_locations.add(location.address)
+                    elif hasattr(location, "port_id"):
+                        if location.port_id not in self.manager.worldports:
+                            self.accessible_worldports.add(location.port_id)
+                    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]