1 files changed, 180 insertions, 7 deletions

@@ -30,6 +30,16 @@ KEY_STORAGE_MAPPING = {
 REVERSE_KEY_STORAGE_MAPPING = {t: k for k, t in KEY_STORAGE_MAPPING.items()}
 
 
+# There is a distinction between an object's ID and its AP ID. The latter is stable between releases, whereas the former
+# can change and is also namespaced based on the object type. We should only store AP IDs in multiworld state (such as
+# slot data and data storage) to increase compatability between releases. The data we currently store is:
+# - Port pairings for worldport shuffle (slot data)
+# - Checked worldports for worldport shuffle (data storage)
+# - Latched doors (data storage)
+# The client generally deals in the actual object IDs rather than the stable IDs, although it does have to convert the
+# port pairing IDs when reading them from slot data. The context (this file here) does the work of converting back and
+# forth between the values. AP IDs are converted to IDs after reading them from data storage, and IDs are converted to
+# AP IDs before sending them to data storage.
 class Lingo2Manager:
     game_ctx: "Lingo2GameContext"
     client_ctx: "Lingo2ClientContext"
@@ -38,6 +48,8 @@ class Lingo2Manager:
     keyboard: dict[str, int]
     worldports: set[int]
     goaled: bool
+    latches: set[int]
+    hinted_locations: set[int]
 
     def __init__(self, game_ctx: "Lingo2GameContext", client_ctx: "Lingo2ClientContext"):
         self.game_ctx = game_ctx
@@ -46,7 +58,6 @@ class Lingo2Manager:
         self.client_ctx.manager = self
         self.tracker = Tracker(self)
         self.keyboard = {}
-        self.worldports = set()
 
         self.reset()
 
@@ -56,6 +67,8 @@ class Lingo2Manager:
 
         self.worldports = set()
         self.goaled = False
+        self.latches = set()
+        self.hinted_locations = set()
 
     def update_keyboard(self, new_keyboard: dict[str, int]) -> dict[str, int]:
         ret: dict[str, int] = {}
@@ -71,6 +84,7 @@ class Lingo2Manager:
 
         return ret
 
+    # Input should be real IDs, not AP IDs
     def update_worldports(self, new_worldports: set[int]) -> set[int]:
         ret = new_worldports.difference(self.worldports)
         self.worldports.update(new_worldports)
@@ -81,6 +95,18 @@ class Lingo2Manager:
 
         return ret
 
+    def update_latches(self, new_latches: set[int]) -> set[int]:
+        ret = new_latches.difference(self.latches)
+        self.latches.update(new_latches)
+
+        return ret
+
+    def update_hinted_locations(self, new_locs: set[int]) -> set[int]:
+        ret = new_locs.difference(self.hinted_locations)
+        self.hinted_locations.update(new_locs)
+
+        return ret
+
 
 class Lingo2GameContext:
     server: Endpoint | None
@@ -218,6 +244,7 @@ class Lingo2GameContext:
 
         async_start(self.send_msgs([msg]), name="update keyboard")
 
+    # Input should be real IDs, not AP IDs
     def send_update_worldports(self, worldports):
         if self.server is None:
             return
@@ -229,6 +256,54 @@ class Lingo2GameContext:
 
         async_start(self.send_msgs([msg]), name="update worldports")
 
+    def send_path_reply(self, object_type: str, object_id: int | None, path: list[str]):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "PathReply",
+            "type": object_type,
+            "path": path,
+        }
+
+        if object_id is not None:
+            msg["id"] = object_id
+
+        async_start(self.send_msgs([msg]), name="path reply")
+
+    def send_update_latches(self, latches):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateLatches",
+            "latches": latches,
+        }
+
+        async_start(self.send_msgs([msg]), name="update latches")
+
+    def send_ignored_locations(self, ignored_locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "SetIgnoredLocations",
+            "locations": ignored_locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="set ignored locations")
+
+    def send_update_hinted_locations(self, hinted_locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateHintedLocations",
+            "locations": hinted_locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="update hinted locations")
+
     async def send_msgs(self, msgs: list[Any]) -> None:
         """ `msgs` JSON serializable """
         if not self.server or not self.server.socket.open or self.server.socket.closed:
