16 files changed, 661 insertions, 155 deletions

@@ -12,7 +12,7 @@ from .player_logic import Lingo2PlayerLogic
 from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
 from .static_logic import Lingo2StaticLogic
 from .version import APWORLD_VERSION
-from ..LauncherComponents import Component, Type, components, launch as launch_component
+from ..LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
 
 
 class Lingo2WebWorld(WebWorld):
@@ -59,6 +59,8 @@ class Lingo2World(World):
     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]
@@ -161,6 +163,7 @@ def launch_client(*args):
     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")
+                      description="Open Lingo 2.", supports_uri=True, game_name="Lingo 2", icon="lingo2_ico")
 components.append(component)
@@ -18,10 +18,12 @@ 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 = []
 
 signal could_not_connect
 signal connect_status
@@ -33,6 +35,8 @@ 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():
@@ -54,7 +58,9 @@ func _reset_state():
         _should_process = false
         _received_items = {}
         _received_indexes = []
+        _checked_worldports = []
         _accessible_locations = []
+        _accessible_worldports = []
 
 
 func disconnect_from_ap():
@@ -116,6 +122,14 @@ func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> vo
 
                         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"])
@@ -151,12 +165,24 @@ func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> vo
 
                 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))
+
                         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}])
@@ -202,19 +228,6 @@ func sendLocations(loc_ids):
         sendMessage([{"cmd": "LocationChecks", "locations": loc_ids}])
 
 
-func setValue(key, value, operation = "replace"):
-        sendMessage(
-                [
-                        {
-                                "cmd": "Set",
-                                "key": "Lingo2_%d_%s" % [_slot, key],
-                                "want_reply": false,
-                                "operations": [{"operation": operation, "value": value}]
-                        }
-                ]
-        )
-
-
 func say(textdata):
         sendMessage([{"cmd": "Say", "text": textdata}])
 
@@ -227,6 +240,15 @@ 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"}])
 
@@ -161,11 +161,23 @@ func get_door_ap_id(door_id):
                 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()
 
@@ -48,6 +48,9 @@ func load_seed():
                 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
 
@@ -105,10 +108,20 @@ func update_unlocks():
 
 
 func collect_local_letter(key, level):
-        if level < 0 or level > 2 or level < letters_saved.get(key, 0):
+        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] = level
+        letters_saved[key] = true_level
+
+        ap.client.updateKeyboard({key: true_level})
 
         if letters_blocked.has(key):
                 letters_blocked.erase(key)
@@ -197,3 +210,22 @@ func reset_keyholders():
         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)
@@ -109,6 +109,7 @@ func _ready():
         client.hint_received.connect(_process_hint_received)
         client.accessible_locations_updated.connect(_on_accessible_locations_updated)
         client.checked_locations_updated.connect(_on_checked_locations_updated)
+        client.checked_worldports_updated.connect(_on_checked_worldports_updated)
 
         client.could_not_connect.connect(_client_could_not_connect)
         client.connect_status.connect(_client_connect_status)
@@ -118,6 +119,7 @@ func _ready():
 
         keyboard = SCRIPT_keyboard.new()
         add_child(keyboard)
+        client.keyboard_update_received.connect(keyboard.remote_keyboard_updated)
 
 
 func saveSettings():
@@ -194,6 +196,7 @@ func _process_item(item, amount):
                         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:
@@ -326,6 +329,13 @@ func _on_checked_locations_updated():
                 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)
 
@@ -440,6 +450,10 @@ func _client_connected(slot_data):
 
                 _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()
 
 
@@ -8,6 +8,13 @@ var tracker_label
 var is_open = false
 
 var locations_overlay
+var location_texture
+var worldport_texture
+
+var worldports_tab
+var worldports_tree
+var port_tree_item_by_map = {}
+var port_tree_item_by_map_port = {}
 
 
 func _ready():
