Worked on daed-only mode daed-only

1 files changed, 47 insertions, 13 deletions

@@ -203,6 +203,8 @@ class Lingo2PlayerLogic:
     world: "Lingo2World"
 
     shuffled_maps: set[int]
+    shuffled_rooms: set[int]
+    shuffled_doors: set[int]
 
     locations_by_room: dict[int, list[PlayerLocation]]
     event_loc_item_by_room: dict[int, dict[str, str]]
@@ -220,6 +222,8 @@ class Lingo2PlayerLogic:
 
     def __init__(self, world: "Lingo2World"):
         self.world = world
+        self.shuffled_rooms = set()
+        self.shuffled_doors = set()
         self.locations_by_room = {}
         self.event_loc_item_by_room = {}
         self.item_by_door = {}
@@ -229,7 +233,10 @@ class Lingo2PlayerLogic:
         self.real_items = list()
         self.double_letter_amount = dict()
 
-        def should_shuffle_map(game_map) -> bool:
+        def should_shuffle_map(game_map) -> bool | set[int]:
+            if world.options.daedalus_only:
+                return game_map.daedalus_only_mode == data_pb2.DaedalusOnlyMode.DAED_ONLY_ALLOW
+
             if game_map.type == data_pb2.MapType.NORMAL_MAP:
                 return True
             elif game_map.type == data_pb2.MapType.ICARUS:
@@ -251,6 +258,14 @@ class Lingo2PlayerLogic:
         self.shuffled_maps = set(game_map.id for game_map in world.static_logic.objects.maps
                                  if should_shuffle_map(game_map))
 
+        if world.options.daedalus_only:
+            for game_map in world.static_logic.objects.maps:
+                if game_map.daedalus_only_mode == data_pb2.DaedalusOnlyMode.DAED_ONLY_PARTIAL:
+                    self.shuffled_rooms.update(set(room.id for room in world.static_logic.objects.rooms
+                                                   if room.map_id == game_map.id and room.daedalus_only_allow))
+                    self.shuffled_doors.update(set(door.id for door in world.static_logic.objects.doors
+                                                   if door.map_id == game_map.id and door.daedalus_only_allow))
+
         maximum_masteries = 13 + len(world.options.enable_gift_maps.value)
         if world.options.enable_icarus:
             maximum_masteries += 1
@@ -265,7 +280,7 @@ class Lingo2PlayerLogic:
             for progressive in world.static_logic.objects.progressives:
                 for i in range(0, len(progressive.doors)):
                     door = world.static_logic.objects.doors[progressive.doors[i]]
-                    if door.map_id not in self.shuffled_maps:
+                    if not self.should_shuffle_door(door.id):
                         continue
 
                     self.item_by_door[progressive.doors[i]] = (progressive.name, i + 1)
@@ -279,13 +294,15 @@ class Lingo2PlayerLogic:
                 if not self.world.options.shuffle_control_center_colors or self.world.options.shuffle_worldports:
                     continue
             elif door_group.type == data_pb2.DoorGroupType.SHUFFLE_GROUP:
-                if not self.world.options.shuffle_doors:
+                if door_group.name == "Lavender Cubes" and self.world.options.daedalus_only:
+                    # Always shuffle this if we're in Daed-only mode.
+                    pass
+                elif not self.world.options.shuffle_doors:
                     continue
             else:
                 continue
 
-            shuffleable_doors = [door_id for door_id in door_group.doors
-                                 if world.static_logic.objects.doors[door_id].map_id in self.shuffled_maps]
+            shuffleable_doors = [door_id for door_id in door_group.doors if self.should_shuffle_door(door_id)]
 
             if len(shuffleable_doors) > 0:
                 for door in shuffleable_doors:
@@ -296,7 +313,7 @@ class Lingo2PlayerLogic:
         # We iterate through the doors in two parts because it is essential that we determine which doors are shuffled
         # before we calculate any access requirements.
         for door in world.static_logic.objects.doors:
-            if door.map_id not in self.shuffled_maps:
+            if not self.should_shuffle_door(door.id):
                 continue
 
             if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
@@ -328,8 +345,7 @@ class Lingo2PlayerLogic:
                     continue
 
                 shuffleable_doors = [door_id for door_id in door_group.doors
-                                     if world.static_logic.objects.doors[door_id].map_id in self.shuffled_maps
-                                     and door_id not in self.item_by_door]
+                                     if self.should_shuffle_door(door_id) and door_id not in self.item_by_door]
 
                 if len(shuffleable_doors) > 0:
                     for door in shuffleable_doors:
@@ -338,7 +354,7 @@ class Lingo2PlayerLogic:
                     self.real_items.append(door_group.name)
 
         for door in world.static_logic.objects.doors:
-            if door.map_id not in self.shuffled_maps:
+            if not self.should_shuffle_door(door.id):
                 continue
 
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
@@ -346,7 +362,7 @@ class Lingo2PlayerLogic:
                                                                                           self.get_door_reqs(door.id)))
 
         for letter in world.static_logic.objects.letters:
-            if world.static_logic.get_room_object_map_id(letter) not in self.shuffled_maps:
+            if not self.should_shuffle_room(letter.room_id):
                 continue
 
             self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
@@ -368,7 +384,7 @@ class Lingo2PlayerLogic:
                 self.double_letter_amount[letter.key.upper()] = self.double_letter_amount.get(letter.key.upper(), 0) + 1
 
         for mastery in world.static_logic.objects.masteries:
-            if world.static_logic.get_room_object_map_id(mastery) not in self.shuffled_maps:
+            if not self.should_shuffle_room(mastery.room_id):
                 continue
 
             self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
@@ -379,7 +395,7 @@ class Lingo2PlayerLogic:
                 self.event_loc_item_by_room.setdefault(mastery.room_id, {})[event_name] = "Mastery"
 
         for ending in world.static_logic.objects.endings:
-            if world.static_logic.get_room_object_map_id(ending) not in self.shuffled_maps:
+            if not self.should_shuffle_room(ending.room_id):
                 continue
 
             # Don't create a location for your selected ending. Also don't create a location for White Ending if it's
@@ -401,7 +417,7 @@ class Lingo2PlayerLogic:
         if self.world.options.keyholder_sanity:
             for keyholder in world.static_logic.objects.keyholders:
                 if keyholder.HasField("key"):
-                    if world.static_logic.get_room_object_map_id(keyholder) not in self.shuffled_maps:
+                    if not self.should_shuffle_room(keyholder.room_id):
                         continue
 
                     reqs = AccessRequirements()
@@ -606,3 +622,21 @@ class Lingo2PlayerLogic:
 
         if any(l.isnumeric() for l in solution):
             reqs.items.add("Numbers")
+
+    def should_shuffle_room(self, room_id: int) -> bool:
+        if room_id in self.shuffled_rooms:
+            return True
+
+        room = self.world.static_logic.objects.rooms[room_id]
+        game_map = self.world.static_logic.objects.maps[room.map_id]
+
+        return game_map.id in self.shuffled_maps
+
+    def should_shuffle_door(self, door_id: int) -> bool:
+        if door_id in self.shuffled_doors:
+            return True
+
+        door = self.world.static_logic.objects.doors[door_id]
+        game_map = self.world.static_logic.objects.maps[door.map_id]
+
+        return game_map.id in self.shuffled_maps