@@ -243,6 +318,7 @@ class Lingo2ClientContext(CommonContext):
     items_handling = 0b111
 
     slot_data: dict[str, Any] | None
+    hints_data_storage_key: str
     victory_data_storage_key: str
 
     def __init__(self, server_address: str | None = None, password: str | None = None):
@@ -280,10 +356,12 @@ class Lingo2ClientContext(CommonContext):
             self.manager.tracker.set_checked_locations(self.checked_locations)
             self.manager.game_ctx.send_accessible_locations()
 
+            self.hints_data_storage_key = f"_read_hints_{self.team}_{self.slot}"
             self.victory_data_storage_key = f"_read_client_status_{self.team}_{self.slot}"
 
             self.set_notify(self.get_datastorage_key("keyboard1"), self.get_datastorage_key("keyboard2"),
-                            self.victory_data_storage_key)
+                            self.victory_data_storage_key, self.get_datastorage_key("latches"),
+                            self.get_datastorage_key("ignored_locations"))
             msg_batch = [{
                 "cmd": "Set",
                 "key": self.get_datastorage_key("keyboard1"),
@@ -296,6 +374,18 @@ class Lingo2ClientContext(CommonContext):
                 "default": 0,
                 "want_reply": True,
                 "operations": [{"operation": "default", "value": 0}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("latches"),
+                "default": [],
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": []}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("ignored_locations"),
+                "default": [],
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": []}]
             }]
 
             if self.slot_data.get("shuffle_worldports", False):
@@ -394,17 +484,29 @@ class Lingo2ClientContext(CommonContext):
             for k, v in args["keys"].items():
                 if k == self.victory_data_storage_key:
                     self.handle_status_update(v)
+                elif k == self.hints_data_storage_key:
+                    self.update_hints()
         elif cmd == "SetReply":
             if args["key"] == self.get_datastorage_key("keyboard1"):
                 self.handle_keyboard_update(1, args)
             elif args["key"] == self.get_datastorage_key("keyboard2"):
                 self.handle_keyboard_update(2, args)
             elif args["key"] == self.get_datastorage_key("worldports"):
-                updates = self.manager.update_worldports(set(args["value"]))
+                port_ids = set(Lingo2World.static_logic.port_id_by_ap_id[ap_id] for ap_id in args["value"])
+                updates = self.manager.update_worldports(port_ids)
                 if len(updates) > 0:
                     self.manager.game_ctx.send_update_worldports(updates)
             elif args["key"] == self.victory_data_storage_key:
                 self.handle_status_update(args["value"])
+            elif args["key"] == self.get_datastorage_key("latches"):
+                door_ids = set(Lingo2World.static_logic.door_id_by_ap_id[ap_id] for ap_id in args["value"])
+                updates = self.manager.update_latches(door_ids)
+                if len(updates) > 0:
+                    self.manager.game_ctx.send_update_latches(updates)
+            elif args["key"] == self.get_datastorage_key("ignored_locations"):
+                self.manager.game_ctx.send_ignored_locations(args["value"])
+            elif args["key"] == self.hints_data_storage_key:
+                self.update_hints()
 
     def get_datastorage_key(self, name: str):
         return f"Lingo2_{self.slot}_{name}"
@@ -470,14 +572,16 @@ class Lingo2ClientContext(CommonContext):
         if len(updates) > 0:
             self.manager.game_ctx.send_update_keyboard(updates)
 
+    # Input should be real IDs, not AP IDs
     async def update_worldports(self, updates: set[int]):
+        port_ap_ids = [Lingo2World.static_logic.objects.ports[port_id].ap_id for port_id in updates]
         await self.send_msgs([{
             "cmd": "Set",
             "key": self.get_datastorage_key("worldports"),
             "want_reply": True,
             "operations": [{
                 "operation": "update",
-                "value": updates
+                "value": port_ap_ids
             }]
         }])
 
@@ -486,6 +590,48 @@ class Lingo2ClientContext(CommonContext):
         self.manager.tracker.refresh_state()
         self.manager.game_ctx.send_accessible_locations()
 
+    async def update_latches(self, updates: set[int]):
+        door_ap_ids = [Lingo2World.static_logic.objects.doors[door_id].ap_id for door_id in updates]
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("latches"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": door_ap_ids
+            }]
+        }])
+
+    async def add_ignored_location(self, loc_id: int):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("ignored_locations"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": [loc_id]
+            }]
+        }])
+
+    async def remove_ignored_location(self, loc_id: int):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("ignored_locations"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "remove",
+                "value": loc_id
+            }]
+        }])
+
+    def update_hints(self):
+        hints = self.stored_data.get(self.hints_data_storage_key, [])
+
+        hinted_locations = set(hint["location"] for hint in hints if hint["finding_player"] == self.slot)
+        updates = self.manager.update_hinted_locations(hinted_locations)
+        if len(updates) > 0:
+            self.manager.game_ctx.send_update_hinted_locations(updates)
+
 
 async def pipe_loop(manager: Lingo2Manager):
     while not manager.client_ctx.exit_event.is_set():
