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

zombie_escape/export_images.py

@@ -41,7 +41,7 @@ from .render_assets import (
     resolve_wall_colors,
     RUBBLE_ROTATION_DEG,
 )
-from .colors import FALL_ZONE_FLOOR_PRIMARY
+from .colors import FALL_ZONE_FLOOR_PRIMARY, FALL_ZONE_FLOOR_SECONDARY
 from .render_constants import (
     FALLING_ZOMBIE_COLOR,
     PITFALL_ABYSS_COLOR,
@@ -67,14 +67,15 @@ def _ensure_pygame_ready() -> None:
         pygame.display.set_mode((1, 1), flags=flags)
 
 
-def _save_surface(surface: pygame.Surface, path: Path) -> None:
+def _save_surface(surface: pygame.Surface, path: Path, *, scale: int = 1) -> None:
+    if scale != 1:
+        width, height = surface.get_size()
+        surface = pygame.transform.scale(surface, (width * scale, height * scale))
     path.parent.mkdir(parents=True, exist_ok=True)
     pygame.image.save(surface, str(path))
 
 
-def _pick_directional_surface(
-    surfaces: list[pygame.Surface], *, bin_index: int = 0
-) -> pygame.Surface:
+def _pick_directional_surface(surfaces: list[pygame.Surface], *, bin_index: int = 0) -> pygame.Surface:
     if not surfaces:
         return pygame.Surface((1, 1), pygame.SRCALPHA)
     return surfaces[bin_index % len(surfaces)]
@@ -87,10 +88,7 @@ def _build_pitfall_tile(cell_size: int) -> pygame.Surface:
 
     for i in range(PITFALL_SHADOW_WIDTH):
         t = i / (PITFALL_SHADOW_WIDTH - 1.0)
-        color = tuple(
-            int(PITFALL_SHADOW_RIM_COLOR[j] * (1.0 - t) + PITFALL_ABYSS_COLOR[j] * t)
-            for j in range(3)
-        )
+        color = tuple(int(PITFALL_SHADOW_RIM_COLOR[j] * (1.0 - t) + PITFALL_ABYSS_COLOR[j] * t) for j in range(3))
         pygame.draw.line(
             surface,
             color,
@@ -118,7 +116,7 @@ def _build_pitfall_tile(cell_size: int) -> pygame.Surface:
     return surface
 
 
-def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> list[Path]:
+def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE, output_scale: int = 4) -> list[Path]:
     _ensure_pygame_ready()
 
     saved: list[Path] = []
@@ -129,7 +127,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         bin_index=0,
     )
     player_path = out / "player.png"
-    _save_surface(player, player_path)
+    _save_surface(player, player_path, scale=output_scale)
     saved.append(player_path)
 
     zombie_base = _pick_directional_surface(
@@ -137,7 +135,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         bin_index=0,
     )
     zombie_normal_path = out / "zombie-normal.png"
-    _save_surface(zombie_base, zombie_normal_path)
+    _save_surface(zombie_base, zombie_normal_path, scale=output_scale)
     saved.append(zombie_normal_path)
 
     tracker = zombie_base.copy()
@@ -148,7 +146,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         color=ZOMBIE_NOSE_COLOR,
     )
     tracker_path = out / "zombie-tracker.png"
-    _save_surface(tracker, tracker_path)
+    _save_surface(tracker, tracker_path, scale=output_scale)
     saved.append(tracker_path)
 
     wall_hugging = zombie_base.copy()
@@ -159,7 +157,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         color=ZOMBIE_NOSE_COLOR,
     )
     wall_path = out / "zombie-wall.png"
-    _save_surface(wall_hugging, wall_path)
+    _save_surface(wall_hugging, wall_path, scale=output_scale)
     saved.append(wall_path)
 
     buddy = _pick_directional_surface(
@@ -171,7 +169,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         bin_index=0,
     )
     buddy_path = out / "buddy.png"
-    _save_surface(buddy, buddy_path)
+    _save_surface(buddy, buddy_path, scale=output_scale)
     saved.append(buddy_path)
 
     survivor = _pick_directional_surface(
@@ -183,7 +181,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         bin_index=0,
     )
     survivor_path = out / "survivor.png"
