The Witness: Add some unit tests

worlds/witness/__init__.py

@@ -185,21 +185,22 @@ def create_regions(self) -> None:
 
         self.items_placed_early.append("Puzzle Skip")
 
-        # Pick an early item to place on the tutorial gate.
-        early_items = [
-            item for item in self.player_items.get_early_items() if item in self.player_items.get_mandatory_items()
-        ]
-        if early_items:
-            random_early_item = self.random.choice(early_items)
-            if self.options.puzzle_randomization == "sigma_expert":
-                # In Expert, only tag the item as early, rather than forcing it onto the gate.
-                self.multiworld.local_early_items[self.player][random_early_item] = 1
-            else:
-                # Force the item onto the tutorial gate check and remove it from our random pool.
-                gate_item = self.create_item(random_early_item)
-                self.get_location("Tutorial Gate Open").place_locked_item(gate_item)
-                self.own_itempool.append(gate_item)
-                self.items_placed_early.append(random_early_item)
+        if self.options.early_symbol_item:
+            # Pick an early item to place on the tutorial gate.
+            early_items = [
+                item for item in self.player_items.get_early_items() if item in self.player_items.get_mandatory_items()
+            ]
+            if early_items:
+                random_early_item = self.random.choice(early_items)
+                if self.options.puzzle_randomization == "sigma_expert":
+                    # In Expert, only tag the item as early, rather than forcing it onto the gate.
+                    self.multiworld.local_early_items[self.player][random_early_item] = 1
+                else:
+                    # Force the item onto the tutorial gate check and remove it from our random pool.
+                    gate_item = self.create_item(random_early_item)
+                    self.get_location("Tutorial Gate Open").place_locked_item(gate_item)
+                    self.own_itempool.append(gate_item)
+                    self.items_placed_early.append(random_early_item)
 
         # There are some really restrictive settings in The Witness.
         # They are rarely played, but when they are, we add some extra sphere 1 locations.

worlds/witness/options.py

@@ -2,7 +2,7 @@
 
 from schema import And, Schema
 
-from Options import Choice, DefaultOnToggle, OptionDict, OptionGroup, PerGameCommonOptions, Range, Toggle
+from Options import Choice, DefaultOnToggle, OptionDict, OptionGroup, PerGameCommonOptions, Range, Toggle, Visibility
 
 from .data import static_logic as static_witness_logic
 from .data.item_definition_classes import ItemCategory, WeightedItemDefinition
@@ -35,6 +35,14 @@ class EarlyCaves(Choice):
     alias_on = 2
 
 
