1 files changed, 140 insertions, 42 deletions

@@ -4,7 +4,7 @@ from .generated import data_pb2 as data_pb2
 from .items import SYMBOL_ITEMS
 from typing import TYPE_CHECKING, NamedTuple
 
-from .options import VictoryCondition, ShuffleLetters, CyanDoorBehavior
+from .options import ShuffleLetters, CyanDoorBehavior
 
 if TYPE_CHECKING:
     from . import Lingo2World
@@ -73,7 +73,7 @@ class AccessRequirements:
         self.cyans = self.cyans or other.cyans
 
         for disjunction in other.or_logic:
-            self.or_logic.append(disjunction)
+            self.or_logic.append([sub_req.copy() for sub_req in disjunction])
 
         if other.complete_at is not None:
             # Merging multiple requirements that use complete_at sucks, and is part of why we want to minimize use of
@@ -84,7 +84,7 @@ class AccessRequirements:
 
                 left_req = AccessRequirements()
                 left_req.complete_at = self.complete_at
-                left_req.possibilities = self.possibilities
+                left_req.possibilities = [sub_req.copy() for sub_req in self.possibilities]
                 self.or_logic.append([left_req])
 
                 self.complete_at = None
@@ -92,11 +92,11 @@ class AccessRequirements:
 
                 right_req = AccessRequirements()
                 right_req.complete_at = other.complete_at
-                right_req.possibilities = other.possibilities
+                right_req.possibilities = [sub_req.copy() for sub_req in other.possibilities]
                 self.or_logic.append([right_req])
             else:
                 self.complete_at = other.complete_at
-                self.possibilities = other.possibilities
+                self.possibilities = [sub_req.copy() for sub_req in other.possibilities]
 
     def is_empty(self) -> bool:
         return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
@@ -114,15 +114,20 @@ class AccessRequirements:
             old_or_logic = self.or_logic
 
             def remove_redundant(sub_reqs: "AccessRequirements"):
-                sub_reqs.letters = {l: v for l, v in sub_reqs.letters.items() if self.letters.get(l, 0) < v}
+                new_reqs = sub_reqs.copy()
+                new_reqs.letters = {l: v for l, v in new_reqs.letters.items() if self.letters.get(l, 0) < v}
+                if new_reqs != sub_reqs:
+                    return new_reqs
+                else:
+                    return sub_reqs
 
             self.or_logic = []
             for disjunction in old_or_logic:
                 new_disjunction = []
                 for ssr in disjunction:
-                    remove_redundant(ssr)
-                    if not ssr.is_empty():
-                        new_disjunction.append(ssr)
+                    new_ssr = remove_redundant(ssr)
+                    if not new_ssr.is_empty():
+                        new_disjunction.append(new_ssr)
                     else:
                         new_disjunction.clear()
                         break
@@ -139,6 +144,29 @@ class AccessRequirements:
         if resimplify:
             self.simplify()
 
+    def get_referenced_rooms(self):
+        result = set(self.rooms)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                result = result.union(sub_req.get_referenced_rooms())
+
+        for sub_req in self.possibilities:
+            result = result.union(sub_req.get_referenced_rooms())
+
+        return result
+
+    def remove_room(self, room: str):
+        if room in self.rooms:
+            self.rooms.remove(room)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                sub_req.remove_room(room)
+
+        for sub_req in self.possibilities:
+            sub_req.remove_room(room)
+
     def __repr__(self):
         parts = []
         if len(self.items) > 0:
@@ -157,7 +185,7 @@ class AccessRequirements:
             parts.append(f"complete_at={self.complete_at}")
         if len(self.possibilities) > 0:
             parts.append(f"possibilities={self.possibilities}")
-        return f"AccessRequirements({", ".join(parts)})"
+        return "AccessRequirements(" + ", ".join(parts) + ")"
 
 
 class PlayerLocation(NamedTuple):
@@ -174,6 +202,8 @@ class LetterBehavior(IntEnum):
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
+    shuffled_maps: set[int]
+
     locations_by_room: dict[int, list[PlayerLocation]]
     event_loc_item_by_room: dict[int, dict[str, str]]
 
@@ -186,6 +216,7 @@ class Lingo2PlayerLogic:
     real_items: list[str]
 
     double_letter_amount: dict[str, int]
+    goal_room_id: int
 
     def __init__(self, world: "Lingo2World"):
         self.world = world
@@ -198,18 +229,54 @@ class Lingo2PlayerLogic:
         self.real_items = list()
         self.double_letter_amount = dict()
 
+        def should_shuffle_map(game_map) -> bool:
+            if game_map.type == data_pb2.MapType.NORMAL_MAP:
+                return True
+            elif game_map.type == data_pb2.MapType.ICARUS:
+                return bool(world.options.enable_icarus)
+            elif game_map.type == data_pb2.MapType.GIFT_MAP:
+                if game_map.name == "the_advanced":
+                    return "The Advanced" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_charismatic":
+                    return "The Charismatic" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_crystalline":
+                    return "The Crystalline" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_fuzzy":
+                    return "The Fuzzy" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_stellar":
+                    return "The Stellar" in world.options.enable_gift_maps.value
+
+            return False
+
+        self.shuffled_maps = set(game_map.id for game_map in world.static_logic.objects.maps
+                                 if should_shuffle_map(game_map))
+
+        maximum_masteries = 13 + len(world.options.enable_gift_maps.value)
+        if world.options.enable_icarus:
+            maximum_masteries += 1
+
+        if world.options.masteries_requirement > maximum_masteries:
+            world.options.masteries_requirement.value = maximum_masteries
+
+        if "The Fuzzy" in world.options.enable_gift_maps.value:
+            self.real_items.append("Numbers")
+
         if self.world.options.shuffle_doors:
             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:
