feat(pack_evade): 2x2 focal, 3x3 open-mouth predator, gap-2, predator-first

proteus/game/scenarios/pack_evade.py

@@ -1,6 +1,6 @@
 """pack_evade — a 64x64 open-field, multi-cell predator-evasion scenario.
 
-A single 5x5 predator hunts a 3x3 focal agent (the lone survivor of a pack of
+A single 3x3 predator hunts a 2x2 focal agent (the lone survivor of a pack of
 three; the two that were caught live only in the hand-authored handover memory,
 see ``proteus.game.runtime.pack_evade_memory``). The field is open (no walls), so all
 geometry is **center-to-center Manhattan** — no BFS. There is no habit/diagnostic
@@ -31,8 +31,19 @@ WALL_IDX = 3        # matches predator_evade + COLOR_MAP gray
 FOOD_IDX = 14       # COLOR_MAP green; observational food cells
 
 _GRID = (64, 64)
-_FOCAL_START = (5, 30)      # 3x3 -> footprint x[5,8) y[30,33), center (6,31)
-_PREDATOR_START = (54, 29)  # 5x5 -> footprint x[54,59) y[29,34), center (56,31)
+_FOCAL_SIZE = 2
+_PREDATOR_SIZE = 3
+_FOCAL_START = (5, 30)      # 2x2 -> footprint x[5,7) y[30,32), center (6,31)
+_PREDATOR_START = (54, 30)  # 3x3 -> footprint x[54,57) y[30,33), center (55,31)
+# ㄷ (open-mouth) predator pixels; mouth opens EAST in the base orientation.
+# Transparent (-1) cells render as background and never collide.
+_PREDATOR_PIXELS = [
+    [PREDATOR_IDX, PREDATOR_IDX, PREDATOR_IDX],
+    [PREDATOR_IDX, -1, -1],
+    [PREDATOR_IDX, PREDATOR_IDX, PREDATOR_IDX],
+]
+# action -> clockwise rotation so the mouth faces the movement direction.
+_FACING = {"right": 0, "down": 90, "left": 180, "up": 270}
 
 _DELTAS: dict[str, tuple[int, int]] = {
     "up": (0, -1), "down": (0, 1), "left": (-1, 0), "right": (1, 0), "stay": (0, 0),
@@ -40,8 +51,8 @@ _DELTAS: dict[str, tuple[int, int]] = {
 _TIE_BREAK_ORDER: tuple[str, ...] = ("up", "down", "left", "right", "stay")
 
 # --- wall terrain config + geometry helpers -------------------------------- #
-_NARROW_GAP = 3          # focal (3-wide) fits; predator (5-wide) cannot
-_CLEARANCE = 6           # min free corridor around blocks/spawns (predator-wide)
+_NARROW_GAP = 2          # focal (2-wide) fits; predator (3-wide) cannot
+_CLEARANCE = 4           # min free corridor around blocks/spawns (> predator-wide)
 _MARGIN = 2              # keep walls off the very border
 # (solid blocks, focal-only channels) per difficulty
 _WALL_COUNTS = {
@@ -51,16 +62,21 @@ _WALL_COUNTS = {
     Difficulty.EXPERT: (5, 3),
 }
 _SPAWN_RECTS = (
-    (_FOCAL_START[0], _FOCAL_START[1], _FOCAL_START[0] + 2, _FOCAL_START[1] + 2),
-    (_PREDATOR_START[0], _PREDATOR_START[1], _PREDATOR_START[0] + 4, _PREDATOR_START[1] + 4),
+    (_FOCAL_START[0], _FOCAL_START[1],
+     _FOCAL_START[0] + _FOCAL_SIZE - 1, _FOCAL_START[1] + _FOCAL_SIZE - 1),
+    (_PREDATOR_START[0], _PREDATOR_START[1],
+     _PREDATOR_START[0] + _PREDATOR_SIZE - 1, _PREDATOR_START[1] + _PREDATOR_SIZE - 1),
 )
 
 # Extra (beyond the two mandatory) observational food cells per difficulty.
 _FOOD_EXTRAS = {
     Difficulty.EASY: 1, Difficulty.MEDIUM: 2, Difficulty.HARD: 3, Difficulty.EXPERT: 3,
 }
-_FOCAL_CENTER = (_FOCAL_START[0] + 1, _FOCAL_START[1] + 1)      # 3x3 center
-_PREDATOR_CENTER = (_PREDATOR_START[0] + 2, _PREDATOR_START[1] + 2)  # 5x5 center
+_FOCAL_CENTER = (_FOCAL_START[0] + _FOCAL_SIZE // 2, _FOCAL_START[1] + _FOCAL_SIZE // 2)
+_PREDATOR_CENTER = (
+    _PREDATOR_START[0] + _PREDATOR_SIZE // 2,
+    _PREDATOR_START[1] + _PREDATOR_SIZE // 2,
+)
 
 
 def _sign(v: int) -> int:
@@ -113,9 +129,10 @@ class PackEvade(Scenario):
 
     task_name: str = "pack_evade"
     grid_size: tuple[int, int] = _GRID
+    turn_order: str = "predator_first"
     rules_text: str = (
-        "You control agent A, a 3x3 block, on a 64x64 field laced with impassable "
-        "wall blocks (your 3x3 body cannot overlap a wall). A 5x5 predator B hunts "
+        "You control agent A, a 2x2 block, on a 64x64 field laced with impassable "
+        "wall blocks (your 2x2 body cannot overlap a wall). A 3x3 predator B hunts "
         "you, moving one cell toward you every turn. You are eaten if B's block "
         "touches (overlaps) yours. Food cells (1x1) are scattered on the field — "
         "one near you and one behind the predator — they are edible context. Stay "
@@ -123,8 +140,8 @@ class PackEvade(Scenario):
         "decreases the row, down increases it; left/right move along the column)."
     )
     memory_brief: str = (
-        "PRACTICE / MEMORY RUN. You are A (3x3) on a 64x64 field laced with "
-        "impassable wall blocks (you cannot overlap a wall). A 5x5 predator B "
+        "PRACTICE / MEMORY RUN. You are A (2x2) on a 64x64 field laced with "
+        "impassable wall blocks (you cannot overlap a wall). A 3x3 predator B "
         "hunts you, stepping one cell toward you each turn; you are eaten if its "
         "block overlaps yours. Food cells (1x1) are scattered — one near you and "
         "one behind the predator — they are edible context. Keep maximum distance. "
@@ -144,12 +161,12 @@ class PackEvade(Scenario):
         )
         self._food_cells = self._generate_food(rng, difficulty)
         focal = Sprite(
-            pixels=[[FOCAL_IDX] * 3 for _ in range(3)],
+            pixels=[[FOCAL_IDX] * _FOCAL_SIZE for _ in range(_FOCAL_SIZE)],
             name="focal", x=_FOCAL_START[0], y=_FOCAL_START[1],
             blocking=BlockingMode.BOUNDING_BOX,
         )
         predator = Sprite(
-            pixels=[[PREDATOR_IDX] * 5 for _ in range(5)],
+            pixels=[row[:] for row in _PREDATOR_PIXELS],
             name="predator", x=_PREDATOR_START[0], y=_PREDATOR_START[1],
             blocking=BlockingMode.NOT_BLOCKED,
         )
@@ -230,11 +247,11 @@ class PackEvade(Scenario):
     def _generate_walls(
         self, rng: random.Random, difficulty: Difficulty
     ) -> list[tuple[int, int, int, int]]:
-        """Seeded rectangular blocks + focal-only (width-3) channels.
+        """Seeded rectangular blocks + focal-only (width-2) channels.
 
         Blocks/channels keep a predator-wide ``_CLEARANCE`` from each other, the
         border, and both spawns, so the predator-navigable space stays connected;
-        each channel's 3-wide slot admits the 3x3 focal but not the 5x5 predator.
+        each channel's 2-wide slot admits the 2x2 focal but not the 3x3 predator.
         """
         w, h = _GRID
         n_blocks, n_channels = _WALL_COUNTS.get(difficulty, (3, 2))
