- Missing Bundle and changes for recursive region access update

BaseClasses.py

@@ -638,36 +638,37 @@ def __init__(self, parent: MultiWorld):
                 self.collect(item, True)
 
     def update_reachable_regions(self, player: int):
+        new_connection: bool = True
         self.stale[player] = False
-        rrp = self.reachable_regions[player]
-        bc = self.blocked_connections[player]
+        reachable_regions = self.reachable_regions[player]
+        blocked_connections = self.blocked_connections[player]
         queue = deque(self.blocked_connections[player])
-        start = self.multiworld.get_region('Menu', player)
+        start = self.multiworld.get_region("Menu", player)
 
         # init on first call - this can't be done on construction since the regions don't exist yet
-        if start not in rrp:
-            rrp.add(start)
-            bc.update(start.exits)
+        if start not in reachable_regions:
+            reachable_regions.add(start)
+            blocked_connections.update(start.exits)
             queue.extend(start.exits)
 
         # run BFS on all connections, and keep track of those blocked by missing items
-        while queue:
-            connection = queue.popleft()
-            new_region = connection.connected_region
-            if new_region in rrp:
-                bc.remove(connection)
-            elif connection.can_reach(self):
-                assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
-                rrp.add(new_region)
-                bc.remove(connection)
-                bc.update(new_region.exits)
-                queue.extend(new_region.exits)
-                self.path[new_region] = (new_region.name, self.path.get(connection, None))
-
-                # Retry connections if the new region can unblock them
-                for new_entrance in self.multiworld.indirect_connections.get(new_region, set()):
-                    if new_entrance in bc and new_entrance not in queue:
-                        queue.append(new_entrance)
+        while new_connection:
+            new_connection = False
+            while queue:
+                connection = queue.popleft()
+                new_region = connection.connected_region
+                if new_region in reachable_regions:
+                    blocked_connections.remove(connection)
+                elif connection.can_reach(self):
+                    assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
+                    reachable_regions.add(new_region)
+                    blocked_connections.remove(connection)
+                    blocked_connections.update(new_region.exits)
+                    queue.extend(new_region.exits)
+                    self.path[new_region] = (new_region.name, self.path.get(connection, None))
+                    new_connection = True
+            # sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
+            queue.extend(blocked_connections)
 
     def copy(self) -> CollectionState:
         ret = CollectionState(self.multiworld)

worlds/stardew_valley/__init__.py

@@ -17,7 +17,8 @@
 from .rules import set_rules
 from worlds.generic.Rules import set_rule
 from .stardew_rule import True_, StardewRule
-from .strings.goal_names import Goal as GoalName
+from .strings.ap_names.event_names import Event
+from .strings.goal_names import Goal
 
 client_version = 0
 
@@ -136,6 +137,7 @@ def create_items(self):
 
         self.setup_early_items()
         self.setup_month_events()
+        self.setup_construction_events()
         self.setup_victory()
 
     def precollect_starting_season(self) -> Optional[StardewItem]:
@@ -169,60 +171,64 @@ def setup_early_items(self):
 
     def setup_month_events(self):
         for i in range(0, MAX_MONTHS):
-            month_end = LocationData(None, "Stardew Valley", f"Month End {i + 1}")
+            month_end = LocationData(None, "Stardew Valley", f"{Event.month_end} {i + 1}")
             if i == 0:
-                self.create_event_location(month_end, True_(), "Month End")
+                self.create_event_location(month_end, True_(), Event.month_end)
                 continue
 
