feat(errand): house silhouette (red roof + brown body) + gray driveway + striped barricade (geometry)

proteus/game/scenarios/errand_world.py

@@ -41,7 +41,8 @@ C_COURIER, C_HOME, C_RED, C_GREEN, C_ROAD, C_CONSTR, C_WALLET, C_PED_DOWN = (
     9, 14, 8, 14, 3, 12, 11, 11,
 )
 C_GRASS = 14   # filled green field (walkable)
-C_HOUSE = 13   # brown (Maroon) house — the goal, painted on top of grass
+C_HOUSE = 13   # brown (Maroon) house BODY — the success goal, painted on grass
+C_ROOF = 8     # red roof, painted directly above the house body
 C_WALL = 4     # off-black building blocks
 
 _DELTAS = {"up": (0, -1), "down": (0, 1), "left": (-1, 0), "right": (1, 0), "stay": (0, 0)}
@@ -65,9 +66,11 @@ class WorldLayout:
     grid: tuple[int, int]
     road_rects: tuple[tuple[int, int, int, int], ...]   # inclusive open-road rects
     grass: tuple[int, int, int, int]                    # filled green field (walkable)
-    house: tuple[int, int, int, int]                    # brown goal rect (at grass edge)
+    house_body: tuple[int, int, int, int]               # brown goal rect (>=2x2, the body)
+    house_roof: tuple[int, int, int, int]               # red roof rect, directly above body
+    house_path: tuple[int, int, int, int]               # gray 2-wide driveway to the road
     crosswalk: tuple[int, int, int, int]                # recolouring line (on a road)
-    construction: tuple[int, int, int, int]             # 4x4 block (on a road)
+    construction: tuple[int, int, int, int]             # zone whose two end columns barricade
     wallet: tuple[int, int]                             # 1x1 anchor (on a road)
     pedestrian: tuple[int, int]                         # 2x2 anchor (on a road)
     spawns: tuple[tuple[int, int], ...]                # courier start anchors