+class EarlySymbolItem(DefaultOnToggle):
+    """
+    Put a random helpful symbol item on an early check, specifically Tutorial Gate Open if it is available early.
+    """
+
+    visibility = Visibility.none
+
+
 class ShuffleSymbols(DefaultOnToggle):
     """
     If on, you will need to unlock puzzle symbols as items to be able to solve the panels that contain those symbols.
@@ -325,6 +333,7 @@ class TheWitnessOptions(PerGameCommonOptions):
     mountain_lasers: MountainLasers
     challenge_lasers: ChallengeLasers
     early_caves: EarlyCaves
+    early_symbol_item: EarlySymbolItem
     elevators_come_to_you: ElevatorsComeToYou
     trap_percentage: TrapPercentage
     trap_weights: TrapWeights

worlds/witness/test/__init__.py

@@ -0,0 +1,149 @@
+from test.bases import WorldTestBase
+from test.general import gen_steps, setup_multiworld
+from test.multiworld.test_multiworlds import MultiworldTestBase
+from typing import Any, ClassVar, Dict, Iterable, List, Mapping, Union, cast
+
+from BaseClasses import CollectionState, Entrance, Item, Location, Region
+
+from .. import WitnessWorld
+
+
+class WitnessTestBase(WorldTestBase):
+    game = "The Witness"
+    player: ClassVar[int] = 1
+
+    world: WitnessWorld
+
+    def can_beat_game_with_items(self, items: Iterable[Item]) -> bool:
+        """
+        Check that the items listed are enough to beat the game.
+        """
+
+        state = CollectionState(self.multiworld)
+        for item in items:
+            state.collect(item)
+        return state.multiworld.can_beat_game(state)
+
+    def assert_dependency_on_event_item(self, spot: Union[Location, Region, Entrance], item_name: str) -> None:
+        """
+        WorldTestBase.assertAccessDependency, but modified & simplified to work with event items
+        """
+        event_items = [item for item in self.multiworld.get_items() if item.name == item_name]
+        self.assertTrue(event_items, f"Event item {item_name} does not exist.")
+
+        event_locations = [cast(Location, event_item.location) for event_item in event_items]
+
+        # Checking for an access dependency on an event item requires a bit of extra work,
+        # as state.remove forces a sweep, which will pick up the event item again right after we tried to remove it.
+        # So, we temporarily set the access rules of the event locations to be impossible.
+        original_rules = {event_location.name: event_location.access_rule for event_location in event_locations}
+        for event_location in event_locations:
+            event_location.access_rule = lambda _: False
+
+        # We can't use self.assertAccessDependency here, it doesn't work for event items. (As of 2024-06-30)
+        test_state = self.multiworld.get_all_state(False)
+
+        self.assertFalse(spot.can_reach(test_state), f"{spot.name} is reachable without {item_name}")
+
+        test_state.collect(event_items[0])
+
+        self.assertTrue(spot.can_reach(test_state), f"{spot.name} is not reachable despite having {item_name}")
+
+        # Restore original access rules.
+        for event_location in event_locations:
+            event_location.access_rule = original_rules[event_location.name]
+
+    def assert_location_exists(self, location_name: str, strict_check: bool = True) -> None:
+        """
+        Assert that a location exists in this world.
+        If strict_check, also make sure that this (non-event) location COULD exist.
+        """
+
+        if strict_check:
+            self.assertIn(location_name, self.world.location_name_to_id, f"Location {location_name} can never exist")
+
+        try:
+            self.world.get_location(location_name)
+        except KeyError:
+            self.fail(f"Location {location_name} does not exist.")
+
+    def assert_location_does_not_exist(self, location_name: str, strict_check: bool = True) -> None:
+        """
+        Assert that a location exists in this world.
+        If strict_check, be explicit about whether the location could exist in the first place.
+        """
+
+        if strict_check:
+            self.assertIn(location_name, self.world.location_name_to_id, f"Location {location_name} can never exist")
+
+        self.assertRaises(
+            KeyError,
+            lambda _: self.world.get_location(location_name),
+            f"Location {location_name} exists, but is not supposed to.",
+        )
+
+    def assert_can_beat_with_minimally(self, required_item_counts: Mapping[str, int]) -> None:
+        """
+        Assert that the specified mapping of items is enough to beat the game,
+        and that having one less of any item would result in the game being unbeatable.
+        """
+        # Find the actual items
+        found_items = [item for item in self.multiworld.get_items() if item.name in required_item_counts]
+        actual_items: Dict[str, List[Item]] = {item_name: [] for item_name in required_item_counts}
+        for item in found_items:
+            if len(actual_items[item.name]) < required_item_counts[item.name]:
+                actual_items[item.name].append(item)
+
+        # Assert that enough items exist in the item pool to satisfy the specified required counts
+        for item_name, item_objects in actual_items.items():
+            self.assertEqual(
+                len(item_objects),
+                required_item_counts[item_name],
+                f"Couldn't find {required_item_counts[item_name]} copies of item {item_name} available in the pool, "
+                f"only found {len(item_objects)}",
+            )
+
+        # assert that multiworld is beatable with the items specified
+        self.assertTrue(
+            self.can_beat_game_with_items(item for items in actual_items.values() for item in items),
+            f"Could not beat game with items: {required_item_counts}",
+        )
+
+        # assert that one less copy of any item would result in the multiworld being unbeatable
+        for item_name, item_objects in actual_items.items():
+            with self.subTest(f"Verify cannot beat game with one less copy of {item_name}"):
+                removed_item = item_objects.pop()
+                self.assertFalse(
+                    self.can_beat_game_with_items(item for items in actual_items.values() for item in items),
+                    f"Game was beatable despite having {len(item_objects)} copies of {item_name} "
+                    f"instead of the specified {required_item_counts[item_name]}",
+                )
+                item_objects.append(removed_item)
+
+
+class WitnessMultiworldTestBase(MultiworldTestBase):
+    options_per_world: List[Dict[str, Any]]
+    common_options: Dict[str, Any] = {}
+
+    def setUp(self) -> None:
+        self.multiworld = setup_multiworld([WitnessWorld] * len(self.options_per_world), ())
+
+        for world, options in zip(self.multiworld.worlds.values(), self.options_per_world):
+            for option_name, option_value in {**self.common_options, **options}.items():
+                option = getattr(world.options, option_name)
+                self.assertIsNotNone(option)
+
+                option.value = option.from_any(option_value).value
+
+        self.assertSteps(gen_steps)
+
+    def collect_by_name(self, item_names: Union[str, Iterable[str]], player: int) -> List[Item]:
+        items = self.get_items_by_name(item_names, player)
+        for item in items:
+            self.multiworld.state.collect(item)
+        return items
+
+    def get_items_by_name(self, item_names: Union[str, Iterable[str]], player: int) -> List[Item]:
+        if isinstance(item_names, str):
+            item_names = (item_names,)
+        return [item for item in self.multiworld.itempool if item.name in item_names and item.player == player]

worlds/witness/test/test_auto_elevators.py

@@ -0,0 +1,55 @@
+from ..test import WitnessMultiworldTestBase, WitnessTestBase
+
+
+class TestElevatorsComeToYou(WitnessTestBase):
+    options = {
+        "elevators_come_to_you": True,
+        "shuffle_doors": "mixed",
+        "shuffle_symbols": False,
+    }
+
+    def test_bunker_laser(self) -> None:
+        self.collect_by_name("Bunker Drop-Down Door Controls (Panel)")
+
+        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", self.player))
+
+        self.collect_by_name("Bunker Elevator Control (Panel)")
+
+        self.assertTrue(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", self.player))
+        self.assertFalse(self.multiworld.state.can_reach("Bunker UV Room 2", "Location", self.player))
+
+        self.collect_by_name("Bunker Elevator Room Entry (Door)")
+
+        self.assertTrue(self.multiworld.state.can_reach("Bunker UV Room 2", "Location", self.player))
+
+
+class TestElevatorsComeToYouBleed(WitnessMultiworldTestBase):
+    options_per_world = [
+        {
+            "elevators_come_to_you": False,
+        },
+        {
+            "elevators_come_to_you": True,
+        },
+        {
+            "elevators_come_to_you": False,
+        },
+    ]
+
+    common_options = {
+        "shuffle_symbols": False,
+        "shuffle_doors": "panels",
+    }
+
+    def test_correct_access_per_player(self) -> None:
+        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 1))
+        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 2))
+        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 3))
+
+        self.collect_by_name(["Bunker Elevator Control (Panel)"], 1)
+        self.collect_by_name(["Bunker Elevator Control (Panel)"], 2)
+        self.collect_by_name(["Bunker Elevator Control (Panel)"], 3)
+
+        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 1))
+        self.assertTrue(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 2))
+        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 3))

worlds/witness/test/test_disable_non_randomized.py

@@ -0,0 +1,36 @@
+from ..rules import _has_lasers
+from ..test import WitnessTestBase
+
+
+class TestDisableNonRandomized(WitnessTestBase):
+    options = {
+        "disable_non_randomized_puzzles": True,
+        "shuffle_doors": "panels",
+        "early_symbol_item": False,
+    }
+
+    def test_unrandomized_locations_do_not_exist(self) -> None:
+        self.assert_location_does_not_exist("Orchard Apple Tree 5")
+
+    def test_locations_got_disabled_and_alternate_activation_triggers_work(self) -> None:
+        """
+        Test that specific Discarded Panels give extra lasers.
+        """
+
+        with self.subTest("Test that unrandomized locations are disabled."):
+            self.assert_location_does_not_exist("Orchard Apple Tree 5")
+
+        with self.subTest("Test that alternate activation trigger events exist."):
+            self.assert_dependency_on_event_item(
+                self.world.get_entrance("Town Tower After Third Door to Town Tower Top"),
+                "Town Tower 4th Door Opens",
+            )
+
+        with self.subTest("Test that alternate activation triggers award lasers."):
+            self.assertFalse(_has_lasers(1, self.world, False)(self.multiworld.state))
+
+            self.collect_by_name("Triangles")
+
+            # Alternate triggers yield Bunker Laser (Mountainside Discard) and Monastery Laser (Desert Discard)
+            self.assertTrue(_has_lasers(2, self.world, False)(self.multiworld.state))
+            self.assertFalse(_has_lasers(3, self.world, False)(self.multiworld.state))

worlds/witness/test/test_door_shuffle.py

@@ -0,0 +1,20 @@
+from ..test import WitnessTestBase
+
+
+class TestIndividualDoors(WitnessTestBase):
+    options = {
+        "shuffle_doors": "doors",
+        "door_groupings": "off",
+    }
+
+    def test_swamp_laser_shortcut(self) -> None:
+        self.assertTrue(self.get_items_by_name("Swamp Laser Shortcut (Door)"))
+
+        self.assertAccessDependency(
+            ["Swamp Laser Panel"],
+            [
+                ["Swamp Laser Shortcut (Door)"],
+                ["Swamp Red Underwater Exit (Door)"],
+            ],
+            only_check_listed=True,
+        )

worlds/witness/test/test_ep_shuffle.py

@@ -0,0 +1,54 @@
+from ..test import WitnessTestBase
+
+
+class TestIndividualEPs(WitnessTestBase):
+    options = {
+        "shuffle_EPs": "individual",
+        "EP_difficulty": "normal",
+        "obelisk_keys": True,
+        "disable_non_randomized_puzzles": True,
+        "shuffle_postgame": False,
+        "victory_condition": "mountain_box_short",
+        "early_caves": "off",
+    }
+
+    def test_correct_eps_exist_and_are_locked(self) -> None:
+        """
+        Test that EP locations exist in shuffle_EPs, but only the ones that actually should (based on options)
+        """
+
+        # Test Tutorial First Hallways EP as a proxy for "EPs exist at all"
+        # Don't wrap in a subtest - If this fails, there is no point.
+        self.assert_location_exists("Tutorial First Hallway EP")
+
+        with self.subTest("Test that disable_non_randomized disables Monastery Garden Left EP"):
+            self.assert_location_does_not_exist("Monastery Garden Left EP")
+
+        with self.subTest("Test that shuffle_postgame being off disables postgame EPs."):
+            self.assert_location_does_not_exist("Caves Skylight EP")
+
+        with self.subTest("Test that ep_difficulty being set to normal excludes tedious EPs."):
+            self.assert_location_does_not_exist("Shipwreck Couch EP")
+
+        with self.subTest("Test that EPs are being locked by Obelisk Keys."):
+            self.assertAccessDependency(["Desert Sand Snake EP"], [["Desert Obelisk Key"]], True)
+
+
+class TestObeliskSides(WitnessTestBase):
+    options = {
+        "shuffle_EPs": "obelisk_sides",
+        "EP_difficulty": "eclipse",
+        "shuffle_vault_boxes": True,
+        "shuffle_postgame": True,
+    }
+
+    def test_eclipse_required_for_town_side_6(self) -> None:
+        """
+        Test that Obelisk Sides require the appropriate event items from the individual EPs.
+        Specifically, assert that Town Obelisk Side 6 needs Theater Eclipse EP.
+        This doubles as a test for Theater Eclipse EP existing with the right options.
+        """
+
+        self.assert_dependency_on_event_item(
+            self.world.get_location("Town Obelisk Side 6"), "Town Obelisk Side 6 - Theater Eclipse EP"
+        )