@@ -20,9 +27,10 @@ func _ready():
         locations_overlay.offset_bottom = 720
         locations_overlay.offset_left = 20
         locations_overlay.anchor_right = 1.0
-        locations_overlay.offset_right = -20
+        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()
 
@@ -83,6 +91,31 @@ func _ready():
         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)
+
 
 func _input(event):
         if global.loaded and event is InputEventKey and event.pressed:
@@ -144,11 +177,22 @@ func update_locations():
         locations_overlay.push_outline_color(Color(0, 0, 0, 1))
         locations_overlay.push_outline_size(2)
 
+        const kLocation = 0
+        const kWorldport = 1
+
         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()
 
@@ -156,7 +200,14 @@ func update_locations():
         for location_name in location_names:
                 tracker_label.append_text("[p]%s[/p]" % location_name)
                 if count < 18:
-                        locations_overlay.append_text("[p align=right]%s[/p]" % location_name)
+                        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)
+                        locations_overlay.pop()
                 count += 1
 
         if count > 18:
@@ -168,5 +219,77 @@ func update_locations_visibility():
         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()
@@ -3,6 +3,8 @@ extends "res://scripts/nodes/worldport.gd"
 var absolute_rotation = false
 var target_rotation = 0
 
+var port_id = null
+
 
 func _ready():
         var node_path = String(
@@ -13,7 +15,7 @@ func _ready():
 
         if ap.shuffle_worldports:
                 var gamedata = global.get_node("Gamedata")
-                var port_id = gamedata.get_port_for_map_node_path(global.map, node_path)
+                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]]
@@ -29,6 +31,8 @@ func _ready():
                                 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:
@@ -39,6 +43,10 @@ func _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
 
@@ -15,35 +15,99 @@ from Utils import async_start
 from . import Lingo2World
 from .tracker import Tracker
 
-PORT = 43182
+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]
+
+    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()
+
+    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
-    client: "Lingo2ClientContext"
-    tracker: Tracker
+    manager: Lingo2Manager
 
     def __init__(self):
         self.server = None
-        self.tracker = Tracker()
 
     def send_connected(self):
+        if self.server is None:
+            return
+
         msg = {
             "cmd": "Connected",
-            "user": self.client.username,
-            "seed_name": self.client.seed_name,
-            "version": self.client.server_version,
-            "generator_version": self.client.generator_version,
-            "team": self.client.team,
-            "slot": self.client.slot,
-            "checked_locations": self.client.checked_locations,
-            "slot_data": self.client.slot_data,
+            "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_item_sent_notification(self, item_name, receiver_name, item_flags):
+        if self.server is None:
+            return
+
         msg = {
             "cmd": "ItemSentNotif",
             "item_name": item_name,
@@ -54,6 +118,9 @@ class Lingo2GameContext:
         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,
@@ -66,6 +133,9 @@ class Lingo2GameContext:
         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,
@@ -74,6 +144,9 @@ class Lingo2GameContext:
         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,
@@ -82,6 +155,9 @@ class Lingo2GameContext:
         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,
@@ -90,14 +166,23 @@ class Lingo2GameContext:
         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.tracker.accessible_locations),
+            "locations": list(self.manager.tracker.accessible_locations),
         }
 
+        if len(self.manager.tracker.accessible_worldports) > 0:
+            msg["worldports"] = list(self.manager.tracker.accessible_worldports)
+
         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,
@@ -105,6 +190,28 @@ class Lingo2GameContext:
 
         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:
@@ -113,7 +220,7 @@ class Lingo2GameContext:
 
 
 class Lingo2ClientContext(CommonContext):
-    game_ctx: Lingo2GameContext
+    manager: Lingo2Manager
 
     game = "Lingo 2"
     items_handling = 0b111
@@ -138,118 +245,227 @@ class Lingo2ClientContext(CommonContext):
         elif cmd == "Connected":
             self.slot_data = args.get("slot_data", None)
 
