13 files changed, 289 insertions, 18 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):
@@ -163,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,7 @@ 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
 
 
@@ -55,7 +58,9 @@ func _reset_state():
         _should_process = false
         _received_items = {}
         _received_indexes = []
+        _checked_worldports = []
         _accessible_locations = []
+        _accessible_worldports = []
 
 
 func disconnect_from_ap():
@@ -117,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"])
@@ -152,10 +165,15 @@ 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":
@@ -226,6 +244,11 @@ 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"}])
 
@@ -173,6 +173,11 @@ func get_door_receivers(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()
 
@@ -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)
@@ -195,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:
@@ -327,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)
 
@@ -441,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
 
@@ -35,6 +35,7 @@ class Lingo2Manager:
     tracker: Tracker
 
     keyboard: dict[str, int]
+    worldports: set[int]
 
     def __init__(self, game_ctx: "Lingo2GameContext", client_ctx: "Lingo2ClientContext"):
         self.game_ctx = game_ctx
@@ -43,6 +44,7 @@ class Lingo2Manager:
         self.client_ctx.manager = self
         self.tracker = Tracker(self)
         self.keyboard = {}
+        self.worldports = set()
 
         self.reset()
 
@@ -50,6 +52,8 @@ class Lingo2Manager:
         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] = {}
 
@@ -64,6 +68,16 @@ class Lingo2Manager:
 
         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
@@ -160,6 +174,9 @@ class Lingo2GameContext:
             "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):
@@ -184,6 +201,17 @@ class Lingo2GameContext:
 
         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:
@@ -226,7 +254,7 @@ class Lingo2ClientContext(CommonContext):
             self.manager.game_ctx.send_accessible_locations()
 
             self.set_notify(self.get_datastorage_key("keyboard1"), self.get_datastorage_key("keyboard2"))
-            async_start(self.send_msgs([{
+            msg_batch = [{
                 "cmd": "Set",
                 "key": self.get_datastorage_key("keyboard1"),
                 "default": 0,
@@ -238,10 +266,23 @@ class Lingo2ClientContext(CommonContext):
                 "default": 0,
                 "want_reply": True,
                 "operations": [{"operation": "default", "value": 0}]
-            }]), name="default keys")
+            }]
+
+            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":
-            self.manager.tracker.set_checked_locations(self.checked_locations)
-            self.manager.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.manager.tracker.set_collected_items(self.items_received)
 
@@ -276,7 +317,7 @@ class Lingo2ClientContext(CommonContext):
 
                 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)
+                                                             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)
 
@@ -324,6 +365,10 @@ class Lingo2ClientContext(CommonContext):
                 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}"
@@ -373,8 +418,6 @@ class Lingo2ClientContext(CommonContext):
             })
 
         if len(msgs) > 0:
-            print(updates)
-            print(msgs)
             await self.send_msgs(msgs)
 
     def handle_keyboard_update(self, field: int, args: dict[str, Any]):
@@ -391,6 +434,17 @@ class Lingo2ClientContext(CommonContext):
         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():
@@ -433,6 +487,16 @@ async def process_game_cmd(manager: Lingo2Manager, args: dict):
         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()
 
@@ -3,3 +3,5 @@ from BaseClasses import Location
 
 class Lingo2Location(Location):
     game: str = "Lingo 2"
+
+    port_id: int
@@ -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)
 
@@ -21,6 +21,7 @@ class Tracker:
     collected_items: dict[int, int]
     checked_locations: set[int]
     accessible_locations: set[int]
+    accessible_worldports: set[int]
 
     state: CollectionState
 
@@ -29,6 +30,7 @@ class Tracker:
         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
@@ -84,12 +86,21 @@ class Tracker:
                     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)