+                        continue
+
                     self.item_by_door[progressive.doors[i]] = (progressive.name, i + 1)
                     self.real_items.append(progressive.name)
 
         for door_group in world.static_logic.objects.door_groups:
             if door_group.type == data_pb2.DoorGroupType.CONNECTOR:
-                if not self.world.options.shuffle_doors:
+                if not self.world.options.shuffle_doors or self.world.options.shuffle_worldports:
                     continue
             elif door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR:
-                if not self.world.options.shuffle_control_center_colors:
+                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:
@@ -217,14 +284,21 @@ class Lingo2PlayerLogic:
             else:
                 continue
 
-            for door in door_group.doors:
-                self.item_by_door[door] = (door_group.name, 1)
+            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]
 
-            self.real_items.append(door_group.name)
+            if len(shuffleable_doors) > 0:
+                for door in shuffleable_doors:
+                    self.item_by_door[door] = (door_group.name, 1)
+
+                self.real_items.append(door_group.name)
 
         # 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:
+                continue
+
             if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
                 continue
 
@@ -253,29 +327,40 @@ class Lingo2PlayerLogic:
                 if door_group.type != data_pb2.DoorGroupType.CYAN_DOORS:
                     continue
 
-                for door in door_group.doors:
-                    if not door in self.item_by_door:
+                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 len(shuffleable_doors) > 0:
+                    for door in shuffleable_doors:
                         self.item_by_door[door] = (door_group.name, 1)
 
-                self.real_items.append(door_group.name)
+                    self.real_items.append(door_group.name)
 
         for door in world.static_logic.objects.doors:
+            if door.map_id not in self.shuffled_maps:
+                continue
+
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
                 self.locations_by_room.setdefault(door.room_id, []).append(PlayerLocation(door.ap_id,
                                                                                           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:
+                continue
+
             self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
                                                                                         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())
 
@@ -283,30 +368,42 @@ 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:
+                continue
+
             self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
                                                                                          AccessRequirements()))
 
+            if world.options.masteries_requirement > 0:
+                event_name = f"{world.static_logic.get_room_object_map_name(mastery)} - Mastery (Collected)"
+                self.event_loc_item_by_room.setdefault(mastery.room_id, {})[event_name] = "Mastery"
+
         for ending in world.static_logic.objects.endings:
-            # Don't ever create a location for White Ending. Don't even make an event for it if it's not the victory
-            # condition, since it is necessarily going to be in the postgame.
-            if ending.name == "WHITE":
-                if self.world.options.victory_condition != VictoryCondition.option_white_ending:
-                    continue
-            else:
+            if world.static_logic.get_room_object_map_id(ending) not in self.shuffled_maps:
+                continue
+
+            # Don't create a location for your selected ending. Also don't create a location for White Ending if it's
+            # necessarily in the postgame, i.e. it requires all 12 other endings.
+            if world.options.victory_condition.current_key.removesuffix("_ending").upper() != ending.name\
+                    and (ending.name != "WHITE" or world.options.endings_requirement < 12):
                 self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
                                                                                             AccessRequirements()))
 
-            event_name = f"{ending.name.capitalize()} Ending (Achieved)"
-            item_name = event_name
-
             if world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
-                item_name = "Victory"
+                event_name = f"{ending.name.capitalize()} Ending (Goal)"
+                self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Victory"
+                self.goal_room_id = ending.room_id
 
-            self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = item_name
+            if ending.name != "WHITE":
+                event_name = f"{ending.name.capitalize()} Ending (Achieved)"
+                self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Ending"
 
         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:
+                        continue
+
                     reqs = AccessRequirements()
 
                     if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED:
@@ -414,7 +511,6 @@ class Lingo2PlayerLogic:
                 reqs.possibilities.append(panel_reqs)
 
         if door.HasField("control_center_color"):
-            # TODO: Logic for ensuring two CC states aren't needed at once.
             reqs.rooms.add("Control Center - Main Area")
             self.add_solution_reqs(reqs, door.control_center_color)
 
@@ -440,13 +536,12 @@ class Lingo2PlayerLogic:
         for room in door.rooms:
             reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
 
-        for ending_id in door.endings:
-            ending = self.world.static_logic.objects.endings[ending_id]
+        if door.white_ending:
+            if self.world.options.endings_requirement > 0:
+                reqs.progressives["Ending"] = self.world.options.endings_requirement.value
 
-            if self.world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
-                reqs.items.add("Victory")
-            else:
-                reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+            if self.world.options.masteries_requirement > 0:
+                reqs.progressives["Mastery"] = self.world.options.masteries_requirement.value
 
         for sub_door_id in door.doors:
             sub_reqs = self.get_door_open_reqs(sub_door_id)
@@ -508,3 +603,6 @@ class Lingo2PlayerLogic:
 
             if needed > 0:
                 reqs.letters[l] = max(reqs.letters.get(l, 0), needed)
+
+        if any(l.isnumeric() for l in solution):
+            reqs.items.add("Numbers")