-            if self.game_ctx.server is not None:
-                self.game_ctx.send_connected()
-
-            self.game_ctx.tracker.setup_slot(self.slot_data)
+            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.set_notify(self.get_datastorage_key("keyboard1"), self.get_datastorage_key("keyboard2"))
+            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["shuffle_worldports"]:
+                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 self.game_ctx.server is not None:
-                self.game_ctx.send_update_locations(args["checked_locations"])
+            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.game_ctx.tracker.set_collected_items(self.items_received)
+            self.manager.tracker.set_collected_items(self.items_received)
 
-            if self.game_ctx.server is not None:
-                cur_index = 0
-                items = []
+            cur_index = 0
+            items = []
 
-                for item in args["items"]:
-                    index = cur_index + args["index"]
-                    cur_index += 1
+            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),
-                    }
+                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)
+                if item.player != self.slot:
+                    item_msg["sender"] = self.player_names.get(item.player)
 
-                    items.append(item_msg)
+                items.append(item_msg)
 
-                self.game_ctx.send_item_received(items)
+            self.manager.game_ctx.send_item_received(items)
 
-                if any(ItemClassification.progression in ItemClassification(item.flags) for item in args["items"]):
-                    self.game_ctx.send_accessible_locations()
+            if any(ItemClassification.progression in ItemClassification(item.flags) for item in args["items"]):
+                self.manager.game_ctx.send_accessible_locations()
         elif cmd == "PrintJSON":
-            if self.game_ctx.server is not None:
-                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.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.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.game_ctx.send_text_message(parts)
-        elif cmd == "LocationInfo":
-            if self.game_ctx.server is not None:
-                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,
+            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.game_ctx.send_location_info(locations)
-
-        if cmd in ["Connected", "RoomUpdate"]:
-            self.game_ctx.tracker.set_checked_locations(self.checked_locations)
-
-
-async def pipe_loop(ctx: Lingo2GameContext):
-    while not ctx.client.exit_event.is_set():
+            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 == "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)
+
+    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
+            }]
+        }])
+
+
+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)
-            ctx.server = Endpoint(socket)
+            manager.game_ctx.server = Endpoint(socket)
             logger.info("Connected to Lingo 2!")
-            if ctx.client.auth is not None:
-                ctx.send_connected()
-                ctx.send_accessible_locations()
-            async for data in ctx.server.socket:
+            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(ctx, msg)
+                    await process_game_cmd(manager, msg)
         except ConnectionRefusedError:
             logger.info("Could not connect to Lingo 2.")
         finally:
-            ctx.server = None
+            manager.game_ctx.server = None
 
 
-async def process_game_cmd(ctx: Lingo2GameContext, args: dict):
+async def process_game_cmd(manager: Lingo2Manager, args: dict):
     cmd = args["cmd"]
 
     if cmd == "Connect":
@@ -262,13 +478,27 @@ async def process_game_cmd(ctx: Lingo2GameContext, args: dict):
         else:
             server_address = f"{player}:None@{server}"
 
-        async_start(ctx.client.connect(server_address), name="client connect")
+        async_start(manager.client_ctx.connect(server_address), name="client connect")
     elif cmd == "Disconnect":
-        async_start(ctx.client.disconnect(), name="client disconnect")
+        async_start(manager.client_ctx.disconnect(), name="client disconnect")
     elif cmd in ["Sync", "LocationChecks", "Say", "StatusUpdate", "LocationScouts"]:
-        async_start(ctx.client.send_msgs([args]), name="client forward")
+        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":
-        ctx.client.exit_event.set()
+        manager.client_ctx.exit_event.set()
 
 
 async def run_game():
@@ -318,9 +548,7 @@ def client_main(*launch_args: str) -> None:
 
         client_ctx = Lingo2ClientContext(args.connect, args.password)
         game_ctx = Lingo2GameContext()
-
-        client_ctx.game_ctx = game_ctx
-        game_ctx.client = client_ctx
+        manager = Lingo2Manager(game_ctx, client_ctx)
 
         client_ctx.server_task = asyncio.create_task(server_loop(client_ctx), name="ServerLoop")
 