-    _save_surface(survivor, survivor_path)
+    _save_surface(survivor, survivor_path, scale=output_scale)
     saved.append(survivor_path)
 
     car_surface = build_car_surface(CAR_WIDTH, CAR_HEIGHT)
@@ -196,27 +194,27 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
     )
     car = _pick_directional_surface(build_car_directional_surfaces(car_surface), bin_index=0)
     car_path = out / "car.png"
-    _save_surface(car, car_path)
+    _save_surface(car, car_path, scale=output_scale)
     saved.append(car_path)
 
     fuel = build_fuel_can_surface(FUEL_CAN_WIDTH, FUEL_CAN_HEIGHT)
     fuel_path = out / "fuel.png"
-    _save_surface(fuel, fuel_path)
+    _save_surface(fuel, fuel_path, scale=output_scale)
     saved.append(fuel_path)
 
     flashlight = build_flashlight_surface(FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT)
     flashlight_path = out / "flashlight.png"
-    _save_surface(flashlight, flashlight_path)
+    _save_surface(flashlight, flashlight_path, scale=output_scale)
     saved.append(flashlight_path)
 
     shoes = build_shoes_surface(SHOES_WIDTH, SHOES_HEIGHT)
     shoes_path = out / "shoes.png"
-    _save_surface(shoes, shoes_path)
+    _save_surface(shoes, shoes_path, scale=output_scale)
     saved.append(shoes_path)
 
     beam = SteelBeam(0, 0, cell_size, health=STEEL_BEAM_HEALTH, palette=None)
     beam_path = out / "steel-beam.png"
-    _save_surface(beam.image, beam_path)
+    _save_surface(beam.image, beam_path, scale=output_scale)
     saved.append(beam_path)
 
     inner_wall = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
@@ -230,13 +228,13 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         fill_color=inner_fill,
         border_color=inner_border,
         bevel_depth=INTERNAL_WALL_BEVEL_DEPTH,
-        bevel_mask=(False, False, False, False),
-        draw_bottom_side=False,
+        bevel_mask=(True, True, True, True),
+        draw_bottom_side=True,
         bottom_side_ratio=0.1,
         side_shade_ratio=0.9,
     )
     inner_wall_path = out / "wall-inner.png"
-    _save_surface(inner_wall, inner_wall_path)
+    _save_surface(inner_wall, inner_wall_path, scale=output_scale)
     saved.append(inner_wall_path)
 
     rubble_wall = build_rubble_wall_surface(
@@ -246,7 +244,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         angle_deg=RUBBLE_ROTATION_DEG,
     )
     rubble_wall_path = out / "wall-rubble.png"
-    _save_surface(rubble_wall, rubble_wall_path)
+    _save_surface(rubble_wall, rubble_wall_path, scale=output_scale)
     saved.append(rubble_wall_path)
 
     outer_wall = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
@@ -260,18 +258,18 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         fill_color=outer_fill,
         border_color=outer_border,
         bevel_depth=0,
-        bevel_mask=(False, False, False, False),
-        draw_bottom_side=False,
+        bevel_mask=(True, True, True, True),
+        draw_bottom_side=True,
         bottom_side_ratio=0.1,
         side_shade_ratio=0.9,
     )
     outer_wall_path = out / "wall-outer.png"
-    _save_surface(outer_wall, outer_wall_path)
+    _save_surface(outer_wall, outer_wall_path, scale=output_scale)
     saved.append(outer_wall_path)
 
     pitfall = _build_pitfall_tile(cell_size)
     pitfall_path = out / "pitfall.png"
-    _save_surface(pitfall, pitfall_path)
+    _save_surface(pitfall, pitfall_path, scale=output_scale)
     saved.append(pitfall_path)
 
     fall_radius = max(1, int(ZOMBIE_RADIUS))
@@ -284,13 +282,21 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> li
         fall_radius,
     )
     falling_path = out / "falling-zombie.png"
-    _save_surface(falling, falling_path)
+    _save_surface(falling, falling_path, scale=output_scale)
     saved.append(falling_path)
 
