Complete randomized board generation

.github/workflows/python-tests.yml

@@ -2,6 +2,8 @@ name: WumpusWorld tests
 
 on:
   push:
+    branches:
+      - master
   pull_request:
 
 jobs:

scripts/environment.py

@@ -13,18 +13,27 @@ def __init__(
         gold_pos=(2, 3),
         randomize=False,
         seed=None,
-        pit_count=2,
+        grid_size_range=None,
+        randomize_start=False,
+        start_pos=(1, 1),
+        pit_count=None,
     ):
-        self.grid_size = grid_size
-        self.start_pos = (1, 1)
+        generator = random.Random(seed)
+        self.grid_size = self._select_grid_size(grid_size, grid_size_range, generator)
+        if randomize and randomize_start:
+            self.start_pos = generator.choice(self._all_positions())
+        else:
+            self.start_pos = start_pos
         self.agent = AgentState(
             x=self.start_pos[0],
             y=self.start_pos[1],
             direction=Direction.EAST,
         )
 
         if randomize:
-            wumpus_pos, pits, gold_pos = self._generate_layout(seed, pit_count)
+            wumpus_pos, pits, gold_pos = self._generate_layout(
+                generator, pit_count, randomize_start
+            )
 
         self.wumpus_pos = wumpus_pos
         self.pits = set(pits) if pits is not None else {(3, 1), (3, 3)}
@@ -38,6 +47,29 @@ def __init__(
         # Log initial tile percepts at (1,1)
         self.record_current_percepts()
 
+    def _select_grid_size(self, grid_size, grid_size_range, generator):
+        if grid_size_range is None:
+            return grid_size
+
+        if (
+            not isinstance(grid_size_range, tuple)
+            or len(grid_size_range) != 2
+            or not all(isinstance(size, int) for size in grid_size_range)
+        ):
+            raise ValueError("grid_size_range must be a tuple of two integers")
+
+        minimum, maximum = grid_size_range
+        if minimum < 1 or minimum > maximum:
+            raise ValueError("grid_size_range must contain valid bounds")
+        return generator.randint(minimum, maximum)
+
+    def _all_positions(self):
+        return [
+            (x, y)
+            for x in range(1, self.grid_size + 1)
+            for y in range(1, self.grid_size + 1)
+        ]
+
     def _validate_layout(self):
         if not isinstance(self.grid_size, int) or self.grid_size < 1:
             raise ValueError("grid_size must be a positive integer")
@@ -72,21 +104,40 @@ def _is_valid_position(self, position):
             and 1 <= position[1] <= self.grid_size
         )
 
-    def _generate_layout(self, seed, pit_count):
+    def _protected_start_positions(self):
+        x, y = self.start_pos
+        return {
+            position
+            for position in (
+                (x, y),
+                (x - 1, y),
+                (x + 1, y),
+                (x, y - 1),
+                (x, y + 1),
+            )
+            if self._is_valid_position(position)
+        }
+
+    def _generate_layout(self, generator, pit_count, protect_start):
+        if pit_count is None:
+            pit_count = max(1, round(self.grid_size ** 2 * 0.15))
         if not isinstance(pit_count, int) or pit_count < 0:
             raise ValueError("pit_count must be a non-negative integer")
 
         positions = [
-            (x, y)
-            for x in range(1, self.grid_size + 1)
-            for y in range(1, self.grid_size + 1)
-            if (x, y) != (1, 1)
+            position
+            for position in self._all_positions()
+            if position
+            not in (
+                self._protected_start_positions()
+                if protect_start
+                else {self.start_pos}
+            )
         ]
         required_positions = pit_count + 2
         if required_positions > len(positions):
             raise ValueError("pit_count is too large for the board")
 
-        generator = random.Random(seed)
         selected = generator.sample(positions, required_positions)
         return selected[0], set(selected[1 : pit_count + 1]), selected[-1]
 

scripts/randommain.py

@@ -4,10 +4,9 @@
 
 def main():
     environment = WumpusEnvironment(
-        grid_size=5,
         randomize=True,
-        seed=7,
-        pit_count=5,
+        grid_size_range=(4, 10),
+        randomize_start=True,
     )
     BoardRenderer(environment).render()
 

scripts/testmain.py

@@ -7,7 +7,7 @@ def main():
         grid_size=5,
         wumpus_pos=(4, 2),
         pits={(1, 4), (3, 3), (4, 4), (5, 1)},
-        gold_pos=(3, 5),
+        gold_pos=(3, 4),
     )
     BoardRenderer(environment).render()
 

tests/test_environment.py

@@ -260,6 +260,64 @@ def test_rejects_invalid_layout_positions(self):
 
 
 class TestRandomizedLayouts(unittest.TestCase):
+    def test_randomized_grid_uses_area_based_pit_count_and_protected_start(self):
+        environment = WumpusEnvironment(
+            randomize=True,
+            seed=7,
+            grid_size_range=(4, 10),
+            randomize_start=True,
+        )
+        start_x, start_y = environment.start_pos
+        protected = {
+            (start_x, start_y),
+            (start_x - 1, start_y),
+            (start_x + 1, start_y),
+            (start_x, start_y - 1),
+            (start_x, start_y + 1),
+        }
+        protected = {
+            position
+            for position in protected
+            if 1 <= position[0] <= environment.grid_size
+            and 1 <= position[1] <= environment.grid_size
+        }
+        objects = {environment.wumpus_pos, environment.gold_pos}
+        objects.update(environment.pits)
+
+        self.assertIn(environment.grid_size, range(4, 11))
+        expected_pits = max(1, round(environment.grid_size ** 2 * 0.15))
+        self.assertEqual(len(environment.pits), expected_pits)
+        self.assertTrue(protected.isdisjoint(objects))
+
+    def test_area_based_pit_count_grows_with_board_size(self):
+        for grid_size, expected_pits in ((4, 2), (6, 5), (10, 15)):
+            with self.subTest(grid_size=grid_size):
+                environment = WumpusEnvironment(
+                    grid_size=grid_size,
+                    randomize=True,
+                    seed=7,
+                )
+
+                self.assertEqual(len(environment.pits), expected_pits)
+
+    def test_randomized_start_is_repeatable_with_seed(self):
+        first = WumpusEnvironment(
+            randomize=True,
+            seed=7,
+            grid_size_range=(4, 10),
+            randomize_start=True,
+        )
+        second = WumpusEnvironment(
+            randomize=True,
+            seed=7,
+            grid_size_range=(4, 10),
+            randomize_start=True,
+        )
+
+        self.assertEqual(first.start_pos, second.start_pos)
+        self.assertEqual(first.grid_size, second.grid_size)
+        self.assertEqual(first.pits, second.pits)
+
     def test_seeded_layouts_are_repeatable(self):
         first = WumpusEnvironment(randomize=True, seed=7)
         second = WumpusEnvironment(randomize=True, seed=7)