The Witness: Add some unit tests

worlds/witness/__init__.py

@@ -183,21 +183,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 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,86 @@
+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
+
+from BaseClasses import CollectionState, Item
+
+from worlds.witness 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:
+        state = CollectionState(self.multiworld)
+        for item in items:
+            state.collect(item)
+        return state.multiworld.can_beat_game(state)
+
+    def assert_can_beat_with_minimally(self, required_item_counts: Mapping[str, int]):
+        """
+        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 = {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():
+            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):
+        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 worlds.witness.test import WitnessMultiworldTestBase, WitnessTestBase
+
+
+class TestElevatorsComeToYou(WitnessTestBase):
+    options = {
+        "elevators_come_to_you": True,
+        "shuffle_doors": "mixed",
+        "shuffle_symbols": False,
+    }
+
+    def test_bunker_laser(self):
+        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):
+        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_door_shuffle.py

@@ -0,0 +1,21 @@
+from worlds.witness.test import WitnessTestBase
+
+
+class TestIndividualDoors(WitnessTestBase):
+    options = {
+        "shuffle_doors": "doors",
+        "door_groupings": "off",
+    }
+
+    def test_swamp_laser_shortcut(self):
+        self.assertTrue(self.get_items_by_name("Swamp Laser Shortcut (Door)"))
+
+        self.assertAccessDependency(
+            ["Swamp Laser Panel"],
+            [
+                ["Swamp Laser Shortcut (Door)"],
+                ["Swamp Entry (Door)"],
+                ["Boat"],
+            ],
+            only_check_listed=True,
+        )