zombie-escape 1.10.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

zombie_escape/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.10.0"
+__version__ = "1.12.0"

zombie_escape/colors.py

@@ -72,37 +72,39 @@ _DEFAULT_ENVIRONMENT_PALETTE = EnvironmentPalette(
 # Dark, desaturated palette that sells the "alone without a flashlight" vibe.
 _GLOOM_ENVIRONMENT_PALETTE = EnvironmentPalette(
     floor_primary=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.floor_primary, brightness=0.725, saturation=0.675
+        _DEFAULT_ENVIRONMENT_PALETTE.floor_primary, brightness=0.8, saturation=0.75
     ),
     floor_secondary=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.floor_secondary, brightness=0.74, saturation=0.65
+        _DEFAULT_ENVIRONMENT_PALETTE.floor_secondary, brightness=0.8, saturation=0.75
     ),
     fall_zone_primary=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.fall_zone_primary,
-        brightness=0.725,
-        saturation=0.675,
+        brightness=0.8,
+        saturation=0.75,
     ),
     fall_zone_secondary=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.fall_zone_secondary,
-        brightness=0.74,
-        saturation=0.65,
+        brightness=0.8,
+        saturation=0.75,
     ),
     outside=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.outside, brightness=0.7, saturation=0.625
+        _DEFAULT_ENVIRONMENT_PALETTE.outside, brightness=0.8, saturation=0.75
     ),
     inner_wall=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall, brightness=0.775, saturation=0.7
+        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall, brightness=0.8, saturation=0.75
     ),
     inner_wall_border=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall_border, brightness=0.775, saturation=0.7
+        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall_border,
+        brightness=0.8,
+        saturation=0.75,
     ),
     outer_wall=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.outer_wall, brightness=0.75, saturation=0.675
+        _DEFAULT_ENVIRONMENT_PALETTE.outer_wall, brightness=0.8, saturation=0.75
     ),
     outer_wall_border=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.outer_wall_border,
-        brightness=0.75,
-        saturation=0.675,
+        brightness=0.8,
+        saturation=0.75,
     ),
 )
 

zombie_escape/entities.py

