zombie-escape 1.13.1__py3-none-any.whl → 1.14.4__py3-none-any.whl

zombie_escape/gameplay/spawn.py

@@ -300,13 +300,8 @@ def _create_zombie(
         level_width = grid_cols * tile_size
         level_height = grid_rows * tile_size
         if hint_pos is not None:
-            points = [
-                random_position_outside_building(level_width, level_height)
-                for _ in range(5)
-            ]
-            points.sort(
-                key=lambda p: (p[0] - hint_pos[0]) ** 2 + (p[1] - hint_pos[1]) ** 2
-            )
+            points = [random_position_outside_building(level_width, level_height) for _ in range(5)]
+            points.sort(key=lambda p: (p[0] - hint_pos[0]) ** 2 + (p[1] - hint_pos[1]) ** 2)
             start_pos = points[0]
         else:
             start_pos = random_position_outside_building(level_width, level_height)
@@ -392,9 +387,7 @@ def _place_flashlight(
             continue
         if cars:
             if any(
-                (center[0] - parked.rect.centerx) ** 2
-                + (center[1] - parked.rect.centery) ** 2
-                < min_car_dist_sq
+                (center[0] - parked.rect.centerx) ** 2 + (center[1] - parked.rect.centery) ** 2 < min_car_dist_sq
                 for parked in cars
             ):
                 continue
@@ -431,9 +424,7 @@ def place_flashlights(
             break
         # Avoid clustering too tightly
         if any(
-            (other.rect.centerx - fl.rect.centerx) ** 2
-            + (other.rect.centery - fl.rect.centery) ** 2
-            < 120 * 120
+            (other.rect.centerx - fl.rect.centerx) ** 2 + (other.rect.centery - fl.rect.centery) ** 2 < 120 * 120
             for other in placed
         ):
             continue
@@ -469,9 +460,7 @@ def _place_shoes(
             continue
         if cars:
             if any(
-                (center[0] - parked.rect.centerx) ** 2
-                + (center[1] - parked.rect.centery) ** 2
-                < min_car_dist_sq
+                (center[0] - parked.rect.centerx) ** 2 + (center[1] - parked.rect.centery) ** 2 < min_car_dist_sq
                 for parked in cars
             ):
                 continue
@@ -507,9 +496,7 @@ def place_shoes(
         if not shoes:
             break
         if any(
-            (other.rect.centerx - shoes.rect.centerx) ** 2
-            + (other.rect.centery - shoes.rect.centery) ** 2
-            < 120 * 120
+            (other.rect.centerx - shoes.rect.centerx) ** 2 + (other.rect.centery - shoes.rect.centery) ** 2 < 120 * 120
             for other in placed
         ):
             continue
@@ -568,30 +555,20 @@ def place_new_car(
         temp_car = Car(c_x, c_y, appearance=appearance)
         temp_rect = temp_car.rect.inflate(30, 30)
         nearby_walls = pygame.sprite.Group()
-        nearby_walls.add(
-            [
-                w
-                for w in wall_group
-                if abs(w.rect.centerx - c_x) < 150 and abs(w.rect.centery - c_y) < 150
-            ]
-        )
+        nearby_walls.add([w for w in wall_group if abs(w.rect.centerx - c_x) < 150 and abs(w.rect.centery - c_y) < 150])
         collides_wall = spritecollideany_walls(temp_car, nearby_walls)
         collides_player = temp_rect.colliderect(player.rect.inflate(50, 50))
         car_overlap = False
         if existing_cars:
             car_overlap = any(
-                temp_car.rect.colliderect(other.rect)
-                for other in existing_cars
-                if other and other.alive()
+                temp_car.rect.colliderect(other.rect) for other in existing_cars if other and other.alive()
             )
         if not collides_wall and not collides_player and not car_overlap:
             return temp_car
     return None
 
 
-def spawn_survivors(
-    game_data: GameData, layout_data: Mapping[str, list[tuple[int, int]]]
-) -> list[Survivor]:
+def spawn_survivors(game_data: GameData, layout_data: Mapping[str, list[tuple[int, int]]]) -> list[Survivor]:
     """Populate rescue-stage survivors and buddy-stage buddies."""
     survivors: list[Survivor] = []
     if not (game_data.stage.rescue_stage or game_data.stage.buddy_required_count > 0):
@@ -671,9 +648,7 @@ def setup_player_and_cars(
         RNG.shuffle(car_candidates)
         for candidate in car_candidates:
             center = _cell_center(candidate, cell_size)
-            if (center[0] - player_pos[0]) ** 2 + (
-                center[1] - player_pos[1]
-            ) ** 2 >= 400 * 400:
+            if (center[0] - player_pos[0]) ** 2 + (center[1] - player_pos[1]) ** 2 >= 400 * 400:
                 car_candidates.remove(candidate)
                 return center
         choice = car_candidates.pop()
@@ -803,9 +778,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
     return None
 
 
-def maintain_waiting_car_supply(
-    game_data: GameData, *, minimum: int | None = None
-) -> None:
+def maintain_waiting_car_supply(game_data: GameData, *, minimum: int | None = None) -> None:
     """Ensure a baseline count of parked cars exists."""
     target = 1 if minimum is None else max(0, minimum)
     current = len(_alive_waiting_cars(game_data))
@@ -839,8 +812,7 @@ def nearest_waiting_car(game_data: GameData, origin: tuple[float, float]) -> Car
         return None
     return min(
         cars,
-        key=lambda car: (car.rect.centerx - origin[0]) ** 2
-        + (car.rect.centery - origin[1]) ** 2,
+        key=lambda car: (car.rect.centerx - origin[0]) ** 2 + (car.rect.centery - origin[1]) ** 2,
     )
 
 

zombie_escape/gameplay/state.py

@@ -28,6 +28,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         overview_created=False,
         footprints=[],
         last_footprint_pos=None,
+        footprint_visible_toggle=True,
         elapsed_play_ms=0,
         has_fuel=starts_with_fuel,
         flashlight_count=initial_flashlights,

zombie_escape/gameplay/survivors.py

@@ -63,9 +63,7 @@ def update_survivors(
         )
 
     # Gently prevent survivors from overlapping the player or each other
-    def _separate_from_point(
-        survivor: Survivor, point: tuple[float, float], min_dist: float
-    ) -> None:
+    def _separate_from_point(survivor: Survivor, point: tuple[float, float], min_dist: float) -> None:
         dx = point[0] - survivor.x
         dy = point[1] - survivor.y
         dist = math.hypot(dx, dy)
@@ -86,9 +84,7 @@ def update_survivors(
     for survivor in survivors:
         _separate_from_point(survivor, player_point, player_overlap)
 
-    survivors_with_x = sorted(
-        ((survivor.x, survivor) for survivor in survivors), key=lambda item: item[0]
-    )
+    survivors_with_x = sorted(((survivor.x, survivor) for survivor in survivors), key=lambda item: item[0])
     for i, (base_x, survivor) in enumerate(survivors_with_x):
         for other_base_x, other in survivors_with_x[i + 1 :]:
             if other_base_x - base_x > survivor_overlap:
@@ -112,10 +108,7 @@ def update_survivors(
                 other.rect.center = (int(other.x), int(other.y))
 
 
-
-def calculate_car_speed_for_passengers(
-    passengers: int, *, capacity: int = SURVIVOR_MAX_SAFE_PASSENGERS
-) -> float:
+def calculate_car_speed_for_passengers(passengers: int, *, capacity: int = SURVIVOR_MAX_SAFE_PASSENGERS) -> float:
     cap = max(1, capacity)
     load_ratio = max(0.0, passengers / cap)
     penalty = SURVIVOR_SPEED_PENALTY_PER_PASSENGER * load_ratio
@@ -196,9 +189,7 @@ def random_survivor_conversion_line(stage_id: str) -> str:
 
 def cleanup_survivor_messages(state: ProgressState) -> None:
     now = pygame.time.get_ticks()
-    state.survivor_messages = [
-        msg for msg in state.survivor_messages if msg.get("expires_at", 0) > now
-    ]
+    state.survivor_messages = [msg for msg in state.survivor_messages if msg.get("expires_at", 0) > now]
 
 
 def drop_survivors_from_car(game_data: GameData, origin: tuple[int, int]) -> None:
@@ -234,9 +225,7 @@ def drop_survivors_from_car(game_data: GameData, origin: tuple[int, int]) -> Non
     apply_passenger_speed_penalty(game_data)
 
 
-def handle_survivor_zombie_collisions(
-    game_data: GameData, config: dict[str, Any]
-) -> None:
+def handle_survivor_zombie_collisions(game_data: GameData, config: dict[str, Any]) -> None:
     if not game_data.stage.rescue_stage:
         return
     survivor_group = game_data.groups.survivor_group

zombie_escape/gameplay/utils.py

@@ -105,12 +105,8 @@ def find_nearby_offscreen_spawn_position(
             SCREEN_HEIGHT,
         )
         view_rect.inflate_ip(SCREEN_WIDTH, SCREEN_HEIGHT)
-    min_distance_sq = (
-        None if min_player_dist is None else min_player_dist * min_player_dist
-    )
-    max_distance_sq = (
-        None if max_player_dist is None else max_player_dist * max_player_dist
-    )
+    min_distance_sq = None if min_player_dist is None else min_player_dist * min_player_dist
+    max_distance_sq = None if max_player_dist is None else max_player_dist * max_player_dist
     for _ in range(max(1, attempts)):
         cell_x, cell_y = RNG.choice(walkable_cells)
         jitter_extent = cell_size * 0.35
@@ -120,9 +116,7 @@ def find_nearby_offscreen_spawn_position(
             int((cell_x * cell_size) + (cell_size / 2) + jitter_x),
             int((cell_y * cell_size) + (cell_size / 2) + jitter_y),
         )
-        if player is not None and (
-            min_distance_sq is not None or max_distance_sq is not None
-        ):
+        if player is not None and (min_distance_sq is not None or max_distance_sq is not None):
             dx = candidate[0] - player.x
             dy = candidate[1] - player.y
             dist_sq = dx * dx + dy * dy
@@ -174,10 +168,7 @@ def find_exterior_spawn_position(
 ) -> tuple[int, int]:
     if hint_pos is None:
         return random_position_outside_building(level_width, level_height)
-    points = [
-        random_position_outside_building(level_width, level_height)
-        for _ in range(max(1, attempts))
-    ]
+    points = [random_position_outside_building(level_width, level_height) for _ in range(max(1, attempts))]
     return min(
         points,
         key=lambda pos: (pos[0] - hint_pos[0]) ** 2 + (pos[1] - hint_pos[1]) ** 2,

zombie_escape/input_utils.py

@@ -24,9 +24,7 @@ CONTROLLER_BUTTON_DPAD_RIGHT = getattr(pygame, "CONTROLLER_BUTTON_DPAD_RIGHT", N
 CONTROLLER_BUTTON_RB = getattr(pygame, "CONTROLLER_BUTTON_RIGHTSHOULDER", None)
 CONTROLLER_AXIS_LEFTX = getattr(pygame, "CONTROLLER_AXIS_LEFTX", None)
 CONTROLLER_AXIS_LEFTY = getattr(pygame, "CONTROLLER_AXIS_LEFTY", None)
-CONTROLLER_AXIS_TRIGGERRIGHT = getattr(
-    pygame, "CONTROLLER_AXIS_TRIGGERRIGHT", None
-)
+CONTROLLER_AXIS_TRIGGERRIGHT = getattr(pygame, "CONTROLLER_AXIS_TRIGGERRIGHT", None)
 
 
 def init_first_controller() -> pygame.controller.Controller | None:
@@ -65,10 +63,7 @@ def is_confirm_event(event: pygame.event.Event) -> bool:
 
 def is_start_event(event: pygame.event.Event) -> bool:
     if CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN:
-        return (
-            CONTROLLER_BUTTON_START is not None
-            and event.button == CONTROLLER_BUTTON_START
-        )
+        return CONTROLLER_BUTTON_START is not None and event.button == CONTROLLER_BUTTON_START
     if event.type == pygame.JOYBUTTONDOWN:
         return event.button == JOY_BUTTON_START
     return False
@@ -76,10 +71,7 @@ def is_start_event(event: pygame.event.Event) -> bool:
 
 def is_select_event(event: pygame.event.Event) -> bool:
     if CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN:
-        return (
-            CONTROLLER_BUTTON_BACK is not None
-            and event.button == CONTROLLER_BUTTON_BACK
-        )
+        return CONTROLLER_BUTTON_BACK is not None and event.button == CONTROLLER_BUTTON_BACK
     if event.type == pygame.JOYBUTTONDOWN:
         return event.button == JOY_BUTTON_BACK
     return False
@@ -102,25 +94,13 @@ def read_gamepad_move(
             x = 0.0
         if abs(y) < deadzone:
             y = 0.0
-        if (
-            CONTROLLER_BUTTON_DPAD_LEFT is not None
-            and controller.get_button(CONTROLLER_BUTTON_DPAD_LEFT)
-        ):
+        if CONTROLLER_BUTTON_DPAD_LEFT is not None and controller.get_button(CONTROLLER_BUTTON_DPAD_LEFT):
             x = -1.0
-        elif (
-            CONTROLLER_BUTTON_DPAD_RIGHT is not None
-            and controller.get_button(CONTROLLER_BUTTON_DPAD_RIGHT)
-        ):
+        elif CONTROLLER_BUTTON_DPAD_RIGHT is not None and controller.get_button(CONTROLLER_BUTTON_DPAD_RIGHT):
             x = 1.0
-        if (
-            CONTROLLER_BUTTON_DPAD_UP is not None
-            and controller.get_button(CONTROLLER_BUTTON_DPAD_UP)
-        ):
+        if CONTROLLER_BUTTON_DPAD_UP is not None and controller.get_button(CONTROLLER_BUTTON_DPAD_UP):
             y = -1.0
-        elif (
-            CONTROLLER_BUTTON_DPAD_DOWN is not None
-            and controller.get_button(CONTROLLER_BUTTON_DPAD_DOWN)
-        ):
+        elif CONTROLLER_BUTTON_DPAD_DOWN is not None and controller.get_button(CONTROLLER_BUTTON_DPAD_DOWN):
             y = 1.0
         return x, y
 
@@ -149,10 +129,7 @@ def is_accel_active(
     if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
         return True
     if controller and controller.get_init():
-        if (
-            CONTROLLER_BUTTON_RB is not None
-            and controller.get_button(CONTROLLER_BUTTON_RB)
-        ):
+        if CONTROLLER_BUTTON_RB is not None and controller.get_button(CONTROLLER_BUTTON_RB):
             return True
         if CONTROLLER_AXIS_TRIGGERRIGHT is not None:
             if controller.get_axis(CONTROLLER_AXIS_TRIGGERRIGHT) > DEADZONE:

zombie_escape/level_blueprints.py

@@ -2,18 +2,21 @@
 
 from collections import deque
 
+from .level_constants import (
+    DEFAULT_GRID_WIRE_WALL_LINES,
+    DEFAULT_SPARSE_WALL_DENSITY,
+    DEFAULT_STEEL_BEAM_CHANCE,
+    DEFAULT_WALL_LINES,
+)
 from .rng import get_rng, seed_rng
 
 EXITS_PER_SIDE = 1  # currently fixed to 1 per side (can be tuned)
-NUM_WALL_LINES = 80  # reduced density (roughly 1/5 of previous 450)
 WALL_MIN_LEN = 3
 WALL_MAX_LEN = 10
-SPARSE_WALL_DENSITY = 0.10
 SPAWN_MARGIN = 3  # keep spawns away from walls/edges
 SPAWN_ZOMBIES = 3
 
 RNG = get_rng()
-STEEL_BEAM_CHANCE = 0.02
 
 
 class MapGenerationError(Exception):
@@ -168,6 +171,7 @@ def _place_exits(grid: list[list[str]], exits_per_side: int) -> None:
 def _place_walls_default(
     grid: list[list[str]],
     *,
+    line_count: int = DEFAULT_WALL_LINES,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
     cols, rows = len(grid[0]), len(grid)
@@ -177,7 +181,7 @@ def _place_walls_default(
     if forbidden_cells:
         forbidden |= forbidden_cells
 
-    for _ in range(NUM_WALL_LINES):
+    for _ in range(line_count):
         length = rng(WALL_MIN_LEN, WALL_MAX_LEN)
         horizontal = RNG.choice([True, False])
         if horizontal:
@@ -210,6 +214,7 @@ def _place_walls_empty(
 def _place_walls_grid_wire(
     grid: list[list[str]],
     *,
+    line_count: int = DEFAULT_GRID_WIRE_WALL_LINES,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
     """
@@ -230,8 +235,7 @@ def _place_walls_grid_wire(
     grid_v = [["." for _ in range(cols)] for _ in range(rows)]
     grid_h = [["." for _ in range(cols)] for _ in range(rows)]
 
-    # Use a similar density to default.
-    lines_per_pass = int(NUM_WALL_LINES * 0.7)
+    lines_per_pass = line_count
 
     # --- Pass 1: Vertical Walls (on grid_v) ---
     for _ in range(lines_per_pass):
@@ -239,24 +243,28 @@ def _place_walls_grid_wire(
         x = rng(2, cols - 3)
         y = rng(2, rows - 2 - length)
 
+        # Reject if the new segment would connect end-to-end with another vertical segment.
         can_place = True
-        for i in range(length):
-            cy = y + i
-            # 1. Global forbidden check (exits, outer walls in main grid)
-            if (x, cy) in forbidden:
-                can_place = False
-                break
-            if grid[cy][x] not in (".",):
-                can_place = False
-                break
-            # 2. Local self-overlap check
-            if grid_v[cy][x] != ".":
-                can_place = False
-                break
-            # 3. Parallel adjacency check (only against other vertical walls)
-            if grid_v[cy][x - 1] == "1" or grid_v[cy][x + 1] == "1":
-                can_place = False
-                break
+        if grid_v[y - 1][x] == "1" or grid_v[y + length][x] == "1":
+            can_place = False
+        else:
+            for i in range(length):
+                cy = y + i
+                # 1. Global forbidden check (exits, outer walls in main grid)
+                if (x, cy) in forbidden:
+                    can_place = False
+                    break
+                if grid[cy][x] not in (".",):
+                    can_place = False
+                    break
+                # 2. Local self-overlap check
+                if grid_v[cy][x] != ".":
+                    can_place = False
+                    break
+                # 3. Parallel adjacency check (only against other vertical walls)
+                if grid_v[cy][x - 1] == "1" or grid_v[cy][x + 1] == "1":
+                    can_place = False
+                    break
 
         if can_place:
             for i in range(length):
@@ -268,24 +276,28 @@ def _place_walls_grid_wire(
         x = rng(2, cols - 2 - length)
         y = rng(2, rows - 3)
 
+        # Reject if the new segment would connect end-to-end with another horizontal segment.
         can_place = True
-        for i in range(length):
-            cx = x + i
-            # 1. Global forbidden check
-            if (cx, y) in forbidden:
-                can_place = False
-                break
-            if grid[y][cx] not in (".",):
-                can_place = False
-                break
-            # 2. Local self-overlap check
-            if grid_h[y][cx] != ".":
-                can_place = False
-                break
-            # 3. Parallel adjacency check (only against other horizontal walls)
-            if grid_h[y - 1][cx] == "1" or grid_h[y + 1][cx] == "1":
-                can_place = False
-                break
+        if grid_h[y][x - 1] == "1" or grid_h[y][x + length] == "1":
+            can_place = False
+        else:
+            for i in range(length):
+                cx = x + i
+                # 1. Global forbidden check
+                if (cx, y) in forbidden:
+                    can_place = False
+                    break
+                if grid[y][cx] not in (".",):
+                    can_place = False
+                    break
+                # 2. Local self-overlap check
+                if grid_h[y][cx] != ".":
+                    can_place = False
+                    break
+                # 3. Parallel adjacency check (only against other horizontal walls)
+                if grid_h[y - 1][cx] == "1" or grid_h[y + 1][cx] == "1":
+                    can_place = False
+                    break
 
         if can_place:
             for i in range(length):
@@ -302,7 +314,7 @@ def _place_walls_grid_wire(
 def _place_walls_sparse_moore(
     grid: list[list[str]],
     *,
-    density: float = SPARSE_WALL_DENSITY,
+    density: float = DEFAULT_SPARSE_WALL_DENSITY,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
     """Place isolated wall tiles at a low density, avoiding adjacency."""
@@ -335,7 +347,7 @@ def _place_walls_sparse_moore(
 def _place_walls_sparse_ortho(
     grid: list[list[str]],
     *,
-    density: float = SPARSE_WALL_DENSITY,
+    density: float = DEFAULT_SPARSE_WALL_DENSITY,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
     """Place isolated wall tiles at a low density, avoiding orthogonal adjacency."""
@@ -351,15 +363,11 @@ def _place_walls_sparse_ortho(
                 continue
             if RNG.random() >= density:
                 continue
-            if (
-                grid[y - 1][x] == "1"
-                or grid[y + 1][x] == "1"
-                or grid[y][x - 1] == "1"
-                or grid[y][x + 1] == "1"
-            ):
+            if grid[y - 1][x] == "1" or grid[y + 1][x] == "1" or grid[y][x - 1] == "1" or grid[y][x + 1] == "1":
                 continue
             grid[y][x] = "1"
 
+
 WALL_ALGORITHMS = {
     "default": _place_walls_default,
     "empty": _place_walls_empty,
@@ -372,7 +380,7 @@ WALL_ALGORITHMS = {
 def _place_steel_beams(
     grid: list[list[str]],
     *,
-    chance: float = STEEL_BEAM_CHANCE,
+    chance: float = DEFAULT_STEEL_BEAM_CHANCE,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> set[tuple[int, int]]:
     """Pick individual cells for steel beams, avoiding exits and their neighbors."""
@@ -396,16 +404,32 @@ def _place_pitfalls(
     grid: list[list[str]],
     *,
     density: float,
+    pitfall_zones: list[tuple[int, int, int, int]] | None = None,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
     """Replace empty floor tiles with pitfalls based on density."""
-    if density <= 0.0:
-        return
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
     if forbidden_cells:
         forbidden |= forbidden_cells
 
+    if pitfall_zones:
+        for col, row, width, height in pitfall_zones:
+            if width <= 0 or height <= 0:
+                continue
+            start_x = max(0, col)
+            start_y = max(0, row)
+            end_x = min(cols, col + width)
+            end_y = min(rows, row + height)
+            for y in range(start_y, end_y):
+                for x in range(start_x, end_x):
+                    if (x, y) in forbidden:
+                        continue
+                    if grid[y][x] == ".":
+                        grid[y][x] = "x"
+
+    if density <= 0.0:
+        return
     for y in range(1, rows - 1):
         for x in range(1, cols - 1):
             if (x, y) in forbidden:
@@ -443,6 +467,7 @@ def _generate_random_blueprint(
     rows: int,
     wall_algo: str = "default",
     pitfall_density: float = 0.0,
+    pitfall_zones: list[tuple[int, int, int, int]] | None = None,
 ) -> dict:
     grid = _init_grid(cols, rows)
     _place_exits(grid, EXITS_PER_SIDE)
@@ -476,18 +501,14 @@ def _generate_random_blueprint(
         reserved_cells.add((sx, sy))
 
     # Select and run the wall placement algorithm (after reserving spawns)
-    sparse_density = SPARSE_WALL_DENSITY
+    sparse_density = DEFAULT_SPARSE_WALL_DENSITY
+    wall_line_count = DEFAULT_WALL_LINES
     original_wall_algo = wall_algo
     if wall_algo == "sparse":
-        print(
-            "WARNING: 'sparse' is deprecated. Use 'sparse_moore' instead."
-        )
+        print("WARNING: 'sparse' is deprecated. Use 'sparse_moore' instead.")
         wall_algo = "sparse_moore"
     elif wall_algo.startswith("sparse."):
-        print(
-            "WARNING: 'sparse.<int>%' is deprecated. Use "
-            "'sparse_moore.<int>%' instead."
-        )
+        print("WARNING: 'sparse.<int>%' is deprecated. Use 'sparse_moore.<int>%' instead.")
         suffix = wall_algo[len("sparse.") :]
         wall_algo = "sparse_moore"
         if suffix.endswith("%") and suffix[:-1].isdigit():
@@ -505,16 +526,37 @@ def _generate_random_blueprint(
                 "'sparse_moore.<int>%' or 'sparse_ortho.<int>%'. "
                 f"Got '{original_wall_algo}'. Falling back to default sparse density."
             )
+    if wall_algo.startswith("default.") or wall_algo.startswith("grid_wire."):
+        base, suffix = wall_algo.split(".", 1)
+        base_line_count = DEFAULT_WALL_LINES if base == "default" else DEFAULT_GRID_WIRE_WALL_LINES
+        if suffix.endswith("%") and suffix[:-1].isdigit():
+            percent = int(suffix[:-1])
+            if 0 <= percent <= 200:
+                wall_line_count = int(base_line_count * (percent / 100.0))
+                wall_algo = base
+            else:
+                print(
+                    "WARNING: Wall line density must be 0-200%. "
+                    f"Got '{suffix}'. Falling back to default line count."
+                )
+                wall_algo = base
+        else:
+            print(
+                "WARNING: Invalid wall line format. Use "
+                "'default.<int>%' or 'grid_wire.<int>%'. "
+                f"Got '{wall_algo}'. Falling back to default line count."
+            )
+            wall_algo = base
     if wall_algo.startswith("sparse_moore.") or wall_algo.startswith("sparse_ortho."):
         base, suffix = wall_algo.split(".", 1)
         if suffix.endswith("%") and suffix[:-1].isdigit():
             percent = int(suffix[:-1])
-            if 0 <= percent <= 100:
+            if 0 <= percent <= 200:
                 sparse_density = percent / 100.0
                 wall_algo = base
             else:
                 print(
-                    "WARNING: Sparse wall density must be 0-100%. "
+                    "WARNING: Sparse wall density must be 0-200%. "
                     f"Got '{suffix}'. Falling back to default sparse density."
                 )
                 wall_algo = base
@@ -527,27 +569,26 @@ def _generate_random_blueprint(
             wall_algo = base
 
     if wall_algo not in WALL_ALGORITHMS:
-        print(
-            f"WARNING: Unknown wall algorithm '{wall_algo}'. Falling back to 'default'."
-        )
+        print(f"WARNING: Unknown wall algorithm '{wall_algo}'. Falling back to 'default'.")
         wall_algo = "default"
 
     # Place pitfalls BEFORE walls so walls avoid them (consistent with spawn reservation)
     _place_pitfalls(
         grid,
         density=pitfall_density,
+        pitfall_zones=pitfall_zones,
         forbidden_cells=reserved_cells,
     )
 
     algo_func = WALL_ALGORITHMS[wall_algo]
     if wall_algo in {"sparse_moore", "sparse_ortho"}:
         algo_func(grid, density=sparse_density, forbidden_cells=reserved_cells)
+    elif wall_algo in {"default", "grid_wire"}:
+        algo_func(grid, line_count=wall_line_count, forbidden_cells=reserved_cells)
     else:
         algo_func(grid, forbidden_cells=reserved_cells)
 
-    steel_beams = _place_steel_beams(
-        grid, chance=steel_chance, forbidden_cells=reserved_cells
-    )
+    steel_beams = _place_steel_beams(grid, chance=steel_chance, forbidden_cells=reserved_cells)
 
     blueprint_rows = ["".join(row) for row in grid]
     return {"grid": blueprint_rows, "steel_cells": steel_beams}
@@ -560,14 +601,15 @@ def choose_blueprint(
     rows: int,
     wall_algo: str = "default",
     pitfall_density: float = 0.0,
+    pitfall_zones: list[tuple[int, int, int, int]] | None = None,
     base_seed: int | None = None,
 ) -> dict:
     # Currently only random generation; hook for future variants.
     steel_conf = config.get("steel_beams", {})
     try:
-        steel_chance = float(steel_conf.get("chance", STEEL_BEAM_CHANCE))
+        steel_chance = float(steel_conf.get("chance", DEFAULT_STEEL_BEAM_CHANCE))
     except (TypeError, ValueError):
-        steel_chance = STEEL_BEAM_CHANCE
+        steel_chance = DEFAULT_STEEL_BEAM_CHANCE
 
     for attempt in range(20):
         if base_seed is not None:
@@ -579,6 +621,7 @@ def choose_blueprint(
             rows=rows,
             wall_algo=wall_algo,
             pitfall_density=pitfall_density,
+            pitfall_zones=pitfall_zones,
         )
 
         car_reachable = validate_connectivity(blueprint["grid"])

zombie_escape/level_constants.py

@@ -5,9 +5,17 @@ from __future__ import annotations
 DEFAULT_GRID_COLS = 48
 DEFAULT_GRID_ROWS = 30
 DEFAULT_TILE_SIZE = 50  # world units per cell; adjust to scale the whole map
+DEFAULT_WALL_LINES = 80  # reduced density (roughly 1/5 of previous 450)
+DEFAULT_GRID_WIRE_WALL_LINES = int(DEFAULT_WALL_LINES * 0.7)
+DEFAULT_SPARSE_WALL_DENSITY = 0.10
+DEFAULT_STEEL_BEAM_CHANCE = 0.02
 
 __all__ = [
     "DEFAULT_GRID_COLS",
     "DEFAULT_GRID_ROWS",
     "DEFAULT_TILE_SIZE",
+    "DEFAULT_WALL_LINES",
+    "DEFAULT_GRID_WIRE_WALL_LINES",
+    "DEFAULT_SPARSE_WALL_DENSITY",
+    "DEFAULT_STEEL_BEAM_CHANCE",
 ]