53 files changed, 5589 insertions, 75 deletions

@@ -1,18 +1,38 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+from typing import ClassVar
+
+from BaseClasses import ItemClassification, Item, Tutorial
+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 ..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()
 
 
 class Lingo2World(World):
@@ -24,21 +44,43 @@ class Lingo2World(World):
     game = "Lingo 2"
     web = Lingo2WebWorld()
 
+    settings: ClassVar[Lingo2Settings]
+    settings_key = "lingo2_options"
+
+    topology_present = True
+
     options_dataclass = Lingo2Options
     options: Lingo2Options
 
     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)
 
+    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 = {int(fp): 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")
@@ -49,11 +91,78 @@ 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("Nothing"))
+            pool.append(self.create_item(self.get_filler_item_name()))
 
         self.multiworld.itempool += pool
 
     def create_item(self, name: str) -> Item:
-        return Lingo2Item(name, ItemClassification.filler if name == "Nothing" else ItemClassification.progression,
+        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)
+
+    def set_rules(self):
+        self.multiworld.completion_condition[self.player] = lambda state: state.has("Victory", self.player)
+
+    def fill_slot_data(self):
+        slot_options = [
+            "cyan_door_behavior",
+            "daedalus_roof_access",
+            "keyholder_sanity",
+            "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: dict[str, object] = {
+            **self.options.as_dict(*slot_options),
+            "version": self.static_logic.get_data_version(),
+        }
+
+        if self.options.shuffle_worldports:
+            slot_data["port_pairings"] = self.port_pairings
+
+        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,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,44 @@
+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 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,265 @@
+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
+
+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 accessible_locations_updated
+signal checked_locations_updated
+signal checked_worldports_updated
+signal keyboard_update_received
+
+
+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(message["checked_locations"]))
+
+                        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["for_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)
+
+
+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 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,46 @@
+extends "res://scripts/nodes/door.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")
+
+        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()
@@ -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,286 @@
+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 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()
+                        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()
+
+        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 room = objects.get_rooms()[door.get_room_id()]
+        var map = objects.get_maps()[room.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.get_endings().size() > 0 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.
+                if not map_areas.has(panel_room.get_panel_display_name()):
+                        map_areas.append(panel_room.get_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.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,296 @@
+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("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("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("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)
+
+        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()
+
+        ap.setup_keys()
+
+        unlocks.loadCollectables()
+        unlocks.loadData()
+        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/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/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,603 @@
+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
+
+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 keyholder_sanity = false
+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
+
+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]
+
+
+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.checked_worldports_updated.connect(_on_checked_worldports_updated)
+
+        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()
+
+        # 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()
+
+
+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 _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))
+        keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
+        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[int(p1)] = 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 _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)
@@ -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,175 @@
+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 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(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 = material.albedo_color
+
+                rendered.set_pixel(pos.x - cell_left, pos.z - cell_top, color)
+
+        return rendered
+
+
+func _renderMeshNode(gridmap, mesh, rendered):
+        if mesh is MeshInstance3D:
+                var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
+                var global_tl = gridmap.to_global(local_tl)
+                var mesh_material = mesh.get_surface_override_material(0)
+                if mesh_material != null:
+                        var mesh_color = mesh_material.albedo_color
+
+                        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(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,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,346 @@
+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()
+
+        # 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 (
+                        door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                        or door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING
+                ):
+                        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)
+
+        # Block off roof access in Daedalus.
+        if global.map == "daedalus" and not ap.daedalus_roof_access:
+                _set_up_invis_wall(75.5, 11, -24.5, 1, 10, 49)
+                _set_up_invis_wall(51.5, 11, -17, 16, 10, 1)
+                _set_up_invis_wall(46, 10, -9.5, 1, 10, 10)
+                _set_up_invis_wall(67.5, 11, 17, 16, 10, 1)
+                _set_up_invis_wall(50.5, 11, 14, 10, 10, 1)
+                _set_up_invis_wall(39, 10, 18.5, 1, 10, 22)
+                _set_up_invis_wall(20, 15, 18.5, 1, 10, 16)
+                _set_up_invis_wall(11.5, 15, 3, 32, 10, 1)
+                _set_up_invis_wall(11.5, 16, -20, 14, 20, 1)
+                _set_up_invis_wall(14, 16, -26.5, 1, 20, 4)
+                _set_up_invis_wall(28.5, 20.5, -26.5, 1, 15, 25)
+                _set_up_invis_wall(40.5, 20.5, -11, 30, 15, 1)
+                _set_up_invis_wall(50.5, 15, 5.5, 7, 10, 1)
+                _set_up_invis_wall(83.5, 33.5, 5.5, 1, 7, 11)
+                _set_up_invis_wall(83.5, 33.5, -5.5, 1, 7, 11)
+
+                var warp_exit_prefab = preload("res://objects/nodes/exit.tscn")
+                var warp_exit = warp_exit_prefab.instantiate()
+                warp_exit.name = "roof_access_blocker_warp_exit"
+                warp_exit.position = Vector3(58, 10, 0)
+                warp_exit.rotation_degrees.y = 90
+                get_parent().add_child.call_deferred(warp_exit)
+
+                var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn")
+                var warp_enter = warp_enter_prefab.instantiate()
+                warp_enter.target = warp_exit
+                warp_enter.position = Vector3(76.5, 30, 1)
+                warp_enter.scale = Vector3(4, 1.5, 1)
+                warp_enter.rotation_degrees.y = 90
+                get_parent().add_child.call_deferred(warp_enter)
+
+        if global.map == "the_entry":
+                # Remove door behind X1.
+                var door_node = get_tree().get_root().get_node("/root/scene/Components/Doors/exit_1")
+                door_node.handleTriggered()
+
+                # Display win condition.
+                var sign_prefab = preload("res://objects/nodes/sign.tscn")
+                var sign1 = sign_prefab.instantiate()
+                sign1.position = Vector3(-7, 5, -15.01)
+                sign1.text = "victory"
+                get_parent().add_child.call_deferred(sign1)
+
+                var sign2 = sign_prefab.instantiate()
+                sign2.position = Vector3(-7, 4, -15.01)
+                sign2.text = "%s ending" % ap.kEndingNameByVictoryValue.get(ap.victory_condition, "?")
+
+                var sign2_color = ap.kEndingNameByVictoryValue.get(ap.victory_condition, "coral").to_lower()
+                if sign2_color == "white":
+                        sign2_color = "silver"
+
+                sign2.material = load("res://assets/materials/%s.material" % sign2_color)
+                get_parent().add_child.call_deferred(sign2)
+
+        # Add the strict purple ending validation.
+        if global.map == "the_sun_temple" and ap.strict_purple_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = ""
+                        panel.answer = word
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, 0)
+                        tpl.teleport_rotate = Vector3(-45, 180, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senders.append(NodePath("/root/scene/Panels/End/panel_24"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        get_parent().get_node("Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the doors that usually wait on EQUINOX. We can't set the senders
+                # here for some reason so we actually set them in the door ready function.
+                var endplat = get_node("/root/scene/Components/Doors/EndPlatform")
+                var endplat2 = endplat.duplicate()
+                endplat2.name = "spe_EndPlatform"
+                endplat.get_parent().add_child.call_deferred(endplat2)
+                endplat.queue_free()
+
+                var entry2 = get_node("/root/scene/Components/Doors/entry_2")
+                var entry22 = entry2.duplicate()
+                entry22.name = "spe_entry_2"
+                entry2.get_parent().add_child.call_deferred(entry22)
+                entry2.queue_free()
+
+        # Add the strict cyan ending validation.
+        if global.map == "the_parthenon" and ap.strict_cyan_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = "."
+                        panel.answer = "%s%s" % [word, word]
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, -11)
+                        tpl.teleport_rotate = Vector3(-45, 0, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senderGroup.append(NodePath("/root/scene/Panels/Rulers"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        get_parent().get_node("Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the door that usually waits on the rulers. We can't set the
+                # senders here for some reason so we actually set them in the door ready
+                # function.
+                var entry1 = get_node("/root/scene/Components/Doors/entry_1")
+                var entry12 = entry1.duplicate()
+                entry12.name = "spe_entry_1"
+                entry1.get_parent().add_child.call_deferred(entry12)
+                entry1.queue_free()
+
+        var minimap = ap.SCRIPT_minimap.new()
+        minimap.name = "Minimap"
+        minimap.visible = ap.show_minimap
+        get_parent().add_child.call_deferred(minimap)
+
+        super._ready()
+
+        await get_tree().process_frame
+        await get_tree().process_frame
+
+        ap.stop_batching_locations()
+
+
+func _set_up_invis_wall(x, y, z, sx, sy, sz):
+        var prefab = preload("res://objects/nodes/block.tscn")
+        var newwall = prefab.instantiate()
+        newwall.position.x = x
+        newwall.position.y = y
+        newwall.position.z = z
+        newwall.scale.x = sz
+        newwall.scale.y = sy
+        newwall.scale.z = sx
+        newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material"))
+        newwall.visibility_range_end = 3
+        newwall.visibility_range_end_margin = 1
+        newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF
+        newwall.skeleton = ".."
+        get_parent().add_child.call_deferred(newwall)
+
+
+func _process(_dt):
+        compass.update_rotation(global_rotation.y)
@@ -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,153 @@
+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.horizontal_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.horizontal_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.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        password_box.caret_blink = true
+        panel.add_child(password_box)
+
+        var accept_dialog = AcceptDialog.new()
+        accept_dialog.name = "AcceptDialog"
+        accept_dialog.offset_right = 83.0
+        accept_dialog.offset_bottom = 58.0
+        panel.add_child(accept_dialog)
+
+        var version_mismatch = ConfirmationDialog.new()
+        version_mismatch.name = "VersionMismatch"
+        version_mismatch.offset_right = 83.0
+        version_mismatch.offset_bottom = 58.0
+        panel.add_child(version_mismatch)
+
+        var connection_history = MenuButton.new()
+        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,29 @@
+extends Node
+
+var source_path
+
+
+func _init(path):
+        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,310 @@
+extends CanvasLayer
+
+var tabs
+var panel
+var label
+var entry
+var tracker_label
+var is_open = false
+
+var locations_overlay
+var location_texture
+var worldport_texture
+var goal_texture
+
+var worldports_tab
+var worldports_tree
+var port_tree_item_by_map = {}
+var port_tree_item_by_map_port = {}
+
+
+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(36)
+
+        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_label = RichTextLabel.new()
+        tracker_margins.add_child(tracker_label)
+
+        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():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        tracker_label.clear()
+        tracker_label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        tracker_label.push_font_size(24)
+
+        locations_overlay.clear()
+        locations_overlay.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        locations_overlay.push_font_size(24)
+        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)
+
+        const kLocation = 0
+        const kWorldport = 1
+        const kGoal = 2
+
+        var location_names = []
+        var type_by_name = {}
+        for location_id in ap.client._accessible_locations:
+                if not ap.client._checked_locations.has(location_id):
+                        var location_name = gamedata.location_name_by_id.get(location_id, "(Unknown)")
+                        location_names.append(location_name)
+                        type_by_name[location_name] = kLocation
+
+        for port_id in ap.client._accessible_worldports:
+                if not ap.client._checked_worldports.has(port_id):
+                        var port_name = gamedata.get_worldport_display_name(port_id)
+                        location_names.append(port_name)
+                        type_by_name[port_name] = kWorldport
+
+        location_names.sort()
+
+        if ap.client._goal_accessible:
+                var location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
+                        ap.victory_condition
+                ]]
+                location_names.push_front(location_name)
+                type_by_name[location_name] = kGoal
+
+        var count = 0
+        for location_name in location_names:
+                tracker_label.append_text("[p]%s[/p]" % location_name)
+                if count < 18:
+                        locations_overlay.push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT)
+                        locations_overlay.append_text(location_name)
+                        locations_overlay.append_text(" ")
+                        if type_by_name[location_name] == kLocation:
+                                locations_overlay.add_image(location_texture)
+                        elif type_by_name[location_name] == kWorldport:
+                                locations_overlay.add_image(worldport_texture)
+                        elif type_by_name[location_name] == kGoal:
+                                locations_overlay.add_image(goal_texture)
+                        locations_overlay.pop()
+                count += 1
+
+        if count > 18:
+                locations_overlay.append_text("[p align=right][lb]...[rb][/p]")
+
+
+func update_locations_visibility():
+        var ap = global.get_node("Archipelago")
+        locations_overlay.visible = ap.show_locations
+
+
+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()
@@ -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 == "menus/credits":
+                return
+
+        super.handleTriggered()
@@ -0,0 +1,630 @@
+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()}
+
+
+class Lingo2Manager:
+    game_ctx: "Lingo2GameContext"
+    client_ctx: "Lingo2ClientContext"
+    tracker: Tracker
+
+    keyboard: dict[str, int]
+    worldports: set[int]
+    goaled: bool
+
+    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.worldports = set()
+
+        self.reset()
+
+    def reset(self):
+        for k in ALL_LETTERS:
+            self.keyboard[k] = 0
+
+        self.worldports = set()
+        self.goaled = False
+
+    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
+
+    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
+
+
+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")
+
+    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")
+
+    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
+    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:
+            if self.password is None:
+                self.manager.game_ctx.send_connection_refused("Slot requires a password.")
+            else:
+                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.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)
+            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}]
+            }]
+
+            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 cmd == "SetReply":
+            if args["key"] == self.get_datastorage_key("keyboard1"):
+                self.handle_keyboard_update(1, args)
+            elif args["key"] == self.get_datastorage_key("keyboard2"):
+                self.handle_keyboard_update(2, args)
+            elif args["key"] == self.get_datastorage_key("worldports"):
+                updates = self.manager.update_worldports(set(args["value"]))
+                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"])
+
+    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)
+
+    async def update_worldports(self, updates: set[int]):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("worldports"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": updates
+            }]
+        }])
+
+    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 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"]
+        worldports = {port_id}
+        if str(port_id) in manager.client_ctx.slot_data["port_pairings"]:
+            worldports.add(manager.client_ctx.slot_data["port_pairings"][str(port_id)])
+
+        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 == "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):
+        async_start(run_game())
+
+        client_ctx = Lingo2ClientContext(args.connect, args.password)
+        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,13 +1,180 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range
 
 
-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"
 
 
+class ShuffleControlCenterColors(Toggle):
+    """
+    Some doors open after solving the COLOR panel in the Control Center. If this option is enabled, these doors will
+    instead open upon receiving an item.
+    """
+    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
+    locations in the starting room, even if letters are shuffled remotely.
+
+    - **Vanilla**: All letters will be present at their vanilla locations.
+    - **Unlocked**: Players will start with their keyboards fully unlocked.
+    - **Progressive**: Two items will be added to the pool for every letter (one for H, I, N, and T). Receiving the
+      first item gives you the corresponding level 1 letter, and the second item gives you the corresponding level 2
+      letter.
+    - **Vanilla Cyan**: Players will start with all level 1 (purple) letters unlocked. Level 2 (cyan) letters will be
+      present at their vanilla locations.
+    - **Item Cyan**: Players will start with all level 1 (purple) letters unlocked. One item will be added to the pool
+      for every level 2 (cyan) letter.
+    """
+    display_name = "Shuffle Letters"
+    option_vanilla = 0
+    option_unlocked = 1
+    option_progressive = 2
+    option_vanilla_cyan = 3
+    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. Connections that depend on placing letters in keyholders are also
+    currently not shuffled.
+
+    NOTE: It is highly recommended that you turn on Shuffle Control Center Colors when using Shuffle Worldports. Not
+    doing so runs the risk of creating an unfinishable seed.
+    """
+    display_name = "Shuffle Worldports"
+
+
+class KeyholderSanity(Toggle):
+    """
+    If enabled, 26 locations will be created for placing each key into its respective Green Ending keyholder.
+
+    NOTE: This does not apply to the two disappearing keyholders in The Congruent, as they are not part of Green Ending.
+    """
+    display_name = "Keyholder Sanity"
+
+
+class CyanDoorBehavior(Choice):
+    """
+    Cyan-colored doors usually only open upon unlocking double letters. Some panels also only appear upon unlocking
+    double letters. This option determines how these unlocks should behave.
+
+    - **Collect H2**: In the base game, H2 is the first double letter you are intended to collect, so cyan doors only
+      open when you collect the H2 pickup in The Repetitive. Collecting the actual pickup is still required even with
+      remote letter shuffle enabled.
+    - **Any Double Letter**: Cyan doors will open when you have unlocked any cyan letter on your keyboard. In letter
+      shuffle, this means receiving a cyan letter, not picking up a cyan letter collectable.
+    - **Item**: Cyan doors will be grouped together in a single item.
+
+    Note that some cyan doors are impacted by door shuffle (e.g. the entrance to The Tower). When door shuffle is
+    enabled, these doors won't be affected by the value of this option.
+    """
+    display_name = "Cyan Door Behavior"
+    option_collect_h2 = 0
+    option_any_double_letter = 1
+    option_item = 2
+
+
+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
+    that is open to the air. If disabled, the player will only be expected to be able to enter the castle, the moat,
+    Icarus, and the area at the bottom of the stairs. Invisible walls that become opaque as you approach them are added
+    to the level to prevent the player from accidentally breaking logic.
+    """
+    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):
+    """
+    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
+    option_mint_ending = 2
+    option_black_ending = 3
+    option_blue_ending = 4
+    option_cyan_ending = 5
+    option_red_ending = 6
+    option_plum_ending = 7
+    option_orange_ending = 8
+    option_gold_ending = 9
+    option_yellow_ending = 10
+    option_green_ending = 11
+    option_white_ending = 12
+
+
+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
+    daedalus_roof_access: DaedalusRoofAccess
+    strict_purple_ending: StrictPurpleEnding
+    strict_cyan_ending: StrictCyanEnding
+    victory_condition: VictoryCondition
+    trap_percentage: TrapPercentage
@@ -1,6 +1,11 @@
+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
+
 if TYPE_CHECKING:
     from . import Lingo2World
 