@@ -328,7 +556,7 @@ def client_main(*launch_args: str) -> None:
             client_ctx.run_gui()
         client_ctx.run_cli()
 
-        pipe_task = asyncio.create_task(pipe_loop(game_ctx), name="GameWatcher")
+        pipe_task = asyncio.create_task(pipe_loop(manager), name="GameWatcher")
 
         try:
             await pipe_task
@@ -3,3 +3,5 @@ from BaseClasses import Location
 
 class Lingo2Location(Location):
     game: str = "Lingo 2"
+
+    port_id: int
@@ -297,13 +297,14 @@ class Lingo2PlayerLogic:
                                                                                         AccessRequirements()))
             behavior = self.get_letter_behavior(letter.key, letter.level2)
             if behavior == LetterBehavior.VANILLA:
-                letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
-                event_name = f"{letter_name} (Collected)"
-                self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
-
-                if letter.level2:
-                    event_name = f"{letter_name} (Double Collected)"
+                if not world.for_tracker:
+                    letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
+                    event_name = f"{letter_name} (Collected)"
                     self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
+
+                    if letter.level2:
+                        event_name = f"{letter_name} (Double Collected)"
+                        self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
             elif behavior == LetterBehavior.ITEM:
                 self.real_items.append(letter.key.upper())
 
@@ -32,6 +32,22 @@ def create_locations(room, new_region: Region, world: "Lingo2World", regions: di
         new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
+    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"):
     regions = {
         "Menu": Region("Menu", world.player, world.multiworld)
@@ -52,7 +68,6 @@ def create_regions(world: "Lingo2World"):
 
     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
@@ -176,11 +191,17 @@ def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
 
         connection = Entrance(world.player, f"{from_region_name} - {from_port.name}", from_region)
 
+        reqs = AccessRequirements()
         if from_port.HasField("required_door"):
-            door_reqs = world.player_logic.get_door_open_reqs(from_port.required_door)
-            connection.access_rule = make_location_lambda(door_reqs, world, None)
+            reqs = world.player_logic.get_door_open_reqs(from_port.required_door).copy()
 
-            for region in door_reqs.get_referenced_rooms():
+        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)
 
@@ -2,6 +2,7 @@ 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]
@@ -1,41 +1,54 @@
+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
+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]
 
     state: CollectionState
 
-    def __init__(self):
+    def __init__(self, manager: "Lingo2Manager"):
+        self.manager = manager
         self.collected_items = {}
         self.checked_locations = set()
         self.accessible_locations = set()
+        self.accessible_worldports = set()
 
     def setup_slot(self, slot_data):
+        Lingo2World.for_tracker = True
+
         self.multiworld = MultiWorld(players=PLAYER_NUM)
-        world = Lingo2World(self.multiworld, PLAYER_NUM)
-        self.multiworld.worlds[1] = world
-        world.options = Lingo2Options(**{k: t(slot_data.get(k, t.default))
-                                         for k, t in Lingo2Options.type_hints.items()})
+        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()})
 
-        world.generate_early()
-        world.create_regions()
+        self.world.generate_early()
+        self.world.create_regions()
 
-        if world.options.shuffle_worldports:
+        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, world)
+            connect_ports_from_ut(port_pairings, self.world)
 
-        self.state = CollectionState(self.multiworld)
+        self.refresh_state()
 
     def set_checked_locations(self, checked_locations: set[int]):
         self.checked_locations = checked_locations.copy()
@@ -56,12 +69,38 @@ class Tracker:
                 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()
 
         for region in self.state.reachable_regions[PLAYER_NUM]:
             for location in region.locations:
-                if location.address not in self.checked_locations and location.access_rule(self.state):
+                if location.access_rule(self.state):
                     if location.address is not None:
-                        self.accessible_locations.add(location.address)
+                        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)