-    fall_zone = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
-    fall_zone.fill(FALL_ZONE_FLOOR_PRIMARY)
+    fall_zone_size = cell_size * 2
+    fall_zone = pygame.Surface((fall_zone_size, fall_zone_size), pygame.SRCALPHA)
+    for y in range(2):
+        for x in range(2):
+            color = FALL_ZONE_FLOOR_SECONDARY if (x + y) % 2 == 0 else FALL_ZONE_FLOOR_PRIMARY
+            pygame.draw.rect(
+                fall_zone,
+                color,
+                (x * cell_size, y * cell_size, cell_size, cell_size),
+            )
     fall_zone_path = out / "fall-zone.png"
-    _save_surface(fall_zone, fall_zone_path)
+    _save_surface(fall_zone, fall_zone_path, scale=output_scale)
     saved.append(fall_zone_path)
 
     return saved

zombie_escape/gameplay/ambient.py

@@ -8,9 +8,7 @@ from ..colors import (
 from ..models import GameData
 
 
-def _set_ambient_palette(
-    game_data: GameData, key: str, *, force: bool = False
-) -> None:
+def _set_ambient_palette(game_data: GameData, key: str, *, force: bool = False) -> None:
     """Apply a named ambient palette to all walls in the level."""
 
     palette = get_environment_palette(key)
@@ -22,9 +20,7 @@ def _set_ambient_palette(
     _apply_palette_to_walls(game_data, palette, force=True)
 
 
-def sync_ambient_palette_with_flashlights(
-    game_data: GameData, *, force: bool = False
-) -> None:
+def sync_ambient_palette_with_flashlights(game_data: GameData, *, force: bool = False) -> None:
     """Sync the ambient palette with the player's flashlight inventory."""
 
     state = game_data.state

zombie_escape/gameplay/footprints.py

@@ -46,17 +46,14 @@ def update_footprints(game_data: GameData, config: dict[str, Any]) -> None:
     footprints = state.footprints
     if not player.in_car:
         last_pos = state.last_footprint_pos
-        dist_sq = (
-            (player.x - last_pos[0]) ** 2 + (player.y - last_pos[1]) ** 2
-            if last_pos
-            else None
-        )
-        if last_pos is None or (
-            dist_sq is not None
-            and dist_sq >= FOOTPRINT_STEP_DISTANCE * FOOTPRINT_STEP_DISTANCE
-        ):
-            footprints.append(Footprint(pos=(player.x, player.y), time=now))
-            state.last_footprint_pos = (player.x, player.y)
+        step_distance = FOOTPRINT_STEP_DISTANCE * 0.5
+        step_distance_sq = step_distance * step_distance
+        dist_sq = (player.x - last_pos[0]) ** 2 + (player.y - last_pos[1]) ** 2 if last_pos else None
+        if last_pos is None or (dist_sq is not None and dist_sq >= step_distance_sq):
+            pos = (int(player.x), int(player.y))
+            footprints.append(Footprint(pos=pos, time=now, visible=state.footprint_visible_toggle))
+            state.footprint_visible_toggle = not state.footprint_visible_toggle
+            state.last_footprint_pos = pos
 
     if len(footprints) > FOOTPRINT_MAX:
         footprints = footprints[-FOOTPRINT_MAX:]

zombie_escape/gameplay/interactions.py

@@ -44,6 +44,7 @@ def _interaction_radius(width: float, height: float) -> float:
     """Approximate interaction reach for a humanoid and an object."""
     return HUMANOID_RADIUS + (width + height) / 4
 
+
 RNG = get_rng()
 
 
@@ -71,9 +72,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
 
     car_interaction_radius = _interaction_radius(CAR_WIDTH, CAR_HEIGHT)
     fuel_interaction_radius = _interaction_radius(FUEL_CAN_WIDTH, FUEL_CAN_HEIGHT)
-    flashlight_interaction_radius = _interaction_radius(
-        FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT
-    )
+    flashlight_interaction_radius = _interaction_radius(FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT)
     shoes_interaction_radius = _interaction_radius(SHOES_WIDTH, SHOES_HEIGHT)
 
     def _rect_center_cell(rect: pygame.Rect) -> tuple[int, int] | None:
@@ -92,14 +91,8 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         dy = point[1] - player.y
         return dx * dx + dy * dy <= radius * radius
 
-    def _player_near_sprite(
-        sprite_obj: pygame.sprite.Sprite | None, radius: float
-    ) -> bool:
-        return bool(
-            sprite_obj
-            and sprite_obj.alive()
-            and _player_near_point(sprite_obj.rect.center, radius)
-        )
+    def _player_near_sprite(sprite_obj: pygame.sprite.Sprite | None, radius: float) -> bool:
+        return bool(sprite_obj and sprite_obj.alive() and _player_near_point(sprite_obj.rect.center, radius))
 
     def _player_near_car(car_obj: Car | None) -> bool:
         return _player_near_sprite(car_obj, car_interaction_radius)
@@ -120,9 +113,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         for flashlight in list(flashlights):
             if not flashlight.alive():
                 continue
-            if _player_near_point(
-                flashlight.rect.center, flashlight_interaction_radius
-            ):
+            if _player_near_point(flashlight.rect.center, flashlight_interaction_radius):
                 state.flashlight_count += 1
                 state.hint_expires_at = 0
                 state.hint_target_type = None
@@ -152,9 +143,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     sync_ambient_palette_with_flashlights(game_data)
 
     buddies = [
-        survivor
-        for survivor in survivor_group
-        if survivor.alive() and survivor.is_buddy and not survivor.rescued
+        survivor for survivor in survivor_group if survivor.alive() and survivor.is_buddy and not survivor.rescued
     ]
 
     # Buddy interactions (Stage 3)
@@ -164,20 +153,13 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                 continue
             buddy_on_screen = rect_visible_on_screen(camera, buddy.rect)
             if not player.in_car:
-                dist_to_player_sq = (player.x - buddy.x) ** 2 + (
-                    player.y - buddy.y
-                ) ** 2
-                if (
-                    dist_to_player_sq
-                    <= SURVIVOR_APPROACH_RADIUS * SURVIVOR_APPROACH_RADIUS
-                ):
+                dist_to_player_sq = (player.x - buddy.x) ** 2 + (player.y - buddy.y) ** 2
+                if dist_to_player_sq <= SURVIVOR_APPROACH_RADIUS * SURVIVOR_APPROACH_RADIUS:
                     buddy.set_following()
             elif player.in_car and active_car and shrunk_car:
                 g = pygame.sprite.Group()
                 g.add(buddy)
-                if pygame.sprite.spritecollide(
-                    shrunk_car, g, False, pygame.sprite.collide_circle
-                ):
+                if pygame.sprite.spritecollide(shrunk_car, g, False, pygame.sprite.collide_circle):
                     prospective_passengers = state.survivors_onboard + 1
                     capacity_limit = state.survivor_capacity
                     if prospective_passengers > capacity_limit:
@@ -191,9 +173,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                     buddy.kill()
                     continue
 
-            if buddy.alive() and pygame.sprite.spritecollide(
-                buddy, zombie_group, False, pygame.sprite.collide_circle
-            ):
+            if buddy.alive() and pygame.sprite.spritecollide(buddy, zombie_group, False, pygame.sprite.collide_circle):
                 if buddy_on_screen:
                     state.game_over_message = tr("game_over.scream")
                     state.game_over = True
@@ -203,18 +183,11 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                         new_cell = RNG.choice(walkable_cells)
                         buddy.teleport(_cell_center(new_cell))
                     else:
-                        buddy.teleport(
-                            (game_data.level_width // 2, game_data.level_height // 2)
-                        )
+                        buddy.teleport((game_data.level_width // 2, game_data.level_height // 2))
                     buddy.following = False
 
     # Player entering an active car already under control
-    if (
-        not player.in_car
-        and _player_near_car(active_car)
-        and active_car
-        and active_car.health > 0
-    ):
+    if not player.in_car and _player_near_car(active_car) and active_car and active_car.health > 0:
         if state.has_fuel:
             player.in_car = True
             all_sprites.remove(player)
@@ -258,9 +231,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     # Bonus: collide a parked car while driving to repair/extend capabilities
     if player.in_car and active_car and shrunk_car and waiting_cars:
         waiting_group = pygame.sprite.Group(waiting_cars)
-        collided_waiters = pygame.sprite.spritecollide(
-            shrunk_car, waiting_group, False, pygame.sprite.collide_rect
-        )
+        collided_waiters = pygame.sprite.spritecollide(shrunk_car, waiting_group, False, pygame.sprite.collide_rect)
         if collided_waiters:
             removed_any = False
             capacity_increments = 0
@@ -288,16 +259,8 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         if zombies_hit:
             active_car._take_damage(CAR_ZOMBIE_DAMAGE * len(zombies_hit))
 
-    if (
-        stage.rescue_stage
-        and player.in_car
-        and active_car
-        and shrunk_car
-        and survivor_group
-    ):
-        boarded = pygame.sprite.spritecollide(
-            shrunk_car, survivor_group, True, pygame.sprite.collide_circle
-        )
+    if stage.rescue_stage and player.in_car and active_car and shrunk_car and survivor_group:
+        boarded = pygame.sprite.spritecollide(shrunk_car, survivor_group, True, pygame.sprite.collide_circle)
         if boarded:
             state.survivors_onboard += len(boarded)
             apply_passenger_speed_penalty(game_data)
@@ -339,9 +302,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     # Player getting caught by zombies
     if not player.in_car and player in all_sprites:
         shrunk_player = get_shrunk_sprite(player, 0.8)
-        collisions = pygame.sprite.spritecollide(
-            shrunk_player, zombie_group, False, pygame.sprite.collide_circle
-        )
+        collisions = pygame.sprite.spritecollide(shrunk_player, zombie_group, False, pygame.sprite.collide_circle)
         if any(not zombie.carbonized for zombie in collisions):
             if not state.game_over:
                 state.game_over = True
@@ -367,9 +328,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         car_cell = _rect_center_cell(car.rect)
         if buddy_ready and car_cell is not None and car_cell in outside_cells:
             if stage.buddy_required_count > 0:
-                state.buddy_rescued = min(
-                    stage.buddy_required_count, state.buddy_onboard
-                )
+                state.buddy_rescued = min(stage.buddy_required_count, state.buddy_onboard)
             if stage.rescue_stage and state.survivors_onboard:
                 state.survivors_rescued += state.survivors_onboard
                 state.survivors_onboard = 0

zombie_escape/gameplay/layout.py

@@ -23,7 +23,6 @@ __all__ = ["generate_level_from_blueprint", "MapGenerationError"]
 RNG = get_rng()
 
 
-
 def _rect_for_cell(x_idx: int, y_idx: int, cell_size: int) -> pygame.Rect:
     return pygame.Rect(
         x_idx * cell_size,
@@ -53,9 +52,7 @@ def _expand_zone_cells(
     return cells
 
 
-def generate_level_from_blueprint(
-    game_data: GameData, config: dict[str, Any]
-) -> dict[str, list[pygame.Rect]]:
+def generate_level_from_blueprint(game_data: GameData, config: dict[str, Any]) -> dict[str, list[pygame.Rect]]:
     """Build walls/spawn candidates/outside area from a blueprint grid."""
     wall_group = game_data.groups.wall_group
     all_sprites = game_data.groups.all_sprites
@@ -69,7 +66,8 @@ def generate_level_from_blueprint(
         cols=stage.grid_cols,
         rows=stage.grid_rows,
         wall_algo=stage.wall_algorithm,
-        pitfall_density=getattr(stage, "pitfall_density", 0.0),
+        pitfall_density=stage.pitfall_density,
+        pitfall_zones=stage.pitfall_zones,
         base_seed=game_data.state.seed,
     )
     if isinstance(blueprint_data, dict):
@@ -81,23 +79,11 @@ def generate_level_from_blueprint(
         steel_cells_raw = set()
         car_reachable_cells = set()
 
-    steel_cells = (
-        {(int(x), int(y)) for x, y in steel_cells_raw} if steel_enabled else set()
-    )
+    steel_cells = {(int(x), int(y)) for x, y in steel_cells_raw} if steel_enabled else set()
     game_data.layout.car_walkable_cells = car_reachable_cells
     cell_size = game_data.cell_size
-    outer_wall_cells = {
-        (x, y)
-        for y, row in enumerate(blueprint)
-        for x, ch in enumerate(row)
-        if ch == "B"
-    }
-    wall_cells = {
-        (x, y)
-        for y, row in enumerate(blueprint)
-        for x, ch in enumerate(row)
-        if ch in {"B", "1"}
-    }
+    outer_wall_cells = {(x, y) for y, row in enumerate(blueprint) for x, ch in enumerate(row) if ch == "B"}
+    wall_cells = {(x, y) for y, row in enumerate(blueprint) for x, ch in enumerate(row) if ch in {"B", "1"}}
 
     def _has_wall(nx: int, ny: int) -> bool:
         if nx < 0 or ny < 0 or nx >= stage.grid_cols or ny >= stage.grid_rows:
@@ -119,7 +105,7 @@ def generate_level_from_blueprint(
     interior_max_y = stage.grid_rows - 3
     bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] = {}
     palette = get_environment_palette(game_data.state.ambient_palette_key)
-    rubble_ratio = max(0.0, min(1.0, getattr(stage, "wall_rubble_ratio", 0.0)))
+    rubble_ratio = max(0.0, min(1.0, stage.wall_rubble_ratio))
 
     def add_beam_to_groups(beam: SteelBeam) -> None:
         if beam._added_to_groups:
@@ -128,16 +114,16 @@ def generate_level_from_blueprint(
         all_sprites.add(beam, layer=0)
         beam._added_to_groups = True
 
-    def remove_wall_cell(cell: tuple[int, int]) -> None:
-        wall_cells.discard(cell)
+    def remove_wall_cell(cell: tuple[int, int], *, allow_walkable: bool = True) -> None:
+        if cell in wall_cells:
+            wall_cells.discard(cell)
+            if allow_walkable and cell not in walkable_cells:
+                walkable_cells.append(cell)
         outer_wall_cells.discard(cell)
 
     for y, row in enumerate(blueprint):
         if len(row) != stage.grid_cols:
-            raise ValueError(
-                "Blueprint width mismatch at row "
-                f"{y}: {len(row)} != {stage.grid_cols}"
-            )
+            raise ValueError(f"Blueprint width mismatch at row {y}: {len(row)} != {stage.grid_cols}")
         for x, ch in enumerate(row):
             cell_rect = _rect_for_cell(x, y, cell_size)
             cell_has_beam = steel_enabled and (x, y) in steel_cells
@@ -180,29 +166,17 @@ def generate_level_from_blueprint(
                     )
                 draw_bottom_side = not _has_wall(x, y + 1)
                 bevel_mask = (
-                    not _has_wall(x, y - 1)
-                    and not _has_wall(x - 1, y)
-                    and not _has_wall(x - 1, y - 1),
-                    not _has_wall(x, y - 1)
-                    and not _has_wall(x + 1, y)
-                    and not _has_wall(x + 1, y - 1),
-                    not _has_wall(x, y + 1)
-                    and not _has_wall(x + 1, y)
-                    and not _has_wall(x + 1, y + 1),
-                    not _has_wall(x, y + 1)
-                    and not _has_wall(x - 1, y)
-                    and not _has_wall(x - 1, y + 1),
+                    not _has_wall(x, y - 1) and not _has_wall(x - 1, y) and not _has_wall(x - 1, y - 1),
+                    not _has_wall(x, y - 1) and not _has_wall(x + 1, y) and not _has_wall(x + 1, y - 1),
+                    not _has_wall(x, y + 1) and not _has_wall(x + 1, y) and not _has_wall(x + 1, y + 1),
+                    not _has_wall(x, y + 1) and not _has_wall(x - 1, y) and not _has_wall(x - 1, y + 1),
                 )
                 if any(bevel_mask):
                     bevel_corners[(x, y)] = bevel_mask
                 wall_cell = (x, y)
                 use_rubble = rubble_ratio > 0 and random.random() < rubble_ratio
                 if use_rubble:
-                    rotation_deg = (
-                        RUBBLE_ROTATION_DEG
-                        if random.random() < 0.5
-                        else -RUBBLE_ROTATION_DEG
-                    )
+                    rotation_deg = RUBBLE_ROTATION_DEG if random.random() < 0.5 else -RUBBLE_ROTATION_DEG
                     wall = RubbleWall(
                         cell_rect.x,
                         cell_rect.y,
@@ -216,7 +190,7 @@ def generate_level_from_blueprint(
                         on_destroy=(
                             (
                                 lambda _w, b=beam, cell=wall_cell: (
-                                    remove_wall_cell(cell),
+                                    remove_wall_cell(cell, allow_walkable=False),
                                     add_beam_to_groups(b),
                                 )
                             )
@@ -238,7 +212,7 @@ def generate_level_from_blueprint(
                         on_destroy=(
                             (
                                 lambda _w, b=beam, cell=wall_cell: (
-                                    remove_wall_cell(cell),
+                                    remove_wall_cell(cell, allow_walkable=False),
                                     add_beam_to_groups(b),
                                 )
                             )

zombie_escape/gameplay/movement.py

@@ -211,11 +211,7 @@ def update_entities(
         if game_data.state.player_wall_target_ttl <= 0:
             game_data.state.player_wall_target_cell = None
 
-    wall_target_cell = (
-        game_data.state.player_wall_target_cell
-        if game_data.state.player_wall_target_ttl > 0
-        else None
-    )
+    wall_target_cell = game_data.state.player_wall_target_cell if game_data.state.player_wall_target_ttl > 0 else None
 
     update_survivors(
         game_data,
@@ -237,17 +233,11 @@ def update_entities(
             game_data.state.last_zombie_spawn_time = current_time
 
     # Update zombies
-    target_center = (
-        active_car.rect.center if player.in_car and active_car else player.rect.center
-    )
+    target_center = active_car.rect.center if player.in_car and active_car else player.rect.center
     buddies = [
-        survivor
-        for survivor in survivor_group
-        if survivor.alive() and survivor.is_buddy and not survivor.rescued
-    ]
-    buddies_on_screen = [
-        buddy for buddy in buddies if rect_visible_on_screen(camera, buddy.rect)
+        survivor for survivor in survivor_group if survivor.alive() and survivor.is_buddy and not survivor.rescued
     ]
+    buddies_on_screen = [buddy for buddy in buddies if rect_visible_on_screen(camera, buddy.rect)]
 
     survivors_on_screen: list[Survivor] = []
     if stage.rescue_stage:
@@ -279,13 +269,10 @@ def update_entities(
     for idx, zombie in enumerate(zombies_sorted):
         target = target_center
         if buddies_on_screen:
-            dist_to_target_sq = (target_center[0] - zombie.x) ** 2 + (
-                target_center[1] - zombie.y
-            ) ** 2
+            dist_to_target_sq = (target_center[0] - zombie.x) ** 2 + (target_center[1] - zombie.y) ** 2
             nearest_buddy = min(
                 buddies_on_screen,
-                key=lambda buddy: (buddy.rect.centerx - zombie.x) ** 2
-                + (buddy.rect.centery - zombie.y) ** 2,
+                key=lambda buddy: (buddy.rect.centerx - zombie.x) ** 2 + (buddy.rect.centery - zombie.y) ** 2,
             )
             dist_to_buddy_sq = (nearest_buddy.rect.centerx - zombie.x) ** 2 + (
                 nearest_buddy.rect.centery - zombie.y
@@ -305,8 +292,7 @@ def update_entities(
                 if candidate_positions:
                     target = min(
                         candidate_positions,
-                        key=lambda pos: (pos[0] - zombie.x) ** 2
-                        + (pos[1] - zombie.y) ** 2,
+                        key=lambda pos: (pos[0] - zombie.x) ** 2 + (pos[1] - zombie.y) ** 2,
                     )
         nearby_candidates = _nearby_zombies(idx)
         zombie_search_radius = ZOMBIE_WALL_HUG_SENSOR_DISTANCE + zombie.radius + 120