@@ -10,60 +15,197 @@ def calculate_letter_histogram(solution: str) -> dict[str, int]:
     for l in solution:
         if l.isalpha():
             real_l = l.upper()
-            histogram[real_l] = min(histogram.get(l, 0) + 1, 2)
+            histogram[real_l] = min(histogram.get(real_l, 0) + 1, 2)
 
     return histogram
 
 
 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 add_solution(self, solution: str):
-        histogram = calculate_letter_histogram(solution)
-
-        for l, a in histogram.items():
-            self.letters[l] = max(self.letters.get(l, 0), histogram.get(l))
+    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:
             self.items.add(item)
 
+        for item, amount in other.progressives.items():
+            self.progressives[item] = max(amount, self.progressives.get(item, 0))
+
         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)
 
+        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 = 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 = other.possibilities
+                self.or_logic.append([right_req])
+            else:
+                self.complete_at = other.complete_at
+                self.possibilities = 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 = []
+        if len(self.items) > 0:
+            parts.append(f"items={self.items}")
+        if len(self.progressives) > 0:
+            parts.append(f"progressives={self.progressives}")
+        if len(self.rooms) > 0:
+            parts.append(f"rooms={self.rooms}")
+        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}")
+        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):
     code: int | None
     reqs: AccessRequirements
 
 
