1 files changed, 145 insertions, 13 deletions

@@ -1,7 +1,8 @@
-from .generated import common_pb2 as common_pb2
 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]
@@ -9,42 +10,173 @@ class Lingo2StaticLogic:
     item_name_to_id: dict[str, int]
     location_name_to_id: dict[str, int]
 
+    item_name_groups: dict[str, list[str]]
+    location_name_groups: dict[str, list[str]]
+
+    letter_weights: dict[str, int]
+
+    door_id_by_ap_id: dict[int, int]
+    port_id_by_ap_id: dict[int, int]
+
     def __init__(self):
         self.item_id_to_name = {}
         self.location_id_to_name = {}
+        self.item_name_groups = {}
+        self.location_name_groups = {}
+        self.letter_weights = {}
 
         file = pkgutil.get_data(__name__, "generated/data.binpb")
         self.objects = data_pb2.AllObjects()
         self.objects.ParseFromString(bytearray(file))
 
         for door in self.objects.doors:
-            if door.type in [common_pb2.DoorType.STANDARD, common_pb2.DoorType.LOCATION_ONLY]:
-                location_name = f"{self.objects.maps[door.map_id].name} - {door.name}"
+            if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
+                location_name = self.get_door_location_name(door)
                 self.location_id_to_name[door.ap_id] = location_name
 
-            if door.type not in [common_pb2.DoorType.EVENT, common_pb2.DoorType.LOCATION_ONLY]:
-                item_name = self.get_door_item_name(door.id)
+            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)
                 self.item_id_to_name[door.ap_id] = item_name
 
         for letter in self.objects.letters:
-            letter_name = f"{letter.key.upper()}{'' if letter.double else '2'}"
-            location_name = f"{self.objects.maps[self.objects.rooms[letter.room_id].map_id].name} - {letter_name}"
+            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.double:
-                self.item_id_to_name[letter.ap_id] = letter_name
+            if not letter.level2:
+                self.item_id_to_name[letter.ap_id] = letter.key.upper()
+                self.item_name_groups.setdefault("Letters", []).append(letter.key.upper())
 
         for mastery in self.objects.masteries:
-            location_name = f"{self.objects.maps[self.objects.rooms[mastery.room_id].map_id].name} - Mastery"
+            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"
+        self.item_id_to_name[self.objects.special_ids["Numbers"]] = "Numbers"
+
+        for symbol_name in SYMBOL_ITEMS.values():
+            self.item_id_to_name[self.objects.special_ids[symbol_name]] = symbol_name
+
+        for trap_name in ANTI_COLLECTABLE_TRAPS:
+            self.item_id_to_name[self.objects.special_ids[trap_name]] = trap_name
 
         self.item_name_to_id = {name: ap_id for ap_id, name in self.item_id_to_name.items()}
         self.location_name_to_id = {name: ap_id for ap_id, name in self.location_id_to_name.items()}
 
-    def get_door_item_name(self, door_id: int) -> str:
+        for panel in self.objects.panels:
+            for letter in panel.answer.upper():
+                if letter.isalpha():
+                    self.letter_weights[letter] = self.letter_weights.get(letter, 0) + 1
+
+        self.door_id_by_ap_id = {door.ap_id: door.id for door in self.objects.doors if door.HasField("ap_id")}
+        self.port_id_by_ap_id = {port.ap_id: port.id for port in self.objects.ports if port.HasField("ap_id")}
+
+    def get_door_item_name(self, door: data_pb2.Door) -> str:
+        return f"{self.get_map_object_map_name(door)} - {door.name}"
+
+    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 door.white_ending 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 f"{self.objects.maps[door.map_id].name} - {door.name}"
+        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.objects.maps[room.map_id].name} - {room.name}"
+        return f"{self.get_map_object_map_name(room)} - {room.name}"
+
+    def get_map_object_map_name(self, obj) -> str:
+        return self.objects.maps[obj.map_id].display_name
+
+    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_room_object_map_id(self, obj) -> int:
+        return self.objects.rooms[obj.room_id].map_id
+
+    def get_data_version(self) -> list[int]:
+        version = self.objects.version
+        return [version.major, version.minor, version.patch]