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

zombie_escape/entities_constants.py

@@ -13,6 +13,13 @@ BUDDY_RADIUS = HUMANOID_RADIUS
 BUDDY_FOLLOW_SPEED = PLAYER_SPEED * 0.7
 HUMANOID_WALL_BUMP_FRAMES = 7
 
+# --- Jump settings ---
+PLAYER_JUMP_RANGE = 15  # px (enough to clear one 50px tile)
+SURVIVOR_JUMP_RANGE = int(PLAYER_JUMP_RANGE * 0.7)  # px
+JUMP_DURATION_MS = 200
+JUMP_SCALE_MAX = 0.15
+JUMP_SHADOW_OFFSET = 5
+
 # --- Survivor settings (Stage 4) ---
 SURVIVOR_RADIUS = HUMANOID_RADIUS
 SURVIVOR_APPROACH_RADIUS = 48
@@ -39,15 +46,20 @@ ZOMBIE_SEPARATION_DISTANCE = ZOMBIE_RADIUS * 2.2
 ZOMBIE_AGING_DURATION_FRAMES = FPS * 60 * 6  # ~6 minutes at target framerate
 ZOMBIE_AGING_MIN_SPEED_RATIO = 0.3
 ZOMBIE_TRACKER_SCENT_RADIUS = 70
-ZOMBIE_TRACKER_SCAN_RADIUS_MULTIPLIER = 2
+ZOMBIE_TRACKER_FAR_SCENT_RADIUS = 140
+ZOMBIE_TRACKER_NEWER_FOOTPRINT_MS = 5000
 ZOMBIE_TRACKER_SCENT_TOP_K = 3
 ZOMBIE_TRACKER_SCAN_INTERVAL_MS = int(1000 * 30 / FPS)
 ZOMBIE_TRACKER_WANDER_INTERVAL_MS = 2500
-ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE = 24
-ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG = 45
-ZOMBIE_WALL_FOLLOW_PROBE_STEP = 2.0
-ZOMBIE_WALL_FOLLOW_TARGET_GAP = 4.0
-ZOMBIE_WALL_FOLLOW_LOST_WALL_MS = 2500
+ZOMBIE_TRACKER_CROWD_BAND_WIDTH = 50
+ZOMBIE_TRACKER_CROWD_BAND_LENGTH = 50
+ZOMBIE_TRACKER_CROWD_COUNT = 5
+ZOMBIE_TRACKER_RELOCK_DELAY_MS = 3000
+ZOMBIE_WALL_HUG_SENSOR_DISTANCE = 24
+ZOMBIE_WALL_HUG_PROBE_ANGLE_DEG = 45
+ZOMBIE_WALL_HUG_PROBE_STEP = 2.0
+ZOMBIE_WALL_HUG_TARGET_GAP = 4.0
+ZOMBIE_WALL_HUG_LOST_WALL_MS = 2500
 
 # --- Car and fuel settings ---
 CAR_WIDTH = 16