+class LetterBehavior(IntEnum):
+    VANILLA = auto()
+    ITEM = auto()
+    UNLOCKED = auto()
+
+
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
     locations_by_room: dict[int, list[PlayerLocation]]
-    item_by_door: dict[int, str]
+    event_loc_item_by_room: dict[int, dict[str, str]]
+
+    item_by_door: dict[int, tuple[str, int]]
 
     panel_reqs: dict[int, AccessRequirements]
     proxy_reqs: dict[int, dict[str, AccessRequirements]]
@@ -71,22 +213,79 @@ class Lingo2PlayerLogic:
 
     real_items: list[str]
 
+    double_letter_amount: dict[str, int]
+
     def __init__(self, world: "Lingo2World"):
         self.world = world
         self.locations_by_room = {}
+        self.event_loc_item_by_room = {}
         self.item_by_door = {}
         self.panel_reqs = dict()
         self.proxy_reqs = dict()
         self.door_reqs = dict()
         self.real_items = list()
+        self.double_letter_amount = dict()
+
+        if self.world.options.shuffle_doors:
+            for progressive in world.static_logic.objects.progressives:
+                for i in range(0, len(progressive.doors)):
+                    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 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 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)
+
+            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.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and self.world.options.shuffle_doors:
-                door_item_name = self.world.static_logic.get_door_item_name(door.id)
-                self.item_by_door[door.id] = door_item_name
-                self.real_items.append(door_item_name)
+            if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
+                continue
+
+            if door.id in self.item_by_door:
+                continue
+
+            if (door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and
+                    not self.world.options.shuffle_doors):
+                continue
+
+            if (door.type == data_pb2.DoorType.CONTROL_CENTER_COLOR and
+                    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)
+
+        # We handle cyan_door_behavior = Item after door shuffle, because cyan doors that are impacted by door shuffle
+        # should be exempt from cyan_door_behavior.
+        if world.options.cyan_door_behavior == CyanDoorBehavior.option_item:
+            for door_group in world.static_logic.objects.door_groups:
+                if door_group.type != data_pb2.DoorGroupType.CYAN_DOORS:
+                    continue
+
+                for door in door_group.doors:
+                    if not door in self.item_by_door:
+                        self.item_by_door[door] = (door_group.name, 1)
+
+                self.real_items.append(door_group.name)
 
         for door in world.static_logic.objects.doors:
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
@@ -96,14 +295,55 @@ class Lingo2PlayerLogic:
         for letter in world.static_logic.objects.letters:
             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:
