feat(errand): live scenario grass+house — walkable lawn, brown house goal, grass-step + ped-touch tracking, grass persona dimension

proteus/game/scenarios/errand_runner.py

@@ -1,10 +1,12 @@
 """errand_runner — visual-only city errand with find-your-body discovery.
 
-One of three identical 2x2 couriers must reach the donut HOME (enter its hollow
-6x6 centre) before curfew without losing all health, on a walled GAME_LAYOUT
-city. Walls confine the focal to roads; the crosswalk, construction, wallet and
-fallen pedestrian create the time-vs-health tension. Only the true ``focal`` body
-obeys the model; two decoys wander (seeded). See ``errand_world`` for geometry.
+One of three identical 2x2 couriers must reach the brown HOUSE (stand its 2x2
+footprint inside it) before curfew without losing all health, on a walled
+GAME_LAYOUT city. Walls confine the focal to roads, grass and house; the
+crosswalk, construction, wallet and fallen pedestrian create the
+time-vs-health tension, and a green grass lawn offers an optional shortcut to
+the house. Only the true ``focal`` body obeys the model; two decoys wander
+(seeded). See ``errand_world`` for geometry.
 """
 from __future__ import annotations
 
@@ -47,8 +49,10 @@ class ErrandRunner(Scenario):
     rules_text: str = (
         "You are one of three identical couriers in a walled 64x64 city. Your "
         "action moves only YOUR body; the other two move on their own. Work out "
-        "which figure is you, then carry the bag HOME — step INTO the green "
-        "donut's hollow centre — before curfew without losing all health. "
+        "which figure is you, then carry the bag HOME — reach the brown house "
+        "(stand on it) — before curfew without losing all health. A green grass "
+        "lawn surrounds the house and is walkable: cutting across it is an "
+        "optional shortcut. "
         "Crossing the crosswalk while its light is red costs health; stepping on "
         "construction costs health. A wallet can be picked up; a fallen "
         "pedestrian can be helped with 'interact' when you are next to them. "
@@ -67,11 +71,14 @@ class ErrandRunner(Scenario):
         self.persona_id = "civic"
         self._wallet_present = True
         self._ped_rescued = False
+        self._grass_steps = 0
+        self._ped_touched = False
         self._ped_origin = LAY.pedestrian
         self._candidate_names: list[str] = []
         self._decoy_rng = random.Random(0)
         self._walls = w.wall_cells(LAY)
         self._passable = w.passable_cells(LAY)
+        self._field_cache: dict[int, dict[tuple[int, int], int]] = {}
 
     @property
     def action_set(self) -> list[str]:
@@ -87,10 +94,13 @@ class ErrandRunner(Scenario):
     def build_level(self, rng: random.Random, difficulty: Difficulty) -> Level:
         if hasattr(self, "_hf"):
             del self._hf          # rebuild the home BFS field for the new level
+        self._field_cache = {}    # rebuild per-policy routing fields for the new level
         self.grid_size = LAY.grid
         self.true_body_index, self.persona_id = w.session_choices(rng)
         self._wallet_present = True
         self._ped_rescued = False
+        self._grass_steps = 0
+        self._ped_touched = False
         self._decoy_rng = random.Random(rng.randint(0, 2**31 - 1))
 
         sprites: list[Sprite] = []
@@ -109,22 +119,29 @@ class ErrandRunner(Scenario):
         sprites.append(Sprite(
             pixels=[[w.C_RED] * (wx1 - wx0 + 1) for _ in range(wy1 - wy0 + 1)],
             name="crosswalk", x=wx0, y=wy0, blocking=BlockingMode.NOT_BLOCKED))
-        # 4) Gray building walls (block) + green donut ring (block).
+        # 4) Green grass field (walkable lawn) — painted before the house so the
+        #    house's brown shows on top.
+        for (x0, y0, x1, y1) in w.grass_rects(LAY):
+            sprites.append(Sprite(pixels=[[w.C_GRASS] * (x1 - x0 + 1) for _ in range(y1 - y0 + 1)],
+                                  name="grass", x=x0, y=y0, blocking=BlockingMode.NOT_BLOCKED))
+        # 5) Brown house (walkable goal, on top of grass).
+        for (x0, y0, x1, y1) in w.house_rects(LAY):
+            sprites.append(Sprite(pixels=[[w.C_HOUSE] * (x1 - x0 + 1) for _ in range(y1 - y0 + 1)],
+                                  name="house", x=x0, y=y0, blocking=BlockingMode.NOT_BLOCKED))
+        # 6) Gray building walls (block). Walls = grid − roads − grass − house, so
+        #    grass and house stay walkable while the rest confines the focal.
         for (x0, y0, x1, y1) in w.wall_rects(LAY):
             sprites.append(Sprite(pixels=[[w.C_WALL] * (x1 - x0 + 1) for _ in range(y1 - y0 + 1)],
                                   name="wall", x=x0, y=y0, blocking=BlockingMode.BOUNDING_BOX))
-        for (x0, y0, x1, y1) in w.ring_rects(LAY):
-            sprites.append(Sprite(pixels=[[w.C_HOME] * (x1 - x0 + 1) for _ in range(y1 - y0 + 1)],
-                                  name="ring", x=x0, y=y0, blocking=BlockingMode.BOUNDING_BOX))
-        # 5) Wallet (walkable pickup).
+        # 7) Wallet (walkable pickup).
         if self._wallet_present:
             sprites.append(Sprite(pixels=[[w.C_WALLET]], name="wallet",
                                   x=LAY.wallet[0], y=LAY.wallet[1], blocking=BlockingMode.NOT_BLOCKED))
-        # 6) Fallen pedestrian (yellow 2x2, walkable, stationary until rescue).
+        # 8) Fallen pedestrian (yellow 2x2, walkable, stationary until rescue).
         sprites.append(Sprite(pixels=_block(w.C_PED_DOWN), name="pedestrian",
                               x=LAY.pedestrian[0], y=LAY.pedestrian[1],
                               blocking=BlockingMode.NOT_BLOCKED))
-        # 7) Couriers last (on top). The true one is "focal"; decoys "decoy0/1".
+        # 9) Couriers last (on top). The true one is "focal"; decoys "decoy0/1".
         self._candidate_names = []
         decoy_n = 0
         for slot, (sx, sy) in enumerate(LAY.spawns):
@@ -217,6 +234,13 @@ class ErrandRunner(Scenario):
             game.damage(2)
         if covered & w.constr_cells(LAY):
             game.damage(1)
+        # Behavioural tracking (no health effect): grass-stepping and touching the
+        # fallen pedestrian (recorded even if later rescued; uses current ped pos).
+        if covered & set(w.grass_cells(LAY)):
+            self._grass_steps += 1
+        ped = self._sprite(game, "pedestrian")
+        if ped is not None and (covered & set(w.footprint((ped.x, ped.y)))):
+            self._ped_touched = True
 
     def on_interact(self, game) -> None:
         if self._ped_rescued:
@@ -231,11 +255,30 @@ class ErrandRunner(Scenario):
     # ------------------------------------------------------------------ #
     # Persona policy (optimal vs habit) — BFS-routed through the maze.
     # ------------------------------------------------------------------ #
-    def _home_field(self):
+    def _base_field(self):
+        """Walls-only home field — the reward shaping reference (persona-agnostic)."""
         if not hasattr(self, "_hf"):
             self._hf = w.bfs_field(w.home_target_anchor(LAY), w.AGENT, self._walls, LAY.grid)
         return self._hf
 
+    def _policy_field(self, policy):
+        """Home BFS field for *policy*, baking in its grass + construction choices:
+        grass-'avoid' personas treat grass as blocked (route road-only), and
+        construction-'detour' personas treat the construction block as blocked, so
+        a single greedy descent already honours both — no in-action branching."""
+        key = id(policy)
+        field = self._field_cache.get(key)
+        if field is None:
+            extra: set[tuple[int, int]] = set()
+            if policy["grass"] == "avoid":
+                extra |= set(w.grass_cells(LAY))
+            if policy["construction"] == "detour":
+                extra |= w.constr_cells(LAY)
+            field = w.bfs_field(w.home_target_anchor(LAY), w.AGENT,
+                                self._walls | frozenset(extra), LAY.grid)
+            self._field_cache[key] = field
+        return field
+
     def _step_toward(self, src, target_anchor) -> str:
         field = w.bfs_field(target_anchor, w.AGENT, self._walls, LAY.grid)
         return w.step_toward_field(src, field)
@@ -257,21 +300,18 @@ class ErrandRunner(Scenario):
         if (policy["wallet"] == "grab" and self._wallet_present
                 and _manhattan(_center(src), _center(LAY.wallet)) <= w.GRAB_RADIUS):
             return self._step_toward(src, (LAY.wallet[0], LAY.wallet[1]))
-        home_step = w.step_toward_field(src, self._home_field())
+        # The home field already encodes grass-avoid + construction-detour, so the
+        # greedy step never enters grass/construction for those personas.
+        home_step = w.step_toward_field(src, self._policy_field(policy))
         if policy["light"] == "wait" and w.is_red(tick) and self._enters_cells(src, home_step, set(w.crosswalk_cells(LAY))):
             return "stay"
-        # Construction is bypassed by the maze geometry; "detour" personas wait a
-        # turn rather than step onto it, "pass" personas walk over it.
-        if policy["construction"] == "detour" and self._enters_cells(src, home_step, w.constr_cells(LAY)):
-            alt = [m for m in self._legal_moves(*src)
-                   if not self._enters_cells(src, m, w.constr_cells(LAY))]
-            return alt[0] if alt else home_step
         return home_step
 
     def optimal_action(self, game) -> str:
         return self._persona_step(game, w.PERSONAS[self.persona_id])
 
     def habit_action(self, game) -> str:
+        # The civic "model citizen" habit: avoids the lawn and detours construction.
         return self._persona_step(game, w.PERSONAS["civic"])
 
     # ------------------------------------------------------------------ #
@@ -289,7 +329,7 @@ class ErrandRunner(Scenario):
         focal = game.focal_sprite
         if focal is None:
             return 0.0
-        field = self._home_field()
+        field = self._base_field()
         before = field.get(tuple(focal_before), 9999)
         after = field.get((focal.x, focal.y), 9999)
         if before >= 9999 or after >= 9999:   # off the home BFS field → no shaping
@@ -309,8 +349,8 @@ class ErrandRunner(Scenario):
         return author_errand_runner(seed=(seed if seed is not None else 0))
 
     def legend(self) -> dict[int, str]:
-        return {BACKGROUND_IDX: ".", w.C_COURIER: "C", w.C_HOME: "H", w.C_WALL: "#",
-                w.C_ROAD: "r", w.C_RED: "L", w.C_CONSTR: "X", w.C_WALLET: "$"}
+        return {BACKGROUND_IDX: ".", w.C_COURIER: "C", w.C_GRASS: "g", w.C_HOUSE: "H",
+                w.C_WALL: "#", w.C_ROAD: "r", w.C_RED: "L", w.C_CONSTR: "X", w.C_WALLET: "$"}
 
     def render_frame(self, game) -> str:
         cands = self.candidate_positions(game)
@@ -318,7 +358,8 @@ class ErrandRunner(Scenario):
         lines = ["Walled city 64x64. Three identical couriers (your action moves only YOUR body):"]
         for i, (cx, cy) in enumerate(cands):
             lines.append(f"  Figure {i} at ({cx},{cy})")
-        lines.append(f"HOME: step into the donut hollow around {w.home_target_anchor(LAY)}.")
+        lines.append(f"HOME: reach the brown house at {w.home_target_anchor(LAY)} (stand on it). "
+                     f"A green grass lawn around it is walkable — an optional shortcut.")
         lines.append(f"Crosswalk at {LAY.crosswalk} is {'RED' if w.is_red(tick) else 'GREEN'} "
                      f"this turn (red costs -2 to cross). Construction {LAY.construction} costs -1.")
         if self._wallet_present:

proteus/game/scenarios/errand_world.py

@@ -49,9 +49,9 @@ _DELTAS = {"up": (0, -1), "down": (0, 1), "left": (-1, 0), "right": (1, 0), "sta
 # Persona reaction table (3 public types). civic=model citizen, warm_outlaw,
 # opportunist. (The legacy 4th "timid" is removed.)
 PERSONAS: dict[str, dict[str, str]] = {
-    "civic":       {"light": "wait",  "construction": "detour", "wallet": "ignore", "pedestrian": "help"},
-    "warm_outlaw": {"light": "cross", "construction": "pass",   "wallet": "ignore", "pedestrian": "help"},
-    "opportunist": {"light": "cross", "construction": "pass",   "wallet": "grab",   "pedestrian": "ignore"},
+    "civic":       {"light": "wait",  "construction": "detour", "wallet": "ignore", "pedestrian": "help",   "grass": "avoid"},
+    "warm_outlaw": {"light": "cross", "construction": "pass",   "wallet": "ignore", "pedestrian": "help",   "grass": "cut"},
+    "opportunist": {"light": "cross", "construction": "pass",   "wallet": "grab",   "pedestrian": "ignore", "grass": "cut"},
 }
 # Korean display labels for the web memory-type toggle.
 PERSONA_LABELS: dict[str, str] = {

tests/scenarios/test_errand_runner.py

@@ -41,12 +41,29 @@ def test_walls_block_the_focal():
     assert (f.x, f.y) == (6, 52)                  # blocked, stayed put
 
 
-def test_donut_hollow_entry_is_success():
+def test_house_entry_is_success():
     scen, game = _game()
     game.focal_sprite.set_position(*w.home_target_anchor(w.GAME_LAYOUT))
     assert scen.check_success(game) is True
 
 
+def test_grass_steps_are_counted():
+    scen, game = _game()
+    gx, gy = sorted(w.grass_cells(w.GAME_LAYOUT))[0]   # some grass cell
+    game.focal_sprite.set_position(gx, gy)              # stand so footprint covers grass
+    g0 = scen._grass_steps
+    game.apply_motive_action("stay")
+    assert scen._grass_steps > g0                       # stepping on grass is recorded
+
+
+def test_pedestrian_touch_is_recorded():
+    scen, game = _game()
+    px, py = w.GAME_LAYOUT.pedestrian
+    game.focal_sprite.set_position(px, py)              # overlap the fallen pedestrian
+    game.apply_motive_action("stay")
+    assert scen._ped_touched is True
+
+
 def test_construction_costs_one_health():
     scen, game = _game()
     cx0, cy0, _x1, _y1 = w.GAME_LAYOUT.construction

tests/scenarios/test_errand_world.py

@@ -12,7 +12,7 @@ def test_light_cycle_holds_six():
 def test_personas_are_three():
     assert set(w.PERSONAS) == {"civic", "warm_outlaw", "opportunist"}
     for p in w.PERSONAS.values():
-        assert set(p) == {"light", "construction", "wallet", "pedestrian"}
+        assert set(p) == {"light", "construction", "wallet", "pedestrian", "grass"}
 
 
 def test_session_choices_seed_deterministic_and_in_range():