@@ -78,10 +81,12 @@ GAME_LAYOUT = WorldLayout(
     name="game", grid=GRID,
     road_rects=((6, 50, 29, 59), (6, 22, 9, 49), (6, 22, 57, 25), (22, 22, 25, 41),
                 (22, 38, 41, 41), (38, 22, 41, 41), (54, 6, 57, 25), (46, 6, 57, 9)),
-    # Grass fills the top-right pocket; the house is its top-left 2x2 corner,
-    # touching the top road (the long way round) so the start (bottom-left) must
-    # cut up through grass for the short route.
-    grass=(46, 10, 53, 21), house=(46, 10, 47, 11),
+    # Grass fills the top-right pocket. The house silhouette (red roof above a
+    # brown body) sits low in the lawn; a 2-wide gray driveway drops from the
+    # body to the H1 road just below the grass (y22). The driveway is the
+    # grass-free route; cutting diagonally across the lawn is the shortcut.
+    grass=(46, 10, 53, 21),
+    house_body=(48, 18, 51, 19), house_roof=(49, 16, 50, 17), house_path=(49, 20, 50, 21),
     crosswalk=(6, 48, 9, 48), construction=(28, 22, 31, 25),
     wallet=(57, 25), pedestrian=(34, 22),
     spawns=((8, 53), (17, 53), (25, 53)), start=(8, 53),
@@ -91,9 +96,12 @@ MEMORY_LAYOUT = WorldLayout(
     name="memory", grid=GRID,
     road_rects=((54, 22, 57, 57), (22, 38, 57, 41), (38, 22, 41, 41), (38, 22, 57, 25),
                 (22, 6, 25, 41), (12, 6, 25, 9)),
-    # Mirror of GAME: grass fills the top-left pocket, house is its top-left 2x2
-    # corner on the top road; grass is the short cut from the bottom-right start.
-    grass=(12, 10, 21, 21), house=(12, 10, 13, 11),
+    # Mirror of GAME: grass fills the top-left pocket. The house silhouette sits
+    # mid-lawn with a 2-wide gray driveway running RIGHT from the body to the
+    # vertical road at x22. The driveway is the grass-free route; cutting across
+    # the lawn from the bottom-right start is the shortcut.
+    grass=(12, 10, 21, 21),
+    house_body=(14, 12, 17, 13), house_roof=(15, 10, 16, 11), house_path=(18, 12, 19, 13),
     crosswalk=(54, 48, 57, 48), construction=(44, 38, 47, 41),
     wallet=(22, 41), pedestrian=(30, 38),
     spawns=((54, 54),), start=(54, 54),
@@ -130,13 +138,23 @@ def road_cells(lay: WorldLayout) -> set[tuple[int, int]]:
 
 
 def house_cells(lay: WorldLayout) -> set[tuple[int, int]]:
-    """Filled rect cells of the brown house (the goal)."""
-    return _rect_cells(lay.house)
+    """Filled rect cells of the brown house BODY (the success goal)."""
+    return _rect_cells(lay.house_body)
+
+
+def roof_cells(lay: WorldLayout) -> set[tuple[int, int]]:
+    """Filled rect cells of the red roof (sits directly above the body)."""
+    return _rect_cells(lay.house_roof)
+
+
+def path_cells(lay: WorldLayout) -> set[tuple[int, int]]:
+    """Filled rect cells of the gray entrance driveway (grass-free route)."""
+    return _rect_cells(lay.house_path)
 
 
 def grass_cells(lay: WorldLayout) -> set[tuple[int, int]]:
-    """Filled rect cells of the green grass field, minus the house carved from it."""
-    return _rect_cells(lay.grass) - house_cells(lay)
+    """Green grass rect cells minus the body, roof and driveway carved from it."""
+    return _rect_cells(lay.grass) - house_cells(lay) - roof_cells(lay) - path_cells(lay)
 
 
 def crosswalk_cells(lay: WorldLayout) -> list[tuple[int, int]]:
@@ -144,12 +162,23 @@ def crosswalk_cells(lay: WorldLayout) -> list[tuple[int, int]]:
 
 
 def constr_cells(lay: WorldLayout) -> set[tuple[int, int]]:
-    return _rect_cells(lay.construction)
+    """The two barricade bars: the FRONT and BACK end columns of the construction
+    rect (each spanning the road). These are the PASSABLE but DAMAGING cells."""
+    x0, y0, x1, y1 = lay.construction
+    return ({(x0, y) for y in range(y0, y1 + 1)}
+            | {(x1, y) for y in range(y0, y1 + 1)})
+
+
+def barricade_overlay(lay: WorldLayout) -> list[tuple[int, int, int]]:
+    """Bar cells coloured with alternating orange/green stripes by (y % 2)."""
+    return [(x, y, C_CONSTR if y % 2 == 0 else C_GREEN)
+            for (x, y) in sorted(constr_cells(lay))]
 
 
 def passable_cells(lay: WorldLayout) -> set[tuple[int, int]]:
-    """Cells the courier may occupy: roads + grass + house (all walkable now)."""
-    return road_cells(lay) | grass_cells(lay) | house_cells(lay)
+    """Cells the courier may occupy: roads + grass + body + roof + driveway."""
+    return (road_cells(lay) | grass_cells(lay) | house_cells(lay)
+            | roof_cells(lay) | path_cells(lay))
 
 
 def wall_cells(lay: WorldLayout) -> frozenset[tuple[int, int]]:
@@ -188,17 +217,30 @@ def grass_rects(lay: WorldLayout) -> list[tuple[int, int, int, int]]:
 
 
 def house_rects(lay: WorldLayout) -> list[tuple[int, int, int, int]]:
+    """Rects of the house body (the brown goal region)."""
     return _rects_of(house_cells(lay), lay.grid)
 
 
+# Alias kept for clarity at call sites that want the body explicitly.
+house_body_rects = house_rects
+
+
+def roof_rects(lay: WorldLayout) -> list[tuple[int, int, int, int]]:
+    return _rects_of(roof_cells(lay), lay.grid)
+
+
+def path_rects(lay: WorldLayout) -> list[tuple[int, int, int, int]]:
+    return _rects_of(path_cells(lay), lay.grid)
+
+
 def home_target_anchor(lay: WorldLayout) -> tuple[int, int]:
-    """A 2x2 anchor whose footprint lies inside the house (success/route target)."""
-    x0, y0, _x1, _y1 = lay.house
+    """A 2x2 anchor whose footprint lies inside the body (success/route target)."""
+    x0, y0, _x1, _y1 = lay.house_body
     return (x0, y0)
 
 
 def in_home(anchor: tuple[int, int], lay: WorldLayout) -> bool:
-    """True iff a 2x2 footprint at *anchor* lies entirely within the house."""
+    """True iff a 2x2 footprint at *anchor* lies entirely within the house body."""
     return set(footprint(anchor)) <= house_cells(lay)
 
 
@@ -206,16 +248,20 @@ def overlay_cells(lay: WorldLayout, tick: int, *, wallet_present: bool = True
                   ) -> list[tuple[int, int, int]]:
     """Coloured overlay (x, y, idx) for memory replay + the live render reference.
 
-    Order matters (later wins): roads, construction, crosswalk (recoloured),
-    grass (green field), house (brown, on top of grass), wallet. The house
-    paints over the grass so its brown is visible inside the green field. The
-    pedestrian is an AgentFrame, not here."""
+    Order matters (later wins): roads → barricade bars (striped orange/green) →
+    crosswalk (recoloured) → grass (green field) → driveway (gray) → roof (red) →
+    body (brown) → wallet. Roads already cover the construction middle as gray;
+    the bars paint striped ends on top. The gray driveway overrides grass; roof
+    and body paint the house silhouette over the lawn. The pedestrian is an
+    AgentFrame, not here."""
     cells: list[tuple[int, int, int]] = []
     cells += [(x, y, C_ROAD) for (x, y) in sorted(road_cells(lay))]
-    cells += [(x, y, C_CONSTR) for (x, y) in sorted(constr_cells(lay))]
+    cells += barricade_overlay(lay)
     lc = light_color(tick)
     cells += [(x, y, lc) for (x, y) in crosswalk_cells(lay)]
     cells += [(x, y, C_GRASS) for (x, y) in sorted(grass_cells(lay))]
+    cells += [(x, y, C_ROAD) for (x, y) in sorted(path_cells(lay))]
+    cells += [(x, y, C_ROOF) for (x, y) in sorted(roof_cells(lay))]
     cells += [(x, y, C_HOUSE) for (x, y) in sorted(house_cells(lay))]
     if wallet_present:
         cells.append((lay.wallet[0], lay.wallet[1], C_WALLET))

tests/scenarios/test_errand_world.py

@@ -1,10 +1,9 @@
-"""errand_world layout library: light cycle, two layouts, walls/roads/grass/house, BFS, personas."""
+"""errand_world: light cycle, two layouts, walls/roads/grass, house silhouette, barricade, BFS, personas."""
 import random
 from proteus.game.scenarios import errand_world as w
 
 
 def test_light_cycle_holds_six():
-    # RED for ticks 1..6, GREEN for 7..12, RED again at 13
     assert [w.is_red(t) for t in range(1, 14)] == [True]*6 + [False]*6 + [True]
     assert w.light_color(1) == w.C_RED and w.light_color(7) == w.C_GREEN
 
@@ -22,46 +21,74 @@ def test_session_choices_seed_deterministic_and_in_range():
     assert 0 <= ti < len(w.GAME_LAYOUT.spawns) and pid in w.PERSONAS
 
 
-def test_both_layouts_grass_house_passable():
+def test_house_silhouette_roof_above_body_and_walkable():
     for lay in (w.GAME_LAYOUT, w.MEMORY_LAYOUT):
         assert lay.grid == (64, 64)
-        grass = w.grass_cells(lay); house = w.house_cells(lay)
-        assert grass and house
+        roof = w.roof_cells(lay); body = w.house_cells(lay)
+        path = w.path_cells(lay); grass = w.grass_cells(lay)
+        assert roof and body and path and grass
+        # all four regions are disjoint (no colour double-paint)
+        assert roof.isdisjoint(body) and roof.isdisjoint(grass) and roof.isdisjoint(path)
+        assert body.isdisjoint(grass) and body.isdisjoint(path) and path.isdisjoint(grass)
         pas = w.passable_cells(lay); walls = w.wall_cells(lay)
-        assert grass <= pas and house <= pas            # both walkable
-        assert pas.isdisjoint(walls)
-        assert house.isdisjoint(w.road_cells(lay))      # house is its own (brown) region, not painted as road
-        # home target is a 2x2 inside the house
+        assert (roof | body | path) <= pas and pas.isdisjoint(walls)
+        # success target: a 2x2 anchor sits inside the brown body
         anc = w.home_target_anchor(lay)
-        assert w.in_home(anc, lay)
+        assert w.in_home(anc, lay) and set(w.footprint(anc)) <= body
+        # roof is a roof: at least one roof cell is directly above a body cell
+        assert any((x, y + 1) in body for (x, y) in roof), (lay.name, "roof not above body")
 
 
-def test_house_reachable_without_grass_and_grass_is_shortcut():
+def test_entrance_path_grass_free_route_and_grass_shortcut():
     for lay in (w.GAME_LAYOUT, w.MEMORY_LAYOUT):
         walls = w.wall_cells(lay)
         grass = frozenset(w.grass_cells(lay))
         anc = w.home_target_anchor(lay)
-        # (a) a grass-FREE path to the house exists from the single start
+        # the gray driveway is a road-coloured, NON-grass corridor to the house
+        path = w.path_cells(lay)
+        assert path and path.isdisjoint(grass)
+        # (a) a grass-FREE path to the house exists (via the driveway) from start + every spawn
         road_only = w.bfs_field(anc, w.AGENT, walls | grass, lay.grid)
-        assert lay.start in road_only, (lay.name, "no grass-free path to house")
+        assert lay.start in road_only, (lay.name, "no grass-free route to house")
         for sp in lay.spawns:
-            assert sp in road_only, (lay.name, "spawn has no grass-free path", sp)
-        # (b) allowing grass yields a STRICTLY shorter route from the start (grass = real shortcut)
+            assert sp in road_only, (lay.name, "spawn has no grass-free route", sp)
+        # (b) allowing grass yields a STRICTLY shorter route (cutting the lawn is a real shortcut)
         with_grass = w.bfs_field(anc, w.AGENT, walls, lay.grid)
         assert with_grass[lay.start] < road_only[lay.start], (lay.name, "grass is not a shortcut")
 
 
+def test_construction_is_a_passable_striped_barricade():
+    for lay in (w.GAME_LAYOUT, w.MEMORY_LAYOUT):
+        bars = w.constr_cells(lay)
+        assert bars and bars <= w.passable_cells(lay)        # barricade bars sit on the road (walkable)
+        # the bars are the two END columns of the construction rect (front & back)
+        x0, y0, x1, y1 = lay.construction
+        assert all(x in (x0, x1) for (x, y) in bars)
+        # striped: the barricade overlay uses BOTH orange and green
+        bidx = {i for (_x, _y, i) in w.barricade_overlay(lay)}
+        assert {w.C_CONSTR, w.C_GREEN} <= bidx
+        # still passable THROUGH (not fully blocked): the house is reachable from start
+        field = w.bfs_field(w.home_target_anchor(lay), w.AGENT, w.wall_cells(lay), lay.grid)
+        assert lay.start in field
+
+
+def test_overlay_paints_grass_path_house_barricade_world():
+    lay = w.MEMORY_LAYOUT
+    idxs = {i for (_x, _y, i) in w.overlay_cells(lay, tick=1, wallet_present=True)}
+    assert {w.C_ROAD, w.C_RED, w.C_CONSTR, w.C_GRASS, w.C_ROOF, w.C_HOUSE, w.C_WALLET} <= idxs
+    green = {i for (_x, _y, i) in w.overlay_cells(lay, tick=7, wallet_present=True)}
+    assert w.C_GREEN in green
+    assert w.C_WALLET not in {i for (_x, _y, i) in w.overlay_cells(lay, 1, wallet_present=False)}
+
+
 def test_pedestrian_flush_to_wall_and_passable_corridor():
     for lay in (w.GAME_LAYOUT, w.MEMORY_LAYOUT):
         walls = w.wall_cells(lay)
         ped_fp = frozenset(w.footprint(lay.pedestrian))
-        assert ped_fp <= w.passable_cells(lay)                  # ped sits on walkable road
-        # ped is flush against a wall: at least one ped cell has an orthogonally-adjacent wall
+        assert ped_fp <= w.passable_cells(lay)
         flush = any((x+dx, y+dy) in walls
                     for (x, y) in ped_fp for (dx, dy) in ((1,0),(-1,0),(0,1),(0,-1)))
         assert flush, (lay.name, "pedestrian not flush to a wall")
-        # a 2x2 courier can get past the ped WITHOUT touching it: treating the ped
-        # footprint as an obstacle, the home target is still reachable from start
         field = w.bfs_field(w.home_target_anchor(lay), w.AGENT, walls | ped_fp, lay.grid)
         assert lay.start in field, (lay.name, "cannot pass pedestrian without touching it")
 
@@ -71,21 +98,9 @@ def test_wallet_in_a_corner():
         walls = w.wall_cells(lay)
         wx, wy = lay.wallet
         assert (wx, wy) in w.passable_cells(lay)
-        # corner = walls (or grid edge) on two orthogonal sides
         def blocked(cx, cy):
             return not (0 <= cx < lay.grid[0] and 0 <= cy < lay.grid[1]) or (cx, cy) in walls
-        horiz = blocked(wx-1, wy) or blocked(wx+1, wy)
-        vert = blocked(wx, wy-1) or blocked(wx, wy+1)
-        assert horiz and vert, (lay.name, "wallet not in a corner")
-
-
-def test_overlay_paints_grass_house_and_world():
-    lay = w.MEMORY_LAYOUT
-    idxs = {i for (_x, _y, i) in w.overlay_cells(lay, tick=1, wallet_present=True)}
-    assert {w.C_ROAD, w.C_RED, w.C_CONSTR, w.C_GRASS, w.C_HOUSE, w.C_WALLET} <= idxs
-    green = {i for (_x, _y, i) in w.overlay_cells(lay, tick=7, wallet_present=True)}
-    assert w.C_GREEN in green                              # light green at tick 7
-    assert w.C_WALLET not in {i for (_x, _y, i) in w.overlay_cells(lay, 1, wallet_present=False)}
+        assert (blocked(wx-1, wy) or blocked(wx+1, wy)) and (blocked(wx, wy-1) or blocked(wx, wy+1))
 
 
 def test_step_toward_field_goal_offfield_and_tiebreak():