+                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())
+
+            if behavior != LetterBehavior.UNLOCKED:
+                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:
             self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
                                                                                          AccessRequirements()))
 
         for ending in world.static_logic.objects.endings:
-            self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
-                                                                                        AccessRequirements()))
+            # Don't create a location for your selected ending, and never create a location for White Ending.
+            if world.options.victory_condition.current_key.removesuffix("_ending").upper() != ending.name\
+                    and ending.name != "WHITE":
+                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"
+
+            self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = item_name
+
+        if self.world.options.keyholder_sanity:
+            for keyholder in world.static_logic.objects.keyholders:
+                if keyholder.HasField("key"):
+                    reqs = AccessRequirements()
+
+                    if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED:
+                        reqs.letters[keyholder.key.upper()] = 1
+
+                    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:
@@ -124,18 +364,38 @@ class Lingo2PlayerLogic:
         reqs.rooms.add(self.world.static_logic.get_room_region_name(panel.room_id))
 
         if answer is not None:
-            reqs.add_solution(answer)
+            self.add_solution_reqs(reqs, answer)
         elif len(panel.proxies) > 0:
+            possibilities = []
+            already_filled = False
+
             for proxy in panel.proxies:
                 proxy_reqs = AccessRequirements()
-                proxy_reqs.add_solution(proxy.answer)
+                self.add_solution_reqs(proxy_reqs, proxy.answer)
+
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
+                    break
+
+            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)
 