@@ -534,14 +680,38 @@ async def process_game_cmd(manager: Lingo2Manager, args: dict):
             async_start(manager.client_ctx.update_keyboard(updates), name="client update keyboard")
     elif cmd == "CheckWorldport":
         port_id = args["port_id"]
+        port_ap_id = Lingo2World.static_logic.objects.ports[port_id].ap_id
         worldports = {port_id}
-        if str(port_id) in manager.client_ctx.slot_data["port_pairings"]:
-            worldports.add(manager.client_ctx.slot_data["port_pairings"][str(port_id)])
+
+        # Also check the reverse port if it's a two-way connection.
+        port_pairings = manager.client_ctx.slot_data["port_pairings"]
+        if str(port_ap_id) in port_pairings and\
+                port_pairings.get(str(port_pairings[str(port_ap_id)]), None) == port_ap_id:
+            worldports.add(Lingo2World.static_logic.port_id_by_ap_id[port_pairings[str(port_ap_id)]])
 
         updates = manager.update_worldports(worldports)
         if len(updates) > 0:
             async_start(manager.client_ctx.update_worldports(updates), name="client update worldports")
             manager.game_ctx.send_update_worldports(updates)
+    elif cmd == "GetPath":
+        path = None
+
+        if args["type"] == "location":
+            path = manager.tracker.get_path_to_location(args["id"])
+        elif args["type"] == "worldport":
+            path = manager.tracker.get_path_to_port(args["id"])
+        elif args["type"] == "goal":
+            path = manager.tracker.get_path_to_goal()
+
+        manager.game_ctx.send_path_reply(args["type"], args.get("id", None), path)
+    elif cmd == "LatchDoor":
+        updates = manager.update_latches({args["door"]})
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_latches(updates), name="client update latches")
+    elif cmd == "IgnoreLocation":
+        async_start(manager.client_ctx.add_ignored_location(args["id"]), name="client ignore loc")
+    elif cmd == "UnignoreLocation":
+        async_start(manager.client_ctx.remove_ignored_location(args["id"]), name="client unignore loc")
     elif cmd == "Quit":
         manager.client_ctx.exit_event.set()
 
@@ -589,9 +759,12 @@ async def run_game():
 
 def client_main(*launch_args: str) -> None:
     async def main(args):
-        async_start(run_game())
+        if settings.get_settings().lingo2_options.start_game:
+            async_start(run_game())
 
         client_ctx = Lingo2ClientContext(args.connect, args.password)
+        client_ctx.auth = args.name
+
         game_ctx = Lingo2GameContext()
         manager = Lingo2Manager(game_ctx, client_ctx)