-            self.create_event_location(month_end, self.logic.received("Month End", i).simplify(), "Month End")
+            self.create_event_location(month_end, self.logic.received(Event.month_end, i).simplify(), Event.month_end)
+
+    def setup_construction_events(self):
+        can_construct_buildings = LocationData(None, "Carpenter Shop", Event.can_construct_buildings)
+        self.create_event_location(can_construct_buildings, True_(), Event.can_construct_buildings)
 
     def setup_victory(self):
         if self.options.goal == Goal.option_community_center:
             self.create_event_location(location_table[GoalName.community_center],
                                        self.logic.can_complete_community_center().simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_grandpa_evaluation:
             self.create_event_location(location_table[GoalName.grandpa_evaluation],
                                        self.logic.can_finish_grandpa_evaluation().simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_bottom_of_the_mines:
             self.create_event_location(location_table[GoalName.bottom_of_the_mines],
                                        self.logic.mine.can_mine_to_floor(120).simplify(),
-                                       item="Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_cryptic_note:
             self.create_event_location(location_table[GoalName.cryptic_note],
                                        self.logic.can_complete_quest("Cryptic Note").simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_master_angler:
             self.create_event_location(location_table[GoalName.master_angler],
                                        self.logic.can_catch_every_fish().simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_complete_collection:
             self.create_event_location(location_table[GoalName.complete_museum],
                                        self.logic.museum.can_complete_museum().simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_full_house:
             self.create_event_location(location_table[GoalName.full_house],
                                        (self.logic.relationship.has_children(2) & self.logic.relationship.can_reproduce()).simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options.goal == Goal.option_greatest_walnut_hunter:
             self.create_event_location(location_table[GoalName.greatest_walnut_hunter],
                                        self.logic.has_walnut(130).simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options[options.Goal] == options.Goal.option_protector_of_the_valley:
             self.create_event_location(location_table[Goal.protector_of_the_valley],
                                        self.logic.can_complete_all_monster_slaying_goals().simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options[options.Goal] == options.Goal.option_full_shipment:
             self.create_event_location(location_table[Goal.full_shipment],
                                        self.logic.can_ship_everything().simplify(),
-                                       "Victory")
+                                       Event.victory)
         elif self.options[options.Goal] == options.Goal.option_perfection:
             self.create_event_location(location_table[Goal.perfection],
                                        self.logic.has_everything(self.all_progression_items).simplify(),
-                                       "Victory")
+                                       Event.victory)
 
-        self.multiworld.completion_condition[self.player] = lambda state: state.has("Victory", self.player)
+        self.multiworld.completion_condition[self.player] = lambda state: state.has(Event.victory, self.player)
 
     def create_item(self, item: Union[str, ItemData], override_classification: ItemClassification = None) -> StardewItem:
         if isinstance(item, str):

worlds/stardew_valley/bundles.py

@@ -37,7 +37,7 @@
     "Bulletin Board/33": "Enchanter's/O 336 5/725 1 0 348 1 0 446 1 0 637 1 0/1",
     "Bulletin Board/34": "Dye/BO 25 1/420 1 0 397 1 0 421 1 0 444 1 0 62 1 0 266 1 0/6",
     "Bulletin Board/35": "Fodder/BO 104 1/262 10 0 178 10 0 613 3 0/3",
-    # "Abandoned Joja Mart/36": "The Missing//348 1 1 807 1 0 74 1 0 454 5 2 795 1 2 445 1 0/1/5"
+    "Abandoned Joja Mart/36": "The Missing//348 1 1 807 1 0 74 1 0 454 5 2 795 1 2 445 1 0/1/5"
 }
 
 
@@ -204,6 +204,7 @@ def shuffle_bundles_thematically(random: Random, bundles: Dict[str, Bundle]):
     shuffle_fish_tank_thematically(random, bundles)
     shuffle_boiler_room_thematically(random, bundles)
     shuffle_bulletin_board_thematically(random, bundles)
+    shuffle_abandoned_jojamart_thematically(random, bundles)
 
 
 def shuffle_crafts_room_bundle_thematically(random: Random, bundles: Dict[str, Bundle]):
@@ -247,6 +248,10 @@ def shuffle_bulletin_board_thematically(random: Random, bundles: Dict[str, Bundl
     bundles["Enchanter's Bundle"].randomize_requirements(random, enchanter_items)
 
 
+def shuffle_abandoned_jojamart_thematically(random: Random, bundles: Dict[str, Bundle]):
+    bundles["The Missing Bundle"].randomize_requirements(random, missing_bundle_items)
+
+
 def shuffle_vault_amongst_themselves(random: Random, bundles: Dict[str, Bundle]):
     bundles["2,500g Bundle"].randomize_requirements(random, vault_bundle_items)
     bundles["5,000g Bundle"].randomize_requirements(random, vault_bundle_items)