-                reqs.or_logic.append([proxy_reqs])
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
+
+            if not already_filled:
+                reqs.or_logic.append(possibilities)
         else:
-            reqs.add_solution(panel.answer)
+            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)
@@ -158,32 +418,67 @@ class Lingo2PlayerLogic:
         door = self.world.static_logic.objects.doors[door_id]
         reqs = AccessRequirements()
 
-        use_item = False
-        if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and self.world.options.shuffle_doors:
-            use_item = True
-
-        if use_item:
-            reqs.items.add(self.world.static_logic.get_door_item_name(door.id))
+        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:
+            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: complete_at, control_center_color, switches, keyholders
-            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])
-            else:
-                # TODO: Handle complete_at > 1
+            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)
+
+        if door.double_letters:
+            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:
+                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
 
-            for room in door.rooms:
-                reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
+        for keyholder_uses in door.keyholders:
+            key_name = keyholder_uses.key.upper()
+            if (self.get_letter_behavior(keyholder_uses.key, False) != LetterBehavior.UNLOCKED
+                    and key_name not in reqs.letters):
+                reqs.letters[key_name] = 1
+
+            keyholder = self.world.static_logic.objects.keyholders[keyholder_uses.keyholder]
+            reqs.rooms.add(self.world.static_logic.get_room_region_name(keyholder.room_id))
+
+        for room in door.rooms:
+            reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
+
+        for ending_id in door.endings:
+            ending = self.world.static_logic.objects.endings[ending_id]
+
+            if self.world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
+                reqs.items.add("Victory")
+            else:
+                reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+
+        for sub_door_id in door.doors:
+            sub_reqs = self.get_door_open_reqs(sub_door_id)
+            reqs.merge(sub_reqs)
 