@@ -26,6 +26,8 @@ from .entities_constants import (
     FLASHLIGHT_WIDTH,
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
     INTERNAL_WALL_BEVEL_DEPTH,
     INTERNAL_WALL_HEALTH,
     PLAYER_RADIUS,
@@ -63,6 +65,7 @@ from .render_assets import (
     build_car_surface,
     build_flashlight_surface,
     build_fuel_can_surface,
+    build_shoes_surface,
     build_player_surface,
     build_survivor_surface,
     build_zombie_surface,
@@ -1589,6 +1592,15 @@ class Flashlight(pygame.sprite.Sprite):
         self.rect = self.image.get_rect(center=(x, y))
 
 
+class Shoes(pygame.sprite.Sprite):
+    """Shoes pickup that boosts the player's move speed when collected."""
+
+    def __init__(self: Self, x: int, y: int) -> None:
+        super().__init__()
+        self.image = build_shoes_surface(SHOES_WIDTH, SHOES_HEIGHT)
+        self.rect = self.image.get_rect(center=(x, y))
+
+
 def _car_body_radius(width: float, height: float) -> float:
     """Approximate car collision radius using only its own dimensions."""
     return min(width, height) / 2
@@ -1604,5 +1616,6 @@ __all__ = [
     "Car",
     "FuelCan",
     "Flashlight",
+    "Shoes",
     "random_position_outside_building",
 ]

zombie_escape/entities_constants.py

@@ -20,8 +20,12 @@ SURVIVOR_MAX_SAFE_PASSENGERS = 5
 SURVIVOR_MIN_SPEED_FACTOR = 0.35
 
 # --- Flashlight settings ---
-FLASHLIGHT_WIDTH = 10
-FLASHLIGHT_HEIGHT = 8
+FLASHLIGHT_WIDTH = 12
+FLASHLIGHT_HEIGHT = 10
+
+# --- Shoes settings ---
+SHOES_WIDTH = 14
+SHOES_HEIGHT = 12
 
 # --- Zombie settings ---
 ZOMBIE_RADIUS = HUMANOID_RADIUS
@@ -50,7 +54,7 @@ CAR_HEIGHT = 25
 CAR_SPEED = 2
 CAR_HEALTH = 20
 CAR_WALL_DAMAGE = 1
-FUEL_CAN_WIDTH = 11
+FUEL_CAN_WIDTH = 12
 FUEL_CAN_HEIGHT = 15
 
 # --- Wall and beam settings ---
@@ -74,6 +78,8 @@ __all__ = [
     "SURVIVOR_MIN_SPEED_FACTOR",
     "FLASHLIGHT_WIDTH",
     "FLASHLIGHT_HEIGHT",
+    "SHOES_WIDTH",
+    "SHOES_HEIGHT",
     "ZOMBIE_RADIUS",
     "ZOMBIE_SPEED",
     "ZOMBIE_WANDER_INTERVAL_MS",

zombie_escape/gameplay/__init__.py

@@ -14,6 +14,7 @@ from .spawn import (
     place_flashlights,
     place_fuel_can,
     place_new_car,
+    place_shoes,
     setup_player_and_cars,
     spawn_exterior_zombie,
     spawn_initial_zombies,
@@ -46,6 +47,7 @@ __all__ = [
     "place_new_car",
     "place_fuel_can",
     "place_flashlights",
+    "place_shoes",
     "place_buddies",
     "find_interior_spawn_positions",
     "find_nearby_offscreen_spawn_position",

zombie_escape/gameplay/interactions.py

@@ -12,6 +12,8 @@ from ..entities_constants import (
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
     HUMANOID_RADIUS,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
     SURVIVOR_APPROACH_RADIUS,
     SURVIVOR_MAX_SAFE_PASSENGERS,
 )
@@ -58,6 +60,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     outside_rects = game_data.layout.outside_rects
     fuel = game_data.fuel
     flashlights = game_data.flashlights or []
+    shoes_list = game_data.shoes or []
     camera = game_data.camera
     stage = game_data.stage
     maintain_waiting_car_supply(game_data)
@@ -70,6 +73,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     flashlight_interaction_radius = _interaction_radius(
         FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT
     )
+    shoes_interaction_radius = _interaction_radius(SHOES_WIDTH, SHOES_HEIGHT)
 
     def _player_near_point(point: tuple[float, float], radius: float) -> bool:
         dx = point[0] - player.x
@@ -118,6 +122,21 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                 print("Flashlight acquired!")
                 break
 
+        for shoes in list(shoes_list):
+            if not shoes.alive():
+                continue
+            if _player_near_point(shoes.rect.center, shoes_interaction_radius):
+                state.shoes_count += 1
+                state.hint_expires_at = 0
+                state.hint_target_type = None
+                shoes.kill()
+                try:
+                    shoes_list.remove(shoes)
+                except ValueError:
+                    pass
+                print("Shoes acquired!")
+                break
+
     sync_ambient_palette_with_flashlights(game_data)
 
     buddies = [

zombie_escape/gameplay/layout.py

@@ -10,9 +10,12 @@ from ..entities_constants import INTERNAL_WALL_HEALTH, STEEL_BEAM_HEALTH
 from .constants import OUTER_WALL_HEALTH
 from ..level_blueprints import choose_blueprint
 from ..models import GameData
+from ..rng import get_rng
 
 __all__ = ["generate_level_from_blueprint"]
 
+RNG = get_rng()
+
 
 def _rect_for_cell(x_idx: int, y_idx: int, cell_size: int) -> pygame.Rect:
     return pygame.Rect(
@@ -94,6 +97,10 @@ def generate_level_from_blueprint(
     player_cells: list[pygame.Rect] = []
     car_cells: list[pygame.Rect] = []
     zombie_cells: list[pygame.Rect] = []
+    interior_min_x = 2
+    interior_max_x = stage.grid_cols - 3
+    interior_min_y = 2
+    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)
 
@@ -214,11 +221,25 @@ def generate_level_from_blueprint(
     game_data.layout.walkable_cells = walkable_cells
     game_data.layout.outer_wall_cells = outer_wall_cells
     game_data.layout.wall_cells = wall_cells
-    game_data.layout.fall_spawn_cells = _expand_zone_cells(
+    fall_spawn_cells = _expand_zone_cells(
         stage.fall_spawn_zones,
         grid_cols=stage.grid_cols,
         grid_rows=stage.grid_rows,
     )
+    floor_ratio = max(0.0, min(1.0, stage.fall_spawn_floor_ratio))
+    if floor_ratio > 0.0 and interior_min_x <= interior_max_x:
+        for y in range(interior_min_y, interior_max_y + 1):
+            for x in range(interior_min_x, interior_max_x + 1):
+                if RNG.random() < floor_ratio:
+                    fall_spawn_cells.add((x, y))
+        if not fall_spawn_cells:
+            fall_spawn_cells.add(
+                (
+                    RNG.randint(interior_min_x, interior_max_x),
+                    RNG.randint(interior_min_y, interior_max_y),
+                )
+            )
+    game_data.layout.fall_spawn_cells = fall_spawn_cells
     game_data.layout.bevel_corners = bevel_corners
 
     return {

zombie_escape/gameplay/movement.py

@@ -17,6 +17,10 @@ from ..entities_constants import (
     ZOMBIE_SEPARATION_DISTANCE,
     ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
 )
+from ..gameplay_constants import (
+    SHOES_SPEED_MULTIPLIER_ONE,
+    SHOES_SPEED_MULTIPLIER_TWO,
+)
 from ..models import GameData
 from ..world_grid import WallIndex, apply_tile_edge_nudge, walls_for_radius
 from .constants import MAX_ZOMBIES
@@ -29,6 +33,7 @@ def process_player_input(
     keys: Sequence[bool],
     player: Player,
     car: Car | None,
+    shoes_count: int = 0,
     pad_input: tuple[float, float] = (0.0, 0.0),
 ) -> tuple[float, float, float, float]:
     """Process keyboard input and return movement deltas."""
@@ -55,7 +60,7 @@ def process_player_input(
                 (dy_input / move_len) * target_speed,
             )
     elif not player.in_car:
-        target_speed = PLAYER_SPEED
+        target_speed = PLAYER_SPEED * _shoes_speed_multiplier(shoes_count)
         move_len = math.hypot(dx_input, dy_input)
         if move_len > 0:
             player_dx, player_dy = (
@@ -66,6 +71,15 @@ def process_player_input(
     return player_dx, player_dy, car_dx, car_dy
 
 
+def _shoes_speed_multiplier(shoes_count: int) -> float:
+    count = max(0, int(shoes_count))
+    if count >= 2:
+        return SHOES_SPEED_MULTIPLIER_TWO
+    if count == 1:
+        return SHOES_SPEED_MULTIPLIER_ONE
+    return 1.0
+
+
 def update_entities(
     game_data: GameData,
     player_dx: float,

zombie_escape/gameplay/spawn.py

@@ -9,6 +9,7 @@ from ..entities import (
     Flashlight,
     FuelCan,
     Player,
+    Shoes,
     Survivor,
     Zombie,
     random_position_outside_building,
@@ -21,10 +22,17 @@ from ..entities_constants import (
     ZOMBIE_AGING_DURATION_FRAMES,
     ZOMBIE_SPEED,
 )
-from ..gameplay_constants import DEFAULT_FLASHLIGHT_SPAWN_COUNT
+from ..gameplay_constants import (
+    DEFAULT_FLASHLIGHT_SPAWN_COUNT,
+    DEFAULT_SHOES_SPAWN_COUNT,
+)
 from ..level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS, DEFAULT_TILE_SIZE
 from ..models import DustRing, FallingZombie, GameData, Stage
-from ..render_constants import FLASHLIGHT_FOG_SCALE_STEP, FOG_RADIUS_SCALE
+from ..render_constants import (
+    FLASHLIGHT_FOG_SCALE_ONE,
+    FLASHLIGHT_FOG_SCALE_TWO,
+    FOG_RADIUS_SCALE,
+)
 from ..rng import get_rng
 from .constants import (
     MAX_ZOMBIES,
@@ -46,6 +54,7 @@ __all__ = [
     "place_new_car",
     "place_fuel_can",
     "place_flashlights",
+    "place_shoes",
     "place_buddies",
     "spawn_survivors",
     "setup_player_and_cars",
@@ -94,7 +103,12 @@ def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
 
 def _fov_radius_for_flashlights(flashlight_count: int) -> float:
     count = max(0, int(flashlight_count))
-    scale = FOG_RADIUS_SCALE + max(0.0, FLASHLIGHT_FOG_SCALE_STEP) * count
+    if count <= 0:
+        scale = FOG_RADIUS_SCALE
+    elif count == 1:
+        scale = FLASHLIGHT_FOG_SCALE_ONE
+    else:
+        scale = FLASHLIGHT_FOG_SCALE_TWO
     return FOV_RADIUS * scale
 
 
@@ -301,6 +315,7 @@ def place_fuel_can(
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
     count: int = 1,
 ) -> FuelCan | None:
     """Pick a spawn spot for the fuel can away from the player (and car if given)."""
@@ -314,6 +329,8 @@ def place_fuel_can(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
+        if reserved_centers and cell.center in reserved_centers:
+            continue
         dx = cell.centerx - player.x
         dy = cell.centery - player.y
         if dx * dx + dy * dy < min_player_dist_sq:
@@ -339,6 +356,7 @@ def _place_flashlight(
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
 ) -> Flashlight | None:
     """Pick a spawn spot for the flashlight away from the player (and car if given)."""
     if not walkable_cells:
@@ -351,6 +369,8 @@ def _place_flashlight(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
+        if reserved_centers and cell.center in reserved_centers:
+            continue
         dx = cell.centerx - player.x
         dy = cell.centery - player.y
         if dx * dx + dy * dy < min_player_dist_sq:
@@ -374,6 +394,7 @@ def place_flashlights(
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
     count: int = DEFAULT_FLASHLIGHT_SPAWN_COUNT,
 ) -> list[Flashlight]:
     """Spawn multiple flashlights using the single-place helper to spread them out."""
@@ -382,7 +403,9 @@ def place_flashlights(
     max_attempts = max(200, count * 80)
     while len(placed) < count and attempts < max_attempts:
         attempts += 1
-        fl = _place_flashlight(walkable_cells, player, cars=cars)
+        fl = _place_flashlight(
+            walkable_cells, player, cars=cars, reserved_centers=reserved_centers
+        )
         if not fl:
             break
         # Avoid clustering too tightly
@@ -397,6 +420,74 @@ def place_flashlights(
     return placed
 
 
+def _place_shoes(
+    walkable_cells: list[pygame.Rect],
+    player: Player,
+    *,
+    cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
+) -> Shoes | None:
+    """Pick a spawn spot for the shoes away from the player (and car if given)."""
+    if not walkable_cells:
+        return None
+
+    min_player_dist = 240
+    min_car_dist = 200
+    min_player_dist_sq = min_player_dist * min_player_dist
+    min_car_dist_sq = min_car_dist * min_car_dist
+
+    for _ in range(200):
+        cell = RNG.choice(walkable_cells)
+        if reserved_centers and cell.center in reserved_centers:
+            continue
+        dx = cell.centerx - player.x
+        dy = cell.centery - player.y
+        if dx * dx + dy * dy < min_player_dist_sq:
+            continue
+        if cars:
+            if any(
+                (cell.centerx - parked.rect.centerx) ** 2
+                + (cell.centery - parked.rect.centery) ** 2
+                < min_car_dist_sq
+                for parked in cars
+            ):
+                continue
+        return Shoes(cell.centerx, cell.centery)
+
+    cell = RNG.choice(walkable_cells)
+    return Shoes(cell.centerx, cell.centery)
+
+
+def place_shoes(
+    walkable_cells: list[pygame.Rect],
+    player: Player,
+    *,
+    cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
+    count: int = DEFAULT_SHOES_SPAWN_COUNT,
+) -> list[Shoes]:
+    """Spawn multiple shoes using the single-place helper to spread them out."""
+    placed: list[Shoes] = []
+    attempts = 0
+    max_attempts = max(200, count * 80)
+    while len(placed) < count and attempts < max_attempts:
+        attempts += 1
+        shoes = _place_shoes(
+            walkable_cells, player, cars=cars, reserved_centers=reserved_centers
+        )
+        if not shoes:
+            break
+        if any(
+            (other.rect.centerx - shoes.rect.centerx) ** 2
+            + (other.rect.centery - shoes.rect.centery) ** 2
+            < 120 * 120
+            for other in placed
+        ):
+            continue
+        placed.append(shoes)
+    return placed
+
+
 def place_buddies(
     walkable_cells: list[pygame.Rect],
     player: Player,

zombie_escape/gameplay/state.py

@@ -31,6 +31,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         elapsed_play_ms=0,
         has_fuel=starts_with_fuel,
         flashlight_count=initial_flashlights,
+        shoes_count=0,
         ambient_palette_key=initial_palette_key,
         hint_expires_at=0,
         hint_target_type=None,
@@ -100,6 +101,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         level_height=level_height,
         fuel=None,
         flashlights=[],
+        shoes=[],
     )
 
 

zombie_escape/gameplay_constants.py

@@ -13,6 +13,11 @@ SURVIVOR_SPAWN_RATE = 0.07
 # --- Flashlight settings ---
 DEFAULT_FLASHLIGHT_SPAWN_COUNT = 2
 
+# --- Shoes settings ---
+DEFAULT_SHOES_SPAWN_COUNT = 0
+SHOES_SPEED_MULTIPLIER_ONE = 1.176
+SHOES_SPEED_MULTIPLIER_TWO = 1.25
+
 # --- Zombie settings ---
 ZOMBIE_SPAWN_DELAY_MS = 4000
 
@@ -25,6 +30,9 @@ __all__ = [
     "SURVIVAL_FAKE_CLOCK_RATIO",
     "SURVIVOR_SPAWN_RATE",
     "DEFAULT_FLASHLIGHT_SPAWN_COUNT",
+    "DEFAULT_SHOES_SPAWN_COUNT",
+    "SHOES_SPEED_MULTIPLIER_ONE",
+    "SHOES_SPEED_MULTIPLIER_TWO",
     "ZOMBIE_SPAWN_DELAY_MS",
     "CAR_HINT_DELAY_MS_DEFAULT",
 ]

zombie_escape/level_blueprints.py

@@ -84,11 +84,17 @@ def _place_exits(grid: list[list[str]], exits_per_side: int) -> None:
             grid[y][x] = "E"
 
 
-def _place_walls_default(grid: list[list[str]]) -> None:
+def _place_walls_default(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     cols, rows = len(grid[0]), len(grid)
     rng = RNG.randint
-    # Avoid placing walls adjacent to exits: collect forbidden cells (exits + neighbors)
+    # Avoid placing walls adjacent to exits and on reserved cells.
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
 
     for _ in range(NUM_WALL_LINES):
         length = rng(WALL_MIN_LEN, WALL_MAX_LEN)
@@ -111,12 +117,20 @@ def _place_walls_default(grid: list[list[str]]) -> None:
                     grid[y + i][x] = "1"
 
 
-def _place_walls_empty(grid: list[list[str]]) -> None:
+def _place_walls_empty(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     """Place no internal walls (open floor plan)."""
-    pass
+    _ = (grid, forbidden_cells)
 
 
-def _place_walls_grid_wire(grid: list[list[str]]) -> None:
+def _place_walls_grid_wire(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     """
     Place walls using a 2-pass approach with independent layers.
     Vertical and horizontal walls are generated on separate grids to ensure
@@ -127,6 +141,8 @@ def _place_walls_grid_wire(grid: list[list[str]]) -> None:
     cols, rows = len(grid[0]), len(grid)
     rng = RNG.randint
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
 
     # Temporary grids for independent generation
     # They only track the internal walls ("1").
@@ -202,10 +218,16 @@ def _place_walls_grid_wire(grid: list[list[str]]) -> None:
                 grid[y][x] = "1"
 
 
-def _place_walls_sparse(grid: list[list[str]]) -> None:
+def _place_walls_sparse(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     """Place isolated wall tiles at a low density, avoiding adjacency."""
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
     for y in range(2, rows - 2):
         for x in range(2, cols - 2):
             if (x, y) in forbidden:
@@ -237,11 +259,16 @@ WALL_ALGORITHMS = {
 
 
 def _place_steel_beams(
-    grid: list[list[str]], *, chance: float = STEEL_BEAM_CHANCE
+    grid: list[list[str]],
+    *,
+    chance: float = 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."""
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
     beams: set[tuple[int, int]] = set()
     for y in range(2, rows - 2):
         for x in range(2, cols - 2):
@@ -257,7 +284,6 @@ def _place_steel_beams(
 def _pick_empty_cell(
     grid: list[list[str]],
     margin: int,
-    forbidden: set[tuple[int, int]],
 ) -> tuple[int, int]:
     cols, rows = len(grid[0]), len(grid)
     attempts = 0
@@ -265,12 +291,12 @@ def _pick_empty_cell(
         attempts += 1
         x = RNG.randint(margin, cols - margin - 1)
         y = RNG.randint(margin, rows - margin - 1)
-        if grid[y][x] == "." and (x, y) not in forbidden:
+        if grid[y][x] == ".":
             return x, y
     # Fallback: scan for any acceptable cell
     for y in range(margin, rows - margin):
         for x in range(margin, cols - margin):
-            if grid[y][x] == "." and (x, y) not in forbidden:
+            if grid[y][x] == ".":
                 return x, y
     return cols // 2, rows // 2
 
@@ -281,7 +307,20 @@ def _generate_random_blueprint(
     grid = _init_grid(cols, rows)
     _place_exits(grid, EXITS_PER_SIDE)
 
-    # Select and run the wall placement algorithm
+    # Spawns: player, car, zombies
+    reserved_cells: set[tuple[int, int]] = set()
+    px, py = _pick_empty_cell(grid, SPAWN_MARGIN)
+    grid[py][px] = "P"
+    reserved_cells.add((px, py))
+    cx, cy = _pick_empty_cell(grid, SPAWN_MARGIN)
+    grid[cy][cx] = "C"
+    reserved_cells.add((cx, cy))
+    for _ in range(SPAWN_ZOMBIES):
+        zx, zy = _pick_empty_cell(grid, SPAWN_MARGIN)
+        grid[zy][zx] = "Z"
+        reserved_cells.add((zx, zy))
+
+    # Select and run the wall placement algorithm (after reserving spawns)
     if wall_algo not in WALL_ALGORITHMS:
         print(
             f"WARNING: Unknown wall algorithm '{wall_algo}'. Falling back to 'default'."
@@ -289,18 +328,11 @@ def _generate_random_blueprint(
         wall_algo = "default"
 
     algo_func = WALL_ALGORITHMS[wall_algo]
-    algo_func(grid)
-
-    steel_beams = _place_steel_beams(grid, chance=steel_chance)
+    algo_func(grid, forbidden_cells=reserved_cells)
 
-    # Spawns: player, car, zombies
-    px, py = _pick_empty_cell(grid, SPAWN_MARGIN, forbidden=steel_beams)
-    grid[py][px] = "P"
-    cx, cy = _pick_empty_cell(grid, SPAWN_MARGIN, forbidden=steel_beams)
-    grid[cy][cx] = "C"
-    for _ in range(SPAWN_ZOMBIES):
-        zx, zy = _pick_empty_cell(grid, SPAWN_MARGIN, forbidden=steel_beams)
-        grid[zy][zx] = "Z"
+    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}

zombie_escape/locales/ui.en.json

@@ -118,7 +118,15 @@
       },
       "stage13": {
         "name": "#13 Rescue Buddy 3",
-        "description": "Rescue your buddy. Zombies may fall from above."
+        "description": "Rescue your buddy. Falling zombies."
+      },
+      "stage14": {
+        "name": "#14 Falling Factory",
+        "description": "A factory with collapsed upper floors. Break through obstacles."
+      },
+      "stage15": {
+        "name": "#15 The Divide",
+        "description": "A central hazard splits the building. Cross with care."
       }
     },
     "status": {