@@ -93,15 +105,20 @@ __all__ = [
     "ZOMBIE_AGING_DURATION_FRAMES",
     "ZOMBIE_AGING_MIN_SPEED_RATIO",
     "ZOMBIE_TRACKER_SCENT_RADIUS",
-    "ZOMBIE_TRACKER_SCAN_RADIUS_MULTIPLIER",
+    "ZOMBIE_TRACKER_FAR_SCENT_RADIUS",
+    "ZOMBIE_TRACKER_NEWER_FOOTPRINT_MS",
     "ZOMBIE_TRACKER_SCENT_TOP_K",
     "ZOMBIE_TRACKER_SCAN_INTERVAL_MS",
     "ZOMBIE_TRACKER_WANDER_INTERVAL_MS",
-    "ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE",
-    "ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG",
-    "ZOMBIE_WALL_FOLLOW_PROBE_STEP",
-    "ZOMBIE_WALL_FOLLOW_TARGET_GAP",
-    "ZOMBIE_WALL_FOLLOW_LOST_WALL_MS",
+    "ZOMBIE_TRACKER_CROWD_BAND_WIDTH",
+    "ZOMBIE_TRACKER_CROWD_BAND_LENGTH",
+    "ZOMBIE_TRACKER_CROWD_COUNT",
+    "ZOMBIE_TRACKER_RELOCK_DELAY_MS",
+    "ZOMBIE_WALL_HUG_SENSOR_DISTANCE",
+    "ZOMBIE_WALL_HUG_PROBE_ANGLE_DEG",
+    "ZOMBIE_WALL_HUG_PROBE_STEP",
+    "ZOMBIE_WALL_HUG_TARGET_GAP",
+    "ZOMBIE_WALL_HUG_LOST_WALL_MS",
     "CAR_WIDTH",
     "CAR_HEIGHT",
     "CAR_SPEED",

zombie_escape/export_images.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+import pygame
+
+from .entities import SteelBeam
+from .entities_constants import (
+    BUDDY_RADIUS,
+    CAR_HEIGHT,
+    CAR_WIDTH,
+    FLASHLIGHT_HEIGHT,
+    FLASHLIGHT_WIDTH,
+    FUEL_CAN_HEIGHT,
+    FUEL_CAN_WIDTH,
+    INTERNAL_WALL_BEVEL_DEPTH,
+    PLAYER_RADIUS,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
+    STEEL_BEAM_HEALTH,
+    SURVIVOR_RADIUS,
+    ZOMBIE_RADIUS,
+)
+from .level_constants import DEFAULT_TILE_SIZE
+from .render_assets import (
+    build_car_directional_surfaces,
+    build_car_surface,
+    build_flashlight_surface,
+    build_fuel_can_surface,
+    build_player_directional_surfaces,
+    build_rubble_wall_surface,
+    build_shoes_surface,
+    build_survivor_directional_surfaces,
+    build_zombie_directional_surfaces,
+    draw_humanoid_hand,
+    draw_humanoid_nose,
+    paint_car_surface,
+    paint_wall_surface,
+    resolve_car_color,
+    resolve_wall_colors,
+    RUBBLE_ROTATION_DEG,
+)
+from .colors import FALL_ZONE_FLOOR_PRIMARY
+from .render_constants import (
+    FALLING_ZOMBIE_COLOR,
+    PITFALL_ABYSS_COLOR,
+    PITFALL_EDGE_DEPTH_OFFSET,
+    PITFALL_EDGE_METAL_COLOR,
+    PITFALL_EDGE_STRIPE_COLOR,
+    PITFALL_EDGE_STRIPE_SPACING,
+    PITFALL_SHADOW_RIM_COLOR,
+    PITFALL_SHADOW_WIDTH,
+    ZOMBIE_NOSE_COLOR,
+)
+
+__all__ = ["export_images"]
+
+
+def _ensure_pygame_ready() -> None:
+    if not pygame.get_init():
+        pygame.init()
+    if not pygame.display.get_init():
+        pygame.display.init()
+    if pygame.display.get_surface() is None:
+        flags = pygame.HIDDEN if hasattr(pygame, "HIDDEN") else 0
+        pygame.display.set_mode((1, 1), flags=flags)
+
+
+def _save_surface(surface: pygame.Surface, path: Path) -> None:
+    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:
+    if not surfaces:
+        return pygame.Surface((1, 1), pygame.SRCALPHA)
+    return surfaces[bin_index % len(surfaces)]
+
+
+def _build_pitfall_tile(cell_size: int) -> pygame.Surface:
+    surface = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    rect = surface.get_rect()
+    pygame.draw.rect(surface, PITFALL_ABYSS_COLOR, rect)
+
+    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)
+        )
+        pygame.draw.line(
+            surface,
+            color,
+            (rect.x + i, rect.y),
+            (rect.x + i, rect.bottom - 1),
+        )
+        pygame.draw.line(
+            surface,
+            color,
+            (rect.right - 1 - i, rect.y),
+            (rect.right - 1 - i, rect.bottom - 1),
+        )
+
+    edge_height = max(1, INTERNAL_WALL_BEVEL_DEPTH - PITFALL_EDGE_DEPTH_OFFSET)
+    pygame.draw.rect(surface, PITFALL_EDGE_METAL_COLOR, (rect.x, rect.y, rect.w, edge_height))
+    for sx in range(rect.x - edge_height, rect.right, PITFALL_EDGE_STRIPE_SPACING):
+        pygame.draw.line(
+            surface,
+            PITFALL_EDGE_STRIPE_COLOR,
+            (max(rect.x, sx), rect.y),
+            (min(rect.right - 1, sx + edge_height), rect.y + edge_height - 1),
+            width=2,
+        )
+
+    return surface
+
+
+def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> list[Path]:
+    _ensure_pygame_ready()
+
+    saved: list[Path] = []
+    out = Path(output_dir)
+
+    player = _pick_directional_surface(
+        build_player_directional_surfaces(radius=PLAYER_RADIUS),
+        bin_index=0,
+    )
+    player_path = out / "player.png"
+    _save_surface(player, player_path)
+    saved.append(player_path)
+
+    zombie_base = _pick_directional_surface(
+        build_zombie_directional_surfaces(radius=ZOMBIE_RADIUS, draw_hands=False),
+        bin_index=0,
+    )
+    zombie_normal_path = out / "zombie-normal.png"
+    _save_surface(zombie_base, zombie_normal_path)
+    saved.append(zombie_normal_path)
+
+    tracker = zombie_base.copy()
+    draw_humanoid_nose(
+        tracker,
+        radius=ZOMBIE_RADIUS,
+        angle_rad=0.0,
+        color=ZOMBIE_NOSE_COLOR,
+    )
+    tracker_path = out / "zombie-tracker.png"
+    _save_surface(tracker, tracker_path)
+    saved.append(tracker_path)
+
+    wall_hugging = zombie_base.copy()
+    draw_humanoid_hand(
+        wall_hugging,
+        radius=ZOMBIE_RADIUS,
+        angle_rad=math.pi / 2.0,
+        color=ZOMBIE_NOSE_COLOR,
+    )
+    wall_path = out / "zombie-wall.png"
+    _save_surface(wall_hugging, wall_path)
+    saved.append(wall_path)
+
+    buddy = _pick_directional_surface(
+        build_survivor_directional_surfaces(
+            radius=BUDDY_RADIUS,
+            is_buddy=True,
+            draw_hands=True,
+        ),
+        bin_index=0,
+    )
+    buddy_path = out / "buddy.png"
+    _save_surface(buddy, buddy_path)
+    saved.append(buddy_path)
+
+    survivor = _pick_directional_surface(
+        build_survivor_directional_surfaces(
+            radius=SURVIVOR_RADIUS,
+            is_buddy=False,
+            draw_hands=False,
+        ),
+        bin_index=0,
+    )
+    survivor_path = out / "survivor.png"
+    _save_surface(survivor, survivor_path)
+    saved.append(survivor_path)
+
+    car_surface = build_car_surface(CAR_WIDTH, CAR_HEIGHT)
+    car_color = resolve_car_color(health_ratio=1.0, appearance="default")
+    paint_car_surface(
+        car_surface,
+        width=CAR_WIDTH,
+        height=CAR_HEIGHT,
+        color=car_color,
+    )
+    car = _pick_directional_surface(build_car_directional_surfaces(car_surface), bin_index=0)
+    car_path = out / "car.png"
+    _save_surface(car, car_path)
+    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)
+    saved.append(fuel_path)
+
+    flashlight = build_flashlight_surface(FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT)
+    flashlight_path = out / "flashlight.png"
+    _save_surface(flashlight, flashlight_path)
+    saved.append(flashlight_path)
+
+    shoes = build_shoes_surface(SHOES_WIDTH, SHOES_HEIGHT)
+    shoes_path = out / "shoes.png"
+    _save_surface(shoes, shoes_path)
+    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)
+    saved.append(beam_path)
+
+    inner_wall = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    inner_fill, inner_border = resolve_wall_colors(
+        health_ratio=1.0,
+        palette_category="inner_wall",
+        palette=None,
+    )
+    paint_wall_surface(
+        inner_wall,
+        fill_color=inner_fill,
+        border_color=inner_border,
+        bevel_depth=INTERNAL_WALL_BEVEL_DEPTH,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+    inner_wall_path = out / "wall-inner.png"
+    _save_surface(inner_wall, inner_wall_path)
+    saved.append(inner_wall_path)
+
+    rubble_wall = build_rubble_wall_surface(
+        cell_size,
+        fill_color=inner_fill,
+        border_color=inner_border,
+        angle_deg=RUBBLE_ROTATION_DEG,
+    )
+    rubble_wall_path = out / "wall-rubble.png"
+    _save_surface(rubble_wall, rubble_wall_path)
+    saved.append(rubble_wall_path)
+
+    outer_wall = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    outer_fill, outer_border = resolve_wall_colors(
+        health_ratio=1.0,
+        palette_category="outer_wall",
+        palette=None,
+    )
+    paint_wall_surface(
+        outer_wall,
+        fill_color=outer_fill,
+        border_color=outer_border,
+        bevel_depth=0,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+    outer_wall_path = out / "wall-outer.png"
+    _save_surface(outer_wall, outer_wall_path)
+    saved.append(outer_wall_path)
+
+    pitfall = _build_pitfall_tile(cell_size)
+    pitfall_path = out / "pitfall.png"
+    _save_surface(pitfall, pitfall_path)
+    saved.append(pitfall_path)
+
+    fall_radius = max(1, int(ZOMBIE_RADIUS))
+    fall_size = fall_radius * 2
+    falling = pygame.Surface((fall_size, fall_size), pygame.SRCALPHA)
+    pygame.draw.circle(
+        falling,
+        FALLING_ZOMBIE_COLOR,
+        (fall_radius, fall_radius),
+        fall_radius,
+    )
+    falling_path = out / "falling-zombie.png"
+    _save_surface(falling, falling_path)
+    saved.append(falling_path)
+
+    fall_zone = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    fall_zone.fill(FALL_ZONE_FLOOR_PRIMARY)
+    fall_zone_path = out / "fall-zone.png"
+    _save_surface(fall_zone, fall_zone_path)
+    saved.append(fall_zone_path)
+
+    return saved

zombie_escape/gameplay/__init__.py

@@ -5,7 +5,7 @@
 from .ambient import sync_ambient_palette_with_flashlights
 from .footprints import get_shrunk_sprite, update_footprints
 from .interactions import check_interactions
-from .layout import generate_level_from_blueprint
+from .layout import MapGenerationError, generate_level_from_blueprint
 from .movement import process_player_input, update_entities
 from .spawn import (
     maintain_waiting_car_supply,
@@ -43,6 +43,7 @@ from .utils import (
 )
 
 __all__ = [
+    "MapGenerationError",
     "generate_level_from_blueprint",
     "place_new_car",
     "place_fuel_can",

zombie_escape/gameplay/constants.py

@@ -17,6 +17,9 @@ FOOTPRINT_MAX = 320
 MAX_ZOMBIES = 400
 ZOMBIE_SPAWN_PLAYER_BUFFER = 230
 ZOMBIE_TRACKER_AGING_DURATION_FRAMES = ZOMBIE_AGING_DURATION_FRAMES
+FALLING_ZOMBIE_PRE_FX_MS = 600
+FALLING_ZOMBIE_DURATION_MS = 450
+FALLING_ZOMBIE_DUST_DURATION_MS = 220
 
 # --- Car and fuel settings ---
 CAR_ZOMBIE_DAMAGE = 1
@@ -34,6 +37,9 @@ __all__ = [
     "MAX_ZOMBIES",
     "ZOMBIE_SPAWN_PLAYER_BUFFER",
     "ZOMBIE_TRACKER_AGING_DURATION_FRAMES",
+    "FALLING_ZOMBIE_PRE_FX_MS",
+    "FALLING_ZOMBIE_DURATION_MS",
+    "FALLING_ZOMBIE_DUST_DURATION_MS",
     "CAR_ZOMBIE_DAMAGE",
     "FUEL_HINT_DURATION_MS",
     "OUTER_WALL_HEALTH",

zombie_escape/gameplay/layout.py

@@ -1,22 +1,29 @@
 from __future__ import annotations
 
+import random
 from typing import Any
 
 import pygame
 
 from ..colors import get_environment_palette
-from ..entities import SteelBeam, Wall
-from ..entities_constants import INTERNAL_WALL_HEALTH, STEEL_BEAM_HEALTH
+from ..entities import RubbleWall, SteelBeam, Wall
+from ..entities_constants import (
+    INTERNAL_WALL_BEVEL_DEPTH,
+    INTERNAL_WALL_HEALTH,
+    STEEL_BEAM_HEALTH,
+)
+from ..render_assets import RUBBLE_ROTATION_DEG
 from .constants import OUTER_WALL_HEALTH
-from ..level_blueprints import choose_blueprint
+from ..level_blueprints import MapGenerationError, choose_blueprint
 from ..models import GameData
 from ..rng import get_rng
 
-__all__ = ["generate_level_from_blueprint"]
+__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,
@@ -62,17 +69,22 @@ 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),
+        base_seed=game_data.state.seed,
     )
     if isinstance(blueprint_data, dict):
         blueprint = blueprint_data.get("grid", [])
         steel_cells_raw = blueprint_data.get("steel_cells", set())
+        car_reachable_cells = blueprint_data.get("car_reachable_cells", set())
     else:
         blueprint = blueprint_data
         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()
     )
+    game_data.layout.car_walkable_cells = car_reachable_cells
     cell_size = game_data.cell_size
     outer_wall_cells = {
         (x, y)
@@ -94,15 +106,20 @@ def generate_level_from_blueprint(
 
     outside_cells: set[tuple[int, int]] = set()
     walkable_cells: list[tuple[int, int]] = []
+    pitfall_cells: set[tuple[int, int]] = set()
     player_cells: list[tuple[int, int]] = []
     car_cells: list[tuple[int, int]] = []
     zombie_cells: list[tuple[int, int]] = []
+    fuel_cells: list[tuple[int, int]] = []
+    flashlight_cells: list[tuple[int, int]] = []
+    shoes_cells: list[tuple[int, int]] = []
     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)
+    rubble_ratio = max(0.0, min(1.0, getattr(stage, "wall_rubble_ratio", 0.0)))
 
     def add_beam_to_groups(beam: SteelBeam) -> None:
         if beam._added_to_groups:
@@ -145,6 +162,9 @@ def generate_level_from_blueprint(
                 wall_group.add(wall)
                 all_sprites.add(wall, layer=0)
                 continue
+            if ch == "x":
+                pitfall_cells.add((x, y))
+                continue
             if ch == "E":
                 if not cell_has_beam:
                     walkable_cells.append((x, y))
@@ -176,22 +196,56 @@ def generate_level_from_blueprint(
                 if any(bevel_mask):
                     bevel_corners[(x, y)] = bevel_mask
                 wall_cell = (x, y)
-                wall = Wall(
-                    cell_rect.x,
-                    cell_rect.y,
-                    cell_rect.width,
-                    cell_rect.height,
-                    health=INTERNAL_WALL_HEALTH,
-                    palette=palette,
-                    palette_category="inner_wall",
-                    bevel_mask=bevel_mask,
-                    draw_bottom_side=draw_bottom_side,
-                    on_destroy=(
-                        (lambda _w, b=beam, cell=wall_cell: (remove_wall_cell(cell), add_beam_to_groups(b)))
-                        if beam
-                        else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
-                    ),
-                )
+                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
+                    )
+                    wall = RubbleWall(
+                        cell_rect.x,
+                        cell_rect.y,
+                        cell_rect.width,
+                        cell_rect.height,
+                        health=INTERNAL_WALL_HEALTH,
+                        palette=palette,
+                        palette_category="inner_wall",
+                        bevel_depth=INTERNAL_WALL_BEVEL_DEPTH,
+                        rubble_rotation_deg=rotation_deg,
+                        on_destroy=(
+                            (
+                                lambda _w, b=beam, cell=wall_cell: (
+                                    remove_wall_cell(cell),
+                                    add_beam_to_groups(b),
+                                )
+                            )
+                            if beam
+                            else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
+                        ),
+                    )
+                else:
+                    wall = Wall(
+                        cell_rect.x,
+                        cell_rect.y,
+                        cell_rect.width,
+                        cell_rect.height,
+                        health=INTERNAL_WALL_HEALTH,
+                        palette=palette,
+                        palette_category="inner_wall",
+                        bevel_mask=bevel_mask,
+                        draw_bottom_side=draw_bottom_side,
+                        on_destroy=(
+                            (
+                                lambda _w, b=beam, cell=wall_cell: (
+                                    remove_wall_cell(cell),
+                                    add_beam_to_groups(b),
+                                )
+                            )
+                            if beam
+                            else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
+                        ),
+                    )
                 wall_group.add(wall)
                 all_sprites.add(wall, layer=0)
             else:
@@ -204,6 +258,12 @@ def generate_level_from_blueprint(
                 car_cells.append((x, y))
             if ch == "Z":
                 zombie_cells.append((x, y))
+            if ch == "f":
+                fuel_cells.append((x, y))
+            if ch == "l":
+                flashlight_cells.append((x, y))
+            if ch == "s":
+                shoes_cells.append((x, y))
 
             if cell_has_beam and ch != "1":
                 beam = SteelBeam(
@@ -225,6 +285,7 @@ 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.pitfall_cells = pitfall_cells
     fall_spawn_cells = _expand_zone_cells(
         stage.fall_spawn_zones,
         grid_cols=stage.grid_cols,
@@ -250,5 +311,9 @@ def generate_level_from_blueprint(
         "player_cells": player_cells,
         "car_cells": car_cells,
         "zombie_cells": zombie_cells,
+        "fuel_cells": fuel_cells,
+        "flashlight_cells": flashlight_cells,
+        "shoes_cells": shoes_cells,
         "walkable_cells": walkable_cells,
+        "car_walkable_cells": list(car_reachable_cells),
     }