-            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
 
@@ -192,8 +487,50 @@ class Lingo2PlayerLogic:
     def get_door_open_reqs(self, door_id: int) -> AccessRequirements:
         if door_id in self.item_by_door:
             reqs = AccessRequirements()
-            reqs.items.add(self.item_by_door.get(door_id))
+
+            item_name, amount = self.item_by_door.get(door_id)
+            if amount == 1:
+                reqs.items.add(item_name)
+            else:
+                reqs.progressives[item_name] = amount
 
             return reqs
         else:
             return self.get_door_reqs(door_id)
+
+    def get_letter_behavior(self, letter: str, level2: bool) -> LetterBehavior:
+        if self.world.options.shuffle_letters == ShuffleLetters.option_unlocked:
+            return LetterBehavior.UNLOCKED
+
+        if self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla_cyan, ShuffleLetters.option_item_cyan]:
+            if level2:
+                if self.world.options.shuffle_letters == ShuffleLetters.option_vanilla_cyan:
+                    return LetterBehavior.VANILLA
+                else:
+                    return LetterBehavior.ITEM
+            else:
+                return LetterBehavior.UNLOCKED
+
+        if not level2 and letter in ["h", "i", "n", "t"]:
+            return LetterBehavior.UNLOCKED
+
+        if self.world.options.shuffle_letters == ShuffleLetters.option_progressive:
+            return LetterBehavior.ITEM
+
+        return LetterBehavior.VANILLA
+
+    def add_solution_reqs(self, reqs: AccessRequirements, solution: str):
+        histogram = calculate_letter_histogram(solution)
+
+        for l, a in histogram.items():
+            needed = min(a, 2)
+            level2 = (needed == 2)
+
+            if level2 and self.get_letter_behavior(l.lower(), True) == LetterBehavior.UNLOCKED:
+                needed = 1
+
+            if self.get_letter_behavior(l.lower(), False) == LetterBehavior.UNLOCKED:
+                needed = needed - 1
+
+            if needed > 0:
+                reqs.letters[l] = max(reqs.letters.get(l, 0), needed)
@@ -1,6 +1,9 @@
 from typing import TYPE_CHECKING
 