@@ -334,6 +351,8 @@ class PackEvade(Scenario):
                 best_dist, best_action = dist, action
         dx, dy = _DELTAS[best_action]
         predator.move(dx, dy)
+        if best_action in _FACING:
+            predator.set_rotation(_FACING[best_action])
 
     def optimal_action(self, game: MotiveGridGame) -> str:
         focal, predator = game.focal_sprite, game.predator_sprite
@@ -368,7 +387,10 @@ class PackEvade(Scenario):
         if focal is None:
             return 0.0
         fw, fh = focal.width, focal.height
-        pred_center_before = (predator_before[0] + 5 // 2, predator_before[1] + 5 // 2)
+        pred_center_before = (
+            predator_before[0] + _PREDATOR_SIZE // 2,
+            predator_before[1] + _PREDATOR_SIZE // 2,
+        )
         center_after = (focal.x + fw // 2, focal.y + fh // 2)
         center_before = (focal_before[0] + fw // 2, focal_before[1] + fh // 2)
         return float(
@@ -392,7 +414,10 @@ class PackEvade(Scenario):
         if focal is None:
             return None
         fw, fh = focal.width, focal.height
-        pred_center_before = (predator_before[0] + 5 // 2, predator_before[1] + 5 // 2)
+        pred_center_before = (
+            predator_before[0] + _PREDATOR_SIZE // 2,
+            predator_before[1] + _PREDATOR_SIZE // 2,
+        )
         center_after = (focal.x + fw // 2, focal.y + fh // 2)
         center_before = (focal_before[0] + fw // 2, focal_before[1] + fh // 2)
         return float(
@@ -414,8 +439,8 @@ class PackEvade(Scenario):
         fc, pc = _center(focal), _center(predator)
         w, h = self.grid_size
         lines = [
-            f"Open field {w}x{h}. You are A (3x3) centered at {fc}. "
-            f"Predator B (5x5) centered at {pc}. Manhattan distance {_manhattan(fc, pc)}."
+            f"Open field {w}x{h}. You are A (2x2) centered at {fc}. "
+            f"Predator B (3x3) centered at {pc}. Manhattan distance {_manhattan(fc, pc)}."
         ]
         if self._wall_rects:
             rects = "; ".join(
@@ -424,7 +449,7 @@ class PackEvade(Scenario):
             lines.append(
                 "Walls (blocked rectangles, inclusive (x0,y0)-(x1,y1)): " + rects + "."
             )
-            lines.append("Your 3x3 body cannot overlap these.")
+            lines.append("Your 2x2 body cannot overlap these.")
         if self._food_cells:
             cells = "; ".join(f"({x},{y})" for (x, y) in self._food_cells)
             lines.append(
@@ -438,7 +463,7 @@ class PackEvade(Scenario):
 
     # --- persona-policy compatibility shims (wall-aware focal navigation) --- #
     def _is_free(self, game: MotiveGridGame, cell: tuple[int, int]) -> bool:
-        """True iff the 3x3 focal footprint anchored at *cell* is on-grid + wall-free.
+        """True iff the 2x2 focal footprint anchored at *cell* is on-grid + wall-free.
 
         Used only by the shared hidden-persona reference policy
         (``proteus.game.metrics.persona``), which calls it on the focal's top-left

tests/grid/test_pack_evade.py

@@ -19,8 +19,8 @@ def test_build_is_64x64_with_multicell_sprites():
     scenario, game = _game()
     assert scenario.grid_size == (64, 64)
     focal, predator = game.focal_sprite, game.predator_sprite
-    assert (focal.width, focal.height) == (3, 3)
-    assert (predator.width, predator.height) == (5, 5)
+    assert (focal.width, focal.height) == (2, 2)
+    assert (predator.width, predator.height) == (3, 3)
     # Disjoint at start (not already eaten).
     assert not scenario.check_elimination(game)
 
@@ -29,20 +29,20 @@ def test_eat_fires_on_footprint_overlap_not_adjacency():
     scenario, game = _game()
     focal, predator = game.focal_sprite, game.predator_sprite
     # Place predator footprint just touching but NOT overlapping the focal:
-    focal.move(-focal.x, -focal.y)            # focal anchor -> (0,0), occupies x,y in [0,3)
-    predator.move(3 - predator.x, -predator.y)  # predator anchor -> (3,0): x in [3,8), no overlap
+    focal.move(-focal.x, -focal.y)            # focal anchor -> (0,0), occupies x,y in [0,2)
+    predator.move(2 - predator.x, -predator.y)  # predator anchor -> (2,0): x in [2,5), no overlap
     assert not scenario.check_elimination(game)
-    predator.move(-1, 0)                       # anchor -> (2,0): x in [2,7) overlaps focal x in [0,3)
+    predator.move(-1, 0)                       # anchor -> (1,0): x in [1,4) overlaps focal x in [0,2)
     assert scenario.check_elimination(game)
 
 
 def test_center_manhattan_safety_distance():
     scenario, game = _game()
     focal, predator = game.focal_sprite, game.predator_sprite
-    focal.move(-focal.x, -focal.y)             # center (1,1)
-    predator.move(10 - predator.x, -predator.y)  # anchor (10,0), center (12,2)
-    # |12-1| + |2-1| = 12
-    assert scenario.safety_distance(game) == 12
+    focal.move(-focal.x, -focal.y)             # focal 2x2: center (1,1)
+    predator.move(10 - predator.x, -predator.y)  # anchor (10,0), predator 3x3: center (11,1)
+    # |11-1| + |1-1| = 10
+    assert scenario.safety_distance(game) == 10
 
 
 def test_optimal_moves_away_and_no_diagnostic():

tests/grid/test_pack_evade_walls.py

@@ -26,8 +26,8 @@ def test_walls_are_generated_and_deterministic():
 def test_walls_clear_spawns_and_border():
     scn, _ = _scn(seed=7)
     w, h = scn.grid_size
-    # spawn footprints must be wall-free
-    for (sx, sy, sw, sh) in [(5, 30, 3, 3), (54, 29, 5, 5)]:
+    # spawn footprints must be wall-free (focal 2x2 at (5,30), predator 3x3 at (54,30))
+    for (sx, sy, sw, sh) in [(5, 30, 2, 2), (54, 30, 3, 3)]:
         for j in range(sh):
             for i in range(sw):
                 assert (sx + i, sy + j) not in scn._wall_cells
@@ -37,7 +37,7 @@ def test_walls_clear_spawns_and_border():
 
 
 def test_has_a_focal_only_channel():
-    """Some 3x3-passable cell is NOT 5x5-passable: a focal-only gap exists."""
+    """Some 2x2-passable cell is NOT 3x3-passable: a focal-only gap exists."""
     scn, _ = _scn(seed=7)
     w, h = scn.grid_size
     wc = scn._wall_cells
@@ -51,35 +51,35 @@ def test_has_a_focal_only_channel():
         return True
 
     found = any(
-        fp_free(x, y, 3) and not fp_free(x, y, 5)
+        fp_free(x, y, 2) and not fp_free(x, y, 3)
         for x in range(w) for y in range(h)
     )
-    assert found, "expected at least one focal-only (3x3 yes, 5x5 no) anchor"
+    assert found, "expected at least one focal-only (2x2 yes, 3x3 no) anchor"
 
 
 def test_predator_can_reach_focal_region():
-    """Predator (5x5) BFS from its spawn reaches adjacency of the focal spawn."""
+    """Predator (3x3) BFS from its spawn reaches adjacency of the focal spawn."""
     scn, _ = _scn(seed=7)
     w, h = scn.grid_size
     wc = scn._wall_cells
 
-    def fp_free5(x, y):
+    def fp_free3(x, y):
         return all(
             0 <= x + i < w and 0 <= y + j < h and (x + i, y + j) not in wc
-            for j in range(5) for i in range(5)
+            for j in range(3) for i in range(3)
         )
 
     from collections import deque
-    start = (54, 29)
+    start = (54, 30)
     seen = {start}
     q = deque([start])
     while q:
         x, y = q.popleft()
         for dx, dy in ((0, -1), (0, 1), (-1, 0), (1, 0)):
             nx, ny = x + dx, y + dy
-            if (nx, ny) not in seen and fp_free5(nx, ny):
+            if (nx, ny) not in seen and fp_free3(nx, ny):
                 seen.add((nx, ny)); q.append((nx, ny))
-    # an anchor whose 5x5 footprint can sit adjacent to the focal spawn (5,30)
+    # an anchor whose 3x3 footprint can sit adjacent to the focal spawn (5,30)
     assert any(abs(ax - 5) <= 6 and abs(ay - 30) <= 6 for (ax, ay) in seen)
 
 
@@ -87,11 +87,11 @@ def test_focal_cannot_move_into_a_wall():
     scn, game = _scn(seed=7)
     focal = game.focal_sprite
     wx, wy = sorted(scn._wall_cells)[len(scn._wall_cells) // 2]
-    # place focal so moving +1 x makes its 3x3 footprint cover (wx,wy)
-    focal.set_position(wx - 3, wy)         # footprint x[wx-3, wx), not yet on wall
-    assert (focal.x, focal.y) == (wx - 3, wy)
+    # place focal so moving +1 x makes its 2x2 footprint cover (wx,wy)
+    focal.set_position(wx - 2, wy)         # footprint x[wx-2, wx), not yet on wall
+    assert (focal.x, focal.y) == (wx - 2, wy)
     game.apply_motive_action("right")      # would put footprint over (wx,wy)
-    assert focal.x == wx - 3, "move into wall must be reverted by the engine"
+    assert focal.x == wx - 2, "move into wall must be reverted by the engine"
 
 
 def test_predator_never_lands_on_a_wall():
@@ -101,7 +101,7 @@ def test_predator_never_lands_on_a_wall():
             break
         game.apply_motive_action("stay")
         pred = game.predator_sprite
-        cells = {(pred.x + i, pred.y + j) for j in range(5) for i in range(5)}
+        cells = {(pred.x + i, pred.y + j) for j in range(pred.height) for i in range(pred.width)}
         assert not (cells & scn._wall_cells), "predator footprint entered a wall"
 
 

tests/scenarios/test_pack_evade_resize.py

@@ -0,0 +1,55 @@
+# tests/scenarios/test_pack_evade_resize.py
+"""pack_evade after resize: 2x2 focal, 3x3 open-mouth predator, gap-2 channels."""
+import random
+
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.engine.grid import MotiveGridGame
+from proteus.game.scenarios.base import get_scenario
+import proteus.game.scenarios  # noqa: F401
+
+
+def _game(diff=Difficulty.EASY, seed=42):
+    scen = get_scenario("pack_evade")()
+    return scen, MotiveGridGame(scen, random.Random(seed), diff, max_steps=50)
+
+
+def test_sprite_sizes():
+    scen, game = _game()
+    assert (game.focal_sprite.width, game.focal_sprite.height) == (2, 2)
+    assert (game.predator_sprite.width, game.predator_sprite.height) == (3, 3)
+
+
+def test_predator_has_open_mouth():
+    scen, game = _game()
+    # ㄷ shape: 9-cell bounding box, exactly 7 solid (2 transparent mouth cells).
+    pix = game.predator_sprite.render()
+    assert (pix != -1).sum() == 7
+
+
+def test_turn_order_is_predator_first():
+    scen, _ = _game()
+    assert scen.turn_order == "predator_first"
+
+
+def test_mouth_faces_movement_direction():
+    scen, game = _game()
+    # Force the predator to take a known step and assert its rotation updates.
+    pred = game.predator_sprite
+    pred.set_position(30, 30)
+    game.focal_sprite.set_position(30, 10)  # straight up from predator
+    scen.advance_threat(game)
+    # Moving up => rotation 270 (see _FACING in pack_evade).
+    assert game.predator_sprite.rotation == 270
+
+
+def test_narrow_gap_blocks_predator_admits_focal():
+    scen, game = _game()
+    scen.build_level(random.Random(0), Difficulty.EASY)
+    # A width-2 free corridor: 2-wide focal footprint fits, 3-wide predator does not.
+    # Use the scenario primitive on a synthetic 2-wide gap between two walls.
+    walls = {(10, y) for y in range(0, 20)} | {(13, y) for y in range(0, 20)}
+    scen._wall_cells = frozenset(walls)
+    # focal anchor (11,5): footprint x in {11,12} — clear of both wall columns.
+    assert scen._footprint_free(game, game.focal_sprite, 11, 5) is True
+    # predator anchor (11,5): footprint x in {11,12,13} — hits wall column 13.
+    assert scen._footprint_free(game, game.predator_sprite, 11, 5) is False