Stardew Valley: Replace current naive entrance rando with GER (#4624)

worlds/stardew_valley/test/regions/TestEntranceRandomization.py

@@ -0,0 +1,167 @@
+from collections import deque
+from collections.abc import Collection
+from unittest.mock import patch, Mock
+
+from BaseClasses import get_seed, MultiWorld, Entrance
+from ..assertion import WorldAssertMixin
+from ..bases import SVTestCase, solo_multiworld
+from ... import options
+from ...mods.mod_data import ModNames
+from ...options import EntranceRandomization, ExcludeGingerIsland, SkillProgression
+from ...options.options import all_mods
+from ...regions.entrance_rando import create_entrance_rando_target, prepare_mod_data, connect_regions
+from ...regions.model import RegionData, ConnectionData, RandomizationFlag
+from ...strings.entrance_names import Entrance as EntranceName
+from ...strings.region_names import Region as RegionName
+
+
+class TestEntranceRando(SVTestCase):
+
+    def test_given_connection_matching_randomization_when_connect_regions_then_make_connection_entrance_rando_target(self):
+        region_data_by_name = {
+            "Region1": RegionData("Region1", ("randomized_connection", "not_randomized")),
+            "Region2": RegionData("Region2"),
+            "Region3": RegionData("Region3"),
+        }
+        connection_data_by_name = {
+            "randomized_connection": ConnectionData("randomized_connection", "Region2", flag=RandomizationFlag.PELICAN_TOWN),
+            "not_randomized": ConnectionData("not_randomized", "Region2", flag=RandomizationFlag.BUILDINGS),
+        }
+        regions_by_name = {
+            "Region1": Mock(),
+            "Region2": Mock(),
+            "Region3": Mock(),
+        }
+        player_randomization_flag = RandomizationFlag.BIT_PELICAN_TOWN
+
+        with patch("worlds.stardew_valley.regions.entrance_rando.create_entrance_rando_target") as mock_create_entrance_rando_target:
+            connect_regions(region_data_by_name, connection_data_by_name, regions_by_name, player_randomization_flag)
+
+            expected_origin, expected_destination = regions_by_name["Region1"], regions_by_name["Region2"]
+            expected_connection = connection_data_by_name["randomized_connection"]
+            mock_create_entrance_rando_target.assert_called_once_with(expected_origin, expected_destination, expected_connection)
+
+    def test_when_create_entrance_rando_target_then_create_exit_and_er_target(self):
+        origin = Mock()
+        destination = Mock()
+        connection_data = ConnectionData("origin to destination", "destination")
+
+        create_entrance_rando_target(origin, destination, connection_data)
+
+        origin.create_exit.assert_called_once_with("origin to destination")
+        destination.create_er_target.assert_called_once_with("destination to origin")
+
+    def test_when_prepare_mod_data_then_swapped_connections_contains_both_directions(self):
+        placements = Mock(pairings=[("A to B", "C to A"), ("C to D", "A to C")])
+
+        swapped_connections = prepare_mod_data(placements)
+
+        self.assertEqual({"A to B": "A to C", "C to A": "B to A", "C to D": "C to A", "A to C": "D to C"}, swapped_connections)
+
+
+class TestEntranceRandoCreatesValidWorlds(WorldAssertMixin, SVTestCase):
+
+    # The following tests validate that ER still generates winnable and logically-sane games with given mods.
+    # Mods that do not interact with entrances are skipped
+    # Not all ER settings are tested, because 'buildings' is, essentially, a superset of all others
+    def test_ginger_island_excluded_buildings(self):
+        world_options = {
+            options.EntranceRandomization: options.EntranceRandomization.option_buildings,
+            options.ExcludeGingerIsland: options.ExcludeGingerIsland.option_true
+        }
+        with solo_multiworld(world_options) as (multi_world, _):
+            self.assert_basic_checks(multi_world)
+
+    def test_deepwoods_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.deepwoods, options.EntranceRandomization.option_buildings)
+
+    def test_juna_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.juna, options.EntranceRandomization.option_buildings)
+
+    def test_jasper_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.jasper, options.EntranceRandomization.option_buildings)
+
+    def test_alec_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.alec, options.EntranceRandomization.option_buildings)
+
+    def test_yoba_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.yoba, options.EntranceRandomization.option_buildings)
+
+    def test_eugene_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.eugene, options.EntranceRandomization.option_buildings)
+
+    def test_ayeisha_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.ayeisha, options.EntranceRandomization.option_buildings)
+
+    def test_riley_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.riley, options.EntranceRandomization.option_buildings)
+
+    def test_sve_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.sve, options.EntranceRandomization.option_buildings)
+
+    def test_alecto_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.alecto, options.EntranceRandomization.option_buildings)
+
+    def test_lacey_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.lacey, options.EntranceRandomization.option_buildings)
+
+    def test_boarding_house_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(ModNames.boarding_house, options.EntranceRandomization.option_buildings)
+
+    def test_all_mods_entrance_randomization_buildings(self):
+        self.perform_basic_checks_on_mod_with_er(all_mods, options.EntranceRandomization.option_buildings)
+
+    def perform_basic_checks_on_mod_with_er(self, mods: str | set[str], er_option: int) -> None:
+        if isinstance(mods, str):
+            mods = {mods}
+        world_options = {
+            options.EntranceRandomization: er_option,
+            options.Mods: frozenset(mods),
+            options.ExcludeGingerIsland: options.ExcludeGingerIsland.option_false
+        }
+        with solo_multiworld(world_options) as (multi_world, _):
+            self.assert_basic_checks(multi_world)
+
+
+# GER should have this covered, but it's good to have a backup
+class TestGingerIslandEntranceRando(SVTestCase):
+    def test_cannot_put_island_access_on_island(self):
+        test_options = {
+            options.EntranceRandomization: EntranceRandomization.option_buildings,
+            options.ExcludeGingerIsland: ExcludeGingerIsland.option_false,
+            options.SkillProgression: SkillProgression.option_progressive_with_masteries,
+        }
+
+        blocked_entrances = {EntranceName.use_island_obelisk, EntranceName.boat_to_ginger_island}
+        required_regions = {RegionName.wizard_tower, RegionName.boat_tunnel}
+
+        for i in range(0, 10 if self.skip_long_tests else 1000):
+            seed = get_seed()
+            with self.solo_world_sub_test(f"Seed: {seed}", world_options=test_options, world_caching=False, seed=seed) as (multiworld, world):
+                self.assert_can_reach_any_region_before_blockers(required_regions, blocked_entrances, multiworld)
+
+    def assert_can_reach_any_region_before_blockers(self, required_regions: Collection[str], blocked_entrances: Collection[str], multiworld: MultiWorld):
+        explored_regions = explore_regions_up_to_blockers(blocked_entrances, multiworld)
+        self.assertTrue(any(region in explored_regions for region in required_regions))
+
+
+def explore_regions_up_to_blockers(blocked_entrances: Collection[str], multiworld: MultiWorld) -> set[str]:
+    explored_regions: set[str] = set()
+    regions_by_name = multiworld.regions.region_cache[1]
+    regions_to_explore = deque([regions_by_name["Menu"]])
+
+    while regions_to_explore:
+        region = regions_to_explore.pop()
+
+        if region.name in explored_regions:
+            continue
+
+        explored_regions.add(region.name)
+
+        for exit_ in region.exits:
+            exit_: Entrance
+            if exit_.name in blocked_entrances:
+                continue
+            regions_to_explore.append(exit_.connected_region)
+
+    return explored_regions