-from BaseClasses import Region
+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
 from .rules import make_location_lambda
@@ -10,15 +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"):
@@ -26,16 +56,34 @@ 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:
         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()
@@ -51,6 +99,9 @@ def create_regions(world: "Lingo2World"):
             port = world.static_logic.objects.ports[connection.port]
             connection_name = f"{connection_name} (via port {port.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))
 
@@ -72,7 +123,93 @@ 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:
-            regions[from_region].connect(regions[to_region], connection_name, 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)
+
+        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])
+
+        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] = {}
+
+    for port in world.static_logic.objects.ports:
+        if port.no_shuffle:
+            continue
+
+        port_region_name = world.static_logic.get_room_region_name(port.room_id)
+        port_region = world.multiworld.get_region(port_region_name, world.player)
+
+        connection_name = f"{port_region_name} - {port.name}"
+        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.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,27 +1,66 @@
 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
 
+    if not all(state.has(item, world.player, amount) for item, amount in reqs.progressives.items()):
+        return False
+
     if not all(state.can_reach_region(region_name, world.player) for region_name in reqs.rooms):
         return False
 
-    # TODO: symbols, letters
+    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):
+            return False
+
+    if reqs.cyans:
+        if not any(state.has(letter, world.player, amount)
+                   for letter, amount in world.player_logic.double_letter_amount.items()):
+            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)
+                   for subjunction in reqs.or_logic):
+            return False
 
-    for disjunction in reqs.or_logic:
-        if not any(lingo2_can_satisfy_requirements(state, sub_reqs, world) for sub_reqs in disjunction):
+    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,17 @@ 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]
+
     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()
@@ -18,38 +28,125 @@ class Lingo2StaticLogic:
 
         for door in self.objects.doors:
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
-                location_name = f"{self.get_map_object_map_name(door)} - {door.name}"
+                location_name = self.get_door_location_name(door)
                 self.location_id_to_name[door.ap_id] = location_name
 
             if door.type not in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
-                item_name = self.get_door_item_name(door.id)
+                item_name = self.get_door_item_name(door)
                 self.item_id_to_name[door.ap_id] = item_name
 
         for letter in self.objects.letters:
             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_name
+                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
+
+        for door_group in self.objects.door_groups:
+            self.item_id_to_name[door_group.ap_id] = door_group.name
+
+        for keyholder in self.objects.keyholders:
+            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"
+
+        for symbol_name in SYMBOL_ITEMS.values():
+            self.item_id_to_name[self.objects.special_ids[symbol_name]] = symbol_name
 
-        self.item_id_to_name[self.objects.special_ids["Nothing"]] = "Nothing"
+        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()}
 
-    def get_door_item_name(self, door_id: int) -> str:
-        door = self.objects.doors[door_id]
+        for panel in self.objects.panels:
+            for letter in panel.answer.upper():
+                self.letter_weights[letter] = self.letter_weights.get(letter, 0) + 1
+
+    def get_door_item_name(self, door: data_pb2.Door) -> str:
         return f"{self.get_map_object_map_name(door)} - {door.name}"
 
+    def get_door_item_name_by_id(self, door_id: int) -> str:
+        door = self.objects.doors[door_id]
+        return self.get_door_item_name(door_id)
+
+    def get_door_location_name(self, door: data_pb2.Door) -> str:
+        map_part = self.get_room_object_location_prefix(door)
+
+        if door.HasField("location_name"):
+            return f"{map_part} - {door.location_name}"
+
+        generated_location_name = self.get_generated_door_location_name(door)
+        if generated_location_name is not None:
+            return generated_location_name
+
+        return f"{map_part} - {door.name}"
+
+    def get_generated_door_location_name(self, door: data_pb2.Door) -> str | None:
+        if door.type != data_pb2.DoorType.STANDARD:
+            return None
+
+        if len(door.keyholders) > 0 or len(door.endings) > 0 or door.HasField("complete_at"):
+            return None
+
+        if len(door.panels) > 4:
+            return None
+
+        map_areas = set()
+        for panel_id in door.panels:
+            panel = self.objects.panels[panel_id.panel]
+            panel_room = self.objects.rooms[panel.room_id]
+            # It's okay if panel_display_name is not present because then it's coalesced with other unnamed areas.
+            map_areas.add(panel_room.panel_display_name)
+
+        if len(map_areas) > 1:
+            return None
+
+        game_map = self.objects.maps[door.map_id]
+        map_area = map_areas.pop()
+        if map_area == "":
+            map_part = game_map.display_name
+        else:
+            map_part = f"{game_map.display_name} ({map_area})"
+
+        def get_panel_display_name(panel: data_pb2.ProxyIdentifier) -> str:
+            panel_data = self.objects.panels[panel.panel]
+            panel_name = panel_data.display_name if panel_data.HasField("display_name") else panel_data.name
+
+            if panel.HasField("answer"):
+                return f"{panel_name}/{panel.answer.upper()}"
+            else:
+                return panel_name
+
+        panel_names = [get_panel_display_name(panel_id)
+                       for panel_id in door.panels]
+        panel_names.sort()
+
+        return map_part + " - " + ", ".join(panel_names)
+
+    def get_door_location_name_by_id(self, door_id: int) -> str:
+        door = self.objects.doors[door_id]
+        return self.get_door_location_name(door)
+
     def get_room_region_name(self, room_id: int) -> str:
         room = self.objects.rooms[room_id]
         return f"{self.get_map_object_map_name(room)} - {room.name}"
@@ -59,3 +156,16 @@ class Lingo2StaticLogic:
 
     def get_room_object_map_name(self, obj) -> str:
         return self.get_map_object_map_name(self.objects.rooms[obj.room_id])
+
+    def get_room_object_location_prefix(self, obj) -> str:
+        room = self.objects.rooms[obj.room_id]
+        game_map = self.objects.maps[room.map_id]
+
+        if room.HasField("panel_display_name"):
+            return f"{game_map.display_name} ({room.panel_display_name})"
+        else:
+            return game_map.display_name
+
+    def get_data_version(self) -> list[int]:
+        version = self.objects.version
+        return [version.major, version.minor, version.patch]
@@ -0,0 +1,112 @@
+from typing import TYPE_CHECKING
+
+from BaseClasses import MultiWorld, CollectionState, ItemClassification
+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 = {int(fp): 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