zombie-escape 1.8.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

zombie_escape/render.py

@@ -17,7 +17,17 @@ from .colors import (
     YELLOW,
     get_environment_palette,
 )
-from .entities import Camera, Car, Flashlight, FuelCan, Player, Survivor, Wall
+from .entities import (
+    Camera,
+    Car,
+    Flashlight,
+    FuelCan,
+    Player,
+    SteelBeam,
+    Survivor,
+    Wall,
+)
+from .entities_constants import ZOMBIE_RADIUS
 from .font_utils import load_font
 from .gameplay_constants import (
     DEFAULT_FLASHLIGHT_SPAWN_COUNT,
@@ -25,8 +35,82 @@ from .gameplay_constants import (
 )
 from .localization import get_font_settings
 from .localization import translate as tr
-from .models import GameData, Stage
-from .render_assets import RenderAssets, resolve_wall_colors
+from .models import DustRing, FallingZombie, Footprint, GameData, Stage
+from .render_assets import RenderAssets, resolve_steel_beam_colors, resolve_wall_colors
+from .render_constants import (
+    FALLING_DUST_COLOR,
+    FALLING_WHIRLWIND_COLOR,
+    FALLING_ZOMBIE_COLOR,
+    SHADOW_MIN_RATIO,
+    SHADOW_OVERSAMPLE,
+    SHADOW_RADIUS_RATIO,
+    SHADOW_STEPS,
+)
+
+_SHADOW_TILE_CACHE: dict[tuple[int, int, float], surface.Surface] = {}
+_SHADOW_LAYER_CACHE: dict[tuple[int, int], surface.Surface] = {}
+
+
+def _get_shadow_tile_surface(
+    cell_size: int,
+    alpha: int,
+    *,
+    edge_softness: float = 0.35,
+) -> surface.Surface:
+    key = (max(1, cell_size), max(0, min(255, alpha)), edge_softness)
+    if key in _SHADOW_TILE_CACHE:
+        return _SHADOW_TILE_CACHE[key]
+    size = key[0]
+    oversample = SHADOW_OVERSAMPLE
+    render_size = size * oversample
+    render_surf = pygame.Surface((render_size, render_size), pygame.SRCALPHA)
+    base_alpha = key[1]
+    if edge_softness <= 0:
+        render_surf.fill((0, 0, 0, base_alpha))
+        if oversample > 1:
+            surf = pygame.transform.smoothscale(render_surf, (size, size))
+        else:
+            surf = render_surf
+        _SHADOW_TILE_CACHE[key] = surf
+        return surf
+
+    softness = max(0.0, min(1.0, edge_softness))
+    fade_band = max(1, int(render_size * softness))
+    base_radius = max(1, int(render_size * SHADOW_RADIUS_RATIO))
+
+    render_surf.fill((0, 0, 0, 0))
+    steps = SHADOW_STEPS
+    min_ratio = SHADOW_MIN_RATIO
+    for idx in range(steps):
+        t = idx / (steps - 1) if steps > 1 else 1.0
+        inset = int(fade_band * t)
+        rect_size = render_size - inset * 2
+        if rect_size <= 0:
+            continue
+        radius = max(0, base_radius - inset)
+        layer_alpha = int(base_alpha * (min_ratio + (1.0 - min_ratio) * t))
+        pygame.draw.rect(
+            render_surf,
+            (0, 0, 0, layer_alpha),
+            pygame.Rect(inset, inset, rect_size, rect_size),
+            border_radius=radius,
+        )
+
+    if oversample > 1:
+        surf = pygame.transform.smoothscale(render_surf, (size, size))
+    else:
+        surf = render_surf
+    _SHADOW_TILE_CACHE[key] = surf
+    return surf
+
+
+def _get_shadow_layer(size: tuple[int, int]) -> surface.Surface:
+    key = (max(1, size[0]), max(1, size[1]))
+    if key in _SHADOW_LAYER_CACHE:
+        return _SHADOW_LAYER_CACHE[key]
+    layer = pygame.Surface(key, pygame.SRCALPHA)
+    _SHADOW_LAYER_CACHE[key] = layer
+    return layer
 
 
 def show_message(
@@ -61,7 +145,7 @@ def draw_level_overview(
     player: Player | None,
     car: Car | None,
     waiting_cars: list[Car] | None,
-    footprints: list[dict[str, Any]],
+    footprints: list[Footprint],
     *,
     fuel: FuelCan | None = None,
     flashlights: list[Flashlight] | None = None,
@@ -71,32 +155,37 @@ def draw_level_overview(
     palette_key: str | None = None,
 ) -> None:
     palette = get_environment_palette(palette_key)
-    base_floor = getattr(palette, "floor_primary", palette.outside)
+    base_floor = palette.floor_primary
     dark_floor = tuple(max(0, int(channel * 0.55)) for channel in base_floor)
     surface.fill(dark_floor)
     for wall in wall_group:
-        if not isinstance(wall, Wall):
-            raise TypeError("wall_group must contain Wall instances")
         if wall.max_health > 0:
             health_ratio = max(0.0, min(1.0, wall.health / wall.max_health))
         else:
             health_ratio = 0.0
-        fill_color, _ = resolve_wall_colors(
-            health_ratio=health_ratio,
-            palette_category=wall.palette_category,
-            palette=palette,
-        )
-        pygame.draw.rect(surface, fill_color, wall.rect)
+        if isinstance(wall, Wall):
+            fill_color, _ = resolve_wall_colors(
+                health_ratio=health_ratio,
+                palette_category=wall.palette_category,
+                palette=palette,
+            )
+            pygame.draw.rect(surface, fill_color, wall.rect)
+        elif isinstance(wall, SteelBeam):
+            fill_color, _ = resolve_steel_beam_colors(
+                health_ratio=health_ratio,
+                palette=palette,
+            )
+            pygame.draw.rect(surface, fill_color, wall.rect)
     now = pygame.time.get_ticks()
     for fp in footprints:
-        age = now - fp["time"]
+        age = now - fp.time
         fade = 1 - (age / assets.footprint_lifetime_ms)
         fade = max(assets.footprint_min_fade, fade)
         color = tuple(int(c * fade) for c in FOOTPRINT_COLOR)
         pygame.draw.circle(
             surface,
             color,
-            (int(fp["pos"][0]), int(fp["pos"][1])),
+            (int(fp.pos[0]), int(fp.pos[1])),
             assets.footprint_overview_radius,
         )
     if fuel and fuel.alive():
@@ -206,19 +295,21 @@ def _get_hatch_pattern(
     fog_data: dict[str, Any],
     thickness: int,
     *,
-    pixel_scale: int = 1,
     color: tuple[int, int, int, int] | None = None,
 ) -> surface.Surface:
-    """Return cached ordered-dither tile surface (Bayer-style, optionally chunky)."""
+    """Return cached dot hatch tile surface (Bayer-ordered, optionally chunky)."""
     cache = fog_data.setdefault("hatch_patterns", {})
-    pixel_scale = max(1, pixel_scale)
-    key = (thickness, pixel_scale, color)
+    key = (thickness, color)
     if key in cache:
         return cache[key]
 
-    spacing = 20
+    spacing = 4
+    oversample = 3
     density = max(1, min(thickness, 16))
-    pattern = pygame.Surface((spacing, spacing), pygame.SRCALPHA)
+    pattern_size = spacing * 8
+    hi_spacing = spacing * oversample
+    hi_pattern_size = pattern_size * oversample
+    pattern = pygame.Surface((hi_pattern_size, hi_pattern_size), pygame.SRCALPHA)
 
     # 8x8 Bayer matrix values 0..63 for ordered dithering
     bayer = [
@@ -232,14 +323,20 @@ def _get_hatch_pattern(
         [63, 31, 55, 23, 61, 29, 53, 21],
     ]
     threshold = int((density / 16) * 64)
-    for y in range(spacing):
-        for x in range(spacing):
-            if bayer[y % 8][x % 8] < threshold:
-                pattern.set_at((x, y), color or (0, 0, 0, 255))
+    dot_radius = max(
+        1,
+        min(hi_spacing, int(math.ceil((density / 16) * hi_spacing))),
+    )
+    dot_color = color or (0, 0, 0, 255)
+    for grid_y in range(8):
+        for grid_x in range(8):
+            if bayer[grid_y][grid_x] < threshold:
+                cx = grid_x * hi_spacing + hi_spacing // 2
+                cy = grid_y * hi_spacing + hi_spacing // 2
+                pygame.draw.circle(pattern, dot_color, (cx, cy), dot_radius)
 
-    if pixel_scale > 1:
-        scaled_size = (spacing * pixel_scale, spacing * pixel_scale)
-        pattern = pygame.transform.scale(pattern, scaled_size)
+    if oversample > 1:
+        pattern = pygame.transform.smoothscale(pattern, (pattern_size, pattern_size))
 
     cache[key] = pattern
     return pattern
@@ -258,6 +355,9 @@ def _get_fog_overlay_surfaces(
         return overlays[key]
 
     scale = profile._scale(assets, stage)
+    ring_scale = scale
+    if profile.flashlight_count >= 2:
+        ring_scale += max(0.0, assets.flashlight_hatch_extra_scale)
     max_radius = int(assets.fov_radius * scale)
     padding = 32
     coverage_width = max(assets.screen_width * 2, max_radius * 2)
@@ -277,14 +377,13 @@ def _get_fog_overlay_surfaces(
         pattern = _get_hatch_pattern(
             fog_data,
             ring.thickness,
-            pixel_scale=assets.fog_hatch_pixel_scale,
             color=base_color,
         )
         p_w, p_h = pattern.get_size()
         for y in range(0, height, p_h):
             for x in range(0, width, p_w):
                 ring_surface.blit(pattern, (x, y))
-        radius = int(assets.fov_radius * ring.radius_factor * scale)
+        radius = int(assets.fov_radius * ring.radius_factor * ring_scale)
         pygame.draw.circle(ring_surface, (0, 0, 0, 0), center, radius)
         ring_surfaces.append(ring_surface)
 
@@ -313,7 +412,7 @@ def _build_flashlight_fade_surface(
     *,
     start_ratio: float = 0.2,
     max_alpha: int = 220,
-    outer_extension: int = 50,
+    outer_extension: int = 30,
 ) -> surface.Surface:
     """Return a radial gradient so flashlight edges softly darken again."""
 
@@ -359,6 +458,96 @@ def _build_flashlight_fade_surface(
     return fade_surface
 
 
+def _draw_fall_whirlwind(
+    screen: surface.Surface,
+    camera: Camera,
+    center: tuple[int, int],
+    progress: float,
+) -> None:
+    base_alpha = FALLING_WHIRLWIND_COLOR[3]
+    alpha = int(max(0, min(255, base_alpha * (1.0 - progress))))
+    if alpha <= 0:
+        return
+    color = (
+        FALLING_WHIRLWIND_COLOR[0],
+        FALLING_WHIRLWIND_COLOR[1],
+        FALLING_WHIRLWIND_COLOR[2],
+        alpha,
+    )
+    swirl_radius = max(2, int(ZOMBIE_RADIUS * 1.1))
+    offset = max(1, int(ZOMBIE_RADIUS * 0.6))
+    size = swirl_radius * 4
+    swirl = pygame.Surface((size, size), pygame.SRCALPHA)
+    cx = cy = size // 2
+    for idx in range(2):
+        angle = progress * math.tau * 0.3 + idx * (math.tau / 2)
+        ox = int(math.cos(angle) * offset)
+        oy = int(math.sin(angle) * offset)
+        pygame.draw.circle(swirl, color, (cx + ox, cy + oy), swirl_radius, width=2)
+    world_rect = pygame.Rect(0, 0, 1, 1)
+    world_rect.center = center
+    screen_center = camera.apply_rect(world_rect).center
+    screen.blit(swirl, swirl.get_rect(center=screen_center))
+
+
+def _draw_falling_fx(
+    screen: surface.Surface,
+    camera: Camera,
+    falling_zombies: list[FallingZombie],
+    flashlight_count: int,
+    dust_rings: list[DustRing],
+) -> None:
+    if not falling_zombies and not dust_rings:
+        return
+    now = pygame.time.get_ticks()
+    for fall in falling_zombies:
+        pre_fx_ms = max(0, fall.pre_fx_ms)
+        fall_duration_ms = max(1, fall.fall_duration_ms)
+        fall_start = fall.started_at_ms + pre_fx_ms
+        impact_at = fall_start + fall_duration_ms
+        if now < fall_start:
+            if flashlight_count > 0 and pre_fx_ms > 0:
+                fx_progress = max(0.0, min(1.0, (now - fall.started_at_ms) / pre_fx_ms))
+                _draw_fall_whirlwind(screen, camera, fall.target_pos, fx_progress)
+            continue
+        if now >= impact_at:
+            continue
+        fall_progress = max(0.0, min(1.0, (now - fall_start) / fall_duration_ms))
+        eased = 1.0 - (1.0 - fall_progress) * (1.0 - fall_progress)
+        x = fall.target_pos[0]
+        y = int(fall.start_pos[1] + (fall.target_pos[1] - fall.start_pos[1]) * eased)
+        world_rect = pygame.Rect(0, 0, ZOMBIE_RADIUS * 2, ZOMBIE_RADIUS * 2)
+        world_rect.center = (x, y)
+        screen_rect = camera.apply_rect(world_rect)
+        pygame.draw.circle(
+            screen,
+            FALLING_ZOMBIE_COLOR,
+            screen_rect.center,
+            ZOMBIE_RADIUS,
+        )
+
+    for ring in list(dust_rings):
+        elapsed = now - ring.started_at_ms
+        if elapsed >= ring.duration_ms:
+            dust_rings.remove(ring)
+            continue
+        progress = max(0.0, min(1.0, elapsed / ring.duration_ms))
+        alpha = int(max(0, min(255, FALLING_DUST_COLOR[3] * (1.0 - progress))))
+        if alpha <= 0:
+            continue
+        radius = int(ZOMBIE_RADIUS * (0.7 + progress * 1.9))
+        color = (
+            FALLING_DUST_COLOR[0],
+            FALLING_DUST_COLOR[1],
+            FALLING_DUST_COLOR[2],
+            alpha,
+        )
+        world_rect = pygame.Rect(0, 0, 1, 1)
+        world_rect.center = ring.pos
+        screen_center = camera.apply_rect(world_rect).center
+        pygame.draw.circle(screen, color, screen_center, radius, width=2)
+
+
 def _draw_hint_arrow(
     screen: surface.Surface,
     camera: Camera,
@@ -411,6 +600,7 @@ def _draw_status_bar(
     seed: int | None = None,
     debug_mode: bool = False,
     zombie_group: sprite.Group | None = None,
+    falling_spawn_carry: int | None = None,
 ) -> None:
     """Render a compact status bar with current config flags and stage info."""
     bar_rect = pygame.Rect(
@@ -429,7 +619,11 @@ def _draw_status_bar(
     steel_on = config.get("steel_beams", {}).get("enabled", False)
     if stage:
         # Keep the label compact for the status bar
-        stage_label = f"#{stage.id[-1]}" if stage.id.startswith("stage") else stage.id
+        if stage.id.startswith("stage"):
+            stage_suffix = stage.id.removeprefix("stage")
+            stage_label = f"#{stage_suffix}" if stage_suffix else stage.id
+        else:
+            stage_label = stage.id
     else:
         stage_label = "#1"
 
@@ -443,14 +637,15 @@ def _draw_status_bar(
     if steel_on:
         parts.append(tr("status.steel"))
     if debug_mode:
-        parts.append(tr("status.debug"))
         if zombie_group is not None:
-            zombies = [z for z in zombie_group if getattr(z, "alive", lambda: True)()]
+            zombies = [z for z in zombie_group if z.alive()]
             total = len(zombies)
-            tracker = sum(1 for z in zombies if getattr(z, "tracker", False))
-            wall = sum(1 for z in zombies if getattr(z, "wall_follower", False))
+            tracker = sum(1 for z in zombies if z.tracker)
+            wall = sum(1 for z in zombies if z.wall_follower)
             normal = max(0, total - tracker - wall)
             parts.append(f"Z:{total} N:{normal} T:{tracker} W:{wall}")
+            if falling_spawn_carry is not None:
+                parts.append(f"C:{max(0, falling_spawn_carry)}")
 
     status_text = " | ".join(parts)
     color = LIGHT_GRAY
@@ -472,45 +667,15 @@ def _draw_status_bar(
         print(f"Error rendering status bar: {e}")
 
 
-def draw(
-    assets: RenderAssets,
+def _draw_play_area(
     screen: surface.Surface,
-    game_data: GameData,
-    fov_target: pygame.sprite.Sprite | None,
-    *,
-    config: dict[str, Any],
-    hint_target: tuple[int, int] | None = None,
-    hint_color: tuple[int, int, int] | None = None,
-    do_flip: bool = True,
-    present_fn: Callable[[surface.Surface], None] | None = None,
-) -> None:
-    hint_color = hint_color or YELLOW
-    state = game_data.state
-    player = game_data.player
-    if player is None:
-        raise ValueError("draw requires an active player on game_data")
-
-    camera = game_data.camera
-    stage = game_data.stage
-    outer_rect = game_data.layout.outer_rect
-    outside_rects = game_data.layout.outside_rects or []
-    all_sprites = game_data.groups.all_sprites
-    fog_surfaces = game_data.fog
-    footprints = state.footprints
-    has_fuel = state.has_fuel
-    flashlight_count = state.flashlight_count
-    elapsed_play_ms = state.elapsed_play_ms
-    fuel_message_until = state.fuel_message_until
-    buddy_onboard = state.buddy_onboard
-    buddy_required = stage.buddy_required_count if stage else 0
-    survivors_onboard = state.survivors_onboard
-    survivor_messages = list(state.survivor_messages)
-    zombie_group = game_data.groups.zombie_group
-    active_car = game_data.car if game_data.car and game_data.car.alive() else None
-
-    palette = get_environment_palette(state.ambient_palette_key)
-    screen.fill(palette.outside)
-
+    camera: Camera,
+    assets: RenderAssets,
+    palette: Any,
+    outer_rect: tuple[int, int, int, int],
+    outside_rects: list[pygame.Rect],
+    fall_spawn_cells: set[tuple[int, int]],
+) -> tuple[int, int, int, int, set[tuple[int, int]]]:
     xs, ys, xe, ye = outer_rect
     xs //= assets.internal_wall_grid_snap
     ys //= assets.internal_wall_grid_snap
@@ -556,38 +721,140 @@ def draw(
         for x in range(start_x, end_x):
             if (x, y) in outside_cells:
                 continue
-            if ((x // 2) + (y // 2)) % 2 == 0:
-                lx, ly = (
-                    x * assets.internal_wall_grid_snap,
-                    y * assets.internal_wall_grid_snap,
-                )
-                r = pygame.Rect(
-                    lx,
-                    ly,
-                    assets.internal_wall_grid_snap,
-                    assets.internal_wall_grid_snap,
+            use_secondary = ((x // 2) + (y // 2)) % 2 == 0
+            if (x, y) in fall_spawn_cells:
+                color = (
+                    palette.fall_zone_secondary
+                    if use_secondary
+                    else palette.fall_zone_primary
                 )
-                sr = camera.apply_rect(r)
-                if sr.colliderect(screen.get_rect()):
-                    pygame.draw.rect(screen, palette.floor_secondary, sr)
-
-    if config.get("footprints", {}).get("enabled", True):
-        now = pygame.time.get_ticks()
-        for fp in footprints:
-            age = now - fp["time"]
-            fade = 1 - (age / assets.footprint_lifetime_ms)
-            fade = max(assets.footprint_min_fade, fade)
-            color = tuple(int(c * fade) for c in FOOTPRINT_COLOR)
-            fp_rect = pygame.Rect(
-                fp["pos"][0] - assets.footprint_radius,
-                fp["pos"][1] - assets.footprint_radius,
-                assets.footprint_radius * 2,
-                assets.footprint_radius * 2,
+            elif not use_secondary:
+                continue
+            else:
+                color = palette.floor_secondary
+            lx, ly = (
+                x * assets.internal_wall_grid_snap,
+                y * assets.internal_wall_grid_snap,
+            )
+            r = pygame.Rect(
+                lx,
+                ly,
+                assets.internal_wall_grid_snap,
+                assets.internal_wall_grid_snap,
             )
-            sr = camera.apply_rect(fp_rect)
-            if sr.colliderect(screen.get_rect().inflate(30, 30)):
-                pygame.draw.circle(screen, color, sr.center, assets.footprint_radius)
+            sr = camera.apply_rect(r)
+            if sr.colliderect(screen.get_rect()):
+                pygame.draw.rect(screen, color, sr)
+
+    return xs, ys, xe, ye, outside_cells
+
+
+def abs_clip(value: float, min_v: float, max_v: float) -> float:
+    value_sign = 1.0 if value >= 0.0 else -1.0
+    value = abs(value)
+    if value < min_v:
+        value = min_v
+    elif value > max_v:
+        value = max_v
+    return value_sign * value
+
+
+def _draw_wall_shadows(
+    screen: surface.Surface,
+    camera: Camera,
+    *,
+    wall_cells: set[tuple[int, int]],
+    wall_group: sprite.Group | None,
+    outer_wall_cells: set[tuple[int, int]] | None,
+    cell_size: int,
+    light_source_pos: tuple[int, int] | None,
+    alpha: int = 68,
+) -> None:
+    if not wall_cells or cell_size <= 0 or light_source_pos is None:
+        return
+    inner_wall_cells = set(wall_cells)
+    if outer_wall_cells:
+        inner_wall_cells.difference_update(outer_wall_cells)
+    if wall_group and cell_size > 0:
+        for wall in wall_group:
+            if isinstance(wall, SteelBeam):
+                cell_x = int(wall.rect.centerx // cell_size)
+                cell_y = int(wall.rect.centery // cell_size)
+                inner_wall_cells.add((cell_x, cell_y))
+    if not inner_wall_cells:
+        return
+    base_shadow_size = max(cell_size + 2, int(cell_size * 1.35))
+    shadow_size = max(1, int(base_shadow_size * 1.5))
+    shadow_surface = _get_shadow_tile_surface(shadow_size, 255, edge_softness=0.12)
+    shadow_layer = _get_shadow_layer(screen.get_size())
+    shadow_layer.fill((0, 0, 0, 0))
+    screen_rect = screen.get_rect()
+    px, py = light_source_pos
+    drew = False
+    clip_max = shadow_size * 0.25
+    for cell_x, cell_y in inner_wall_cells:
+        world_x = cell_x * cell_size
+        world_y = cell_y * cell_size
+        wall_rect = pygame.Rect(world_x, world_y, cell_size, cell_size)
+        wall_screen_rect = camera.apply_rect(wall_rect)
+        if not wall_screen_rect.colliderect(screen_rect):
+            continue
+        center_x = world_x + cell_size / 2
+        center_y = world_y + cell_size / 2
+        dx = (center_x - px) * 0.5
+        dy = (center_y - py) * 0.5
+        dx = int(abs_clip(dx, 0, clip_max))
+        dy = int(abs_clip(dy, 0, clip_max))
+        shadow_rect = pygame.Rect(0, 0, shadow_size, shadow_size)
+        shadow_rect.center = (
+            int(center_x + dx),
+            int(center_y + dy),
+        )
+        shadow_screen_rect = camera.apply_rect(shadow_rect)
+        if not shadow_screen_rect.colliderect(screen_rect):
+            continue
+        shadow_layer.blit(shadow_surface, shadow_screen_rect.topleft)
+        drew = True
+    if drew:
+        shadow_layer.set_alpha(alpha)
+        screen.blit(shadow_layer, (0, 0))
+
+
+def _draw_footprints(
+    screen: surface.Surface,
+    camera: Camera,
+    assets: RenderAssets,
+    footprints: list[Footprint],
+    *,
+    config: dict[str, Any],
+) -> None:
+    if not config.get("footprints", {}).get("enabled", True):
+        return
+    now = pygame.time.get_ticks()
+    for fp in footprints:
+        age = now - fp.time
+        fade = 1 - (age / assets.footprint_lifetime_ms)
+        fade = max(assets.footprint_min_fade, fade)
+        color = tuple(int(c * fade) for c in FOOTPRINT_COLOR)
+        fp_rect = pygame.Rect(
+            fp.pos[0] - assets.footprint_radius,
+            fp.pos[1] - assets.footprint_radius,
+            assets.footprint_radius * 2,
+            assets.footprint_radius * 2,
+        )
+        sr = camera.apply_rect(fp_rect)
+        if sr.colliderect(screen.get_rect().inflate(30, 30)):
+            pygame.draw.circle(screen, color, sr.center, assets.footprint_radius)
 
+
+def _draw_entities(
+    screen: surface.Surface,
+    camera: Camera,
+    all_sprites: sprite.LayeredUpdates,
+    player: Player,
+    *,
+    has_fuel: bool,
+) -> pygame.Rect:
     screen_rect_inflated = screen.get_rect().inflate(100, 100)
     player_screen_rect: pygame.Rect | None = None
     for entity in all_sprites:
@@ -596,177 +863,273 @@ def draw(
             screen.blit(entity.image, sprite_screen_rect)
         if entity is player:
             player_screen_rect = sprite_screen_rect
+            _draw_fuel_indicator(
+                screen,
+                player_screen_rect,
+                has_fuel=has_fuel,
+                in_car=player.in_car,
+            )
+    return player_screen_rect or camera.apply_rect(player.rect)
 
-    if player_screen_rect is None:
-        player_screen_rect = camera.apply_rect(player.rect)
-
-    if has_fuel and player_screen_rect and not player.in_car:
-        indicator_size = 4
-        padding = 1
-        indicator_rect = pygame.Rect(
-            player_screen_rect.right - indicator_size - padding,
-            player_screen_rect.bottom - indicator_size - padding,
-            indicator_size,
-            indicator_size,
-        )
-        pygame.draw.rect(screen, YELLOW, indicator_rect)
-        pygame.draw.rect(screen, (180, 160, 40), indicator_rect, width=1)
 
-    if hint_target and player:
-        current_fov_scale = _get_fog_scale(
-            assets,
-            stage,
-            flashlight_count,
-        )
-        hint_ring_radius = assets.fov_radius * 0.5 * current_fov_scale
-        _draw_hint_arrow(
-            screen,
-            camera,
-            assets,
-            player,
-            hint_target,
-            color=hint_color,
-            ring_radius=hint_ring_radius,
-        )
+def _draw_fuel_indicator(
+    screen: surface.Surface,
+    player_screen_rect: pygame.Rect,
+    *,
+    has_fuel: bool,
+    in_car: bool,
+) -> None:
+    if not has_fuel or in_car:
+        return
+    indicator_size = 4
+    padding = 1
+    indicator_rect = pygame.Rect(
+        player_screen_rect.right - indicator_size - padding,
+        player_screen_rect.bottom - indicator_size - padding,
+        indicator_size,
+        indicator_size,
+    )
+    pygame.draw.rect(screen, YELLOW, indicator_rect)
+    pygame.draw.rect(screen, (180, 160, 40), indicator_rect, width=1)
 
-    if fov_target is not None:
-        fov_center_on_screen = list(camera.apply(fov_target).center)
-        cam_rect = camera.camera
-        horizontal_span = camera.width - assets.screen_width
-        vertical_span = camera.height - assets.screen_height
-        if horizontal_span <= 0 or (cam_rect.x != 0 and cam_rect.x != -horizontal_span):
-            fov_center_on_screen[0] = assets.screen_width // 2
-        if vertical_span <= 0 or (cam_rect.y != 0 and cam_rect.y != -vertical_span):
-            fov_center_on_screen[1] = assets.screen_height // 2
-        fov_center_tuple = (int(fov_center_on_screen[0]), int(fov_center_on_screen[1]))
-        if state.dawn_ready:
-            profile = FogProfile.DAWN
-        else:
-            profile = FogProfile._from_flashlight_count(flashlight_count)
-        overlay = _get_fog_overlay_surfaces(
-            fog_surfaces,
-            assets,
-            profile,
-            stage=stage,
-        )
-        combined_surface: surface.Surface = overlay["combined"]
-        screen.blit(
-            combined_surface,
-            combined_surface.get_rect(center=fov_center_tuple),
-        )
 
-    if not has_fuel and fuel_message_until > elapsed_play_ms:
-        show_message(
-            screen,
-            tr("hud.need_fuel"),
-            18,
-            ORANGE,
-            (assets.screen_width // 2, assets.screen_height // 2),
-        )
+def _draw_hint_indicator(
+    screen: surface.Surface,
+    camera: Camera,
+    assets: RenderAssets,
+    player: Player,
+    hint_target: tuple[int, int] | None,
+    *,
+    hint_color: tuple[int, int, int],
+    stage: Stage | None,
+    flashlight_count: int,
+) -> None:
+    if not hint_target:
+        return
+    current_fov_scale = _get_fog_scale(
+        assets,
+        stage,
+        flashlight_count,
+    )
+    hint_ring_radius = assets.fov_radius * 0.5 * current_fov_scale
+    _draw_hint_arrow(
+        screen,
+        camera,
+        assets,
+        player,
+        hint_target,
+        color=hint_color,
+        ring_radius=hint_ring_radius,
+    )
 
-    def _render_objective(lines: list[str]) -> None:
-        try:
-            font_settings = get_font_settings()
-            font = load_font(font_settings.resource, font_settings.scaled_size(11))
-            y = 8
-            for line in lines:
-                text_surface = font.render(line, False, YELLOW)
-                text_rect = text_surface.get_rect(topleft=(12, y))
-                screen.blit(text_surface, text_rect)
-                y += text_rect.height + 4
-        except pygame.error as e:
-            print(f"Error rendering objective: {e}")
-
-    def _render_survival_timer() -> None:
-        if not (stage and stage.survival_stage):
-            return
-        goal_ms = state.survival_goal_ms
-        if goal_ms <= 0:
-            return
-        elapsed_ms = max(0, min(goal_ms, state.survival_elapsed_ms))
-        remaining_ms = max(0, goal_ms - elapsed_ms)
-        padding = 12
-        bar_height = 8
-        y_pos = assets.screen_height - assets.status_bar_height - bar_height - 10
-        bar_rect = pygame.Rect(
-            padding,
-            y_pos,
-            assets.screen_width - padding * 2,
-            bar_height,
-        )
-        track_surface = pygame.Surface(
-            (bar_rect.width, bar_rect.height), pygame.SRCALPHA
+
+def _draw_fog_of_war(
+    screen: surface.Surface,
+    camera: Camera,
+    assets: RenderAssets,
+    fog_surfaces: dict[str, Any],
+    fov_target: pygame.sprite.Sprite | None,
+    *,
+    stage: Stage | None,
+    flashlight_count: int,
+    dawn_ready: bool,
+) -> None:
+    if fov_target is None:
+        return
+    fov_center_on_screen = list(camera.apply(fov_target).center)
+    cam_rect = camera.camera
+    horizontal_span = camera.width - assets.screen_width
+    vertical_span = camera.height - assets.screen_height
+    if horizontal_span <= 0 or (cam_rect.x != 0 and cam_rect.x != -horizontal_span):
+        fov_center_on_screen[0] = assets.screen_width // 2
+    if vertical_span <= 0 or (cam_rect.y != 0 and cam_rect.y != -vertical_span):
+        fov_center_on_screen[1] = assets.screen_height // 2
+    fov_center_tuple = (int(fov_center_on_screen[0]), int(fov_center_on_screen[1]))
+    if dawn_ready:
+        profile = FogProfile.DAWN
+    else:
+        profile = FogProfile._from_flashlight_count(flashlight_count)
+    overlay = _get_fog_overlay_surfaces(
+        fog_surfaces,
+        assets,
+        profile,
+        stage=stage,
+    )
+    combined_surface: surface.Surface = overlay["combined"]
+    screen.blit(
+        combined_surface,
+        combined_surface.get_rect(center=fov_center_tuple),
+    )
+
+
+def _draw_need_fuel_message(
+    screen: surface.Surface,
+    assets: RenderAssets,
+    *,
+    has_fuel: bool,
+    fuel_message_until: int,
+    elapsed_play_ms: int,
+) -> None:
+    if has_fuel or fuel_message_until <= elapsed_play_ms:
+        return
+    show_message(
+        screen,
+        tr("hud.need_fuel"),
+        18,
+        ORANGE,
+        (assets.screen_width // 2, assets.screen_height // 2),
+    )
+
+
+def _draw_objective(lines: list[str], *, screen: surface.Surface) -> None:
+    try:
+        font_settings = get_font_settings()
+        font = load_font(font_settings.resource, font_settings.scaled_size(11))
+        y = 8
+        for line in lines:
+            text_surface = font.render(line, False, YELLOW)
+            text_rect = text_surface.get_rect(topleft=(12, y))
+            screen.blit(text_surface, text_rect)
+            y += text_rect.height + 4
+    except pygame.error as e:
+        print(f"Error rendering objective: {e}")
+
+
+def _draw_endurance_timer(
+    screen: surface.Surface,
+    assets: RenderAssets,
+    *,
+    stage: Stage | None,
+    state: Any,
+) -> None:
+    if not (stage and stage.endurance_stage):
+        return
+    goal_ms = state.endurance_goal_ms
+    if goal_ms <= 0:
+        return
+    elapsed_ms = max(0, min(goal_ms, state.endurance_elapsed_ms))
+    remaining_ms = max(0, goal_ms - elapsed_ms)
+    padding = 12
+    bar_height = 8
+    y_pos = assets.screen_height - assets.status_bar_height - bar_height - 10
+    bar_rect = pygame.Rect(
+        padding,
+        y_pos,
+        assets.screen_width - padding * 2,
+        bar_height,
+    )
+    track_surface = pygame.Surface((bar_rect.width, bar_rect.height), pygame.SRCALPHA)
+    track_surface.fill((0, 0, 0, 140))
+    screen.blit(track_surface, bar_rect.topleft)
+    progress_ratio = elapsed_ms / goal_ms if goal_ms else 0.0
+    progress_width = int(bar_rect.width * max(0.0, min(1.0, progress_ratio)))
+    if progress_width > 0:
+        fill_color = (120, 20, 20)
+        if state.dawn_ready:
+            fill_color = (25, 40, 120)
+        fill_rect = pygame.Rect(
+            bar_rect.left,
+            bar_rect.top,
+            progress_width,
+            bar_rect.height,
         )
-        track_surface.fill((0, 0, 0, 140))
-        screen.blit(track_surface, bar_rect.topleft)
-        progress_ratio = elapsed_ms / goal_ms if goal_ms else 0.0
-        progress_width = int(bar_rect.width * max(0.0, min(1.0, progress_ratio)))
-        if progress_width > 0:
-            fill_color = (120, 20, 20)
-            if state.dawn_ready:
-                fill_color = (25, 40, 120)
-            fill_rect = pygame.Rect(
-                bar_rect.left,
-                bar_rect.top,
-                progress_width,
-                bar_rect.height,
+        pygame.draw.rect(screen, fill_color, fill_rect)
+    display_ms = int(remaining_ms * SURVIVAL_FAKE_CLOCK_RATIO)
+    display_ms = max(0, display_ms)
+    display_hours = display_ms // 3_600_000
+    display_minutes = (display_ms % 3_600_000) // 60_000
+    display_label = f"{int(display_hours):02d}:{int(display_minutes):02d}"
+    timer_text = tr("hud.endurance_timer_label", time=display_label)
+    try:
+        font_settings = get_font_settings()
+        font = load_font(font_settings.resource, font_settings.scaled_size(12))
+        text_surface = font.render(timer_text, False, LIGHT_GRAY)
+        text_rect = text_surface.get_rect(left=bar_rect.left, bottom=bar_rect.top - 2)
+        screen.blit(text_surface, text_rect)
+        if state.time_accel_active:
+            accel_text = tr("hud.time_accel")
+            accel_surface = font.render(accel_text, False, YELLOW)
+            accel_rect = accel_surface.get_rect(
+                right=bar_rect.right, bottom=bar_rect.top - 2
             )
-            pygame.draw.rect(screen, fill_color, fill_rect)
-        display_ms = int(remaining_ms * SURVIVAL_FAKE_CLOCK_RATIO)
-        display_ms = max(0, display_ms)
-        display_hours = display_ms // 3_600_000
-        display_minutes = (display_ms % 3_600_000) // 60_000
-        display_label = f"{int(display_hours):02d}:{int(display_minutes):02d}"
-        timer_text = tr("hud.survival_timer_label", time=display_label)
-        try:
-            font_settings = get_font_settings()
-            font = load_font(font_settings.resource, font_settings.scaled_size(12))
-            text_surface = font.render(timer_text, False, LIGHT_GRAY)
-            text_rect = text_surface.get_rect(
-                left=bar_rect.left, bottom=bar_rect.top - 2
+            screen.blit(accel_surface, accel_rect)
+        else:
+            hint_text = tr("hud.time_accel_hint")
+            hint_surface = font.render(hint_text, False, LIGHT_GRAY)
+            hint_rect = hint_surface.get_rect(
+                right=bar_rect.right, bottom=bar_rect.top - 2
             )
-            screen.blit(text_surface, text_rect)
-            if state.time_accel_active:
-                accel_text = tr("hud.time_accel")
-                accel_surface = font.render(accel_text, False, YELLOW)
-                accel_rect = accel_surface.get_rect(
-                    right=bar_rect.right, bottom=bar_rect.top - 2
-                )
-                screen.blit(accel_surface, accel_rect)
-            else:
-                hint_text = tr("hud.time_accel_hint")
-                hint_surface = font.render(hint_text, False, LIGHT_GRAY)
-                hint_rect = hint_surface.get_rect(
-                    right=bar_rect.right, bottom=bar_rect.top - 2
-                )
-                screen.blit(hint_surface, hint_rect)
-        except pygame.error as e:
-            print(f"Error rendering survival timer: {e}")
-
-    def _render_time_accel_indicator() -> None:
-        if stage and stage.survival_stage:
-            return
-        try:
-            font_settings = get_font_settings()
-            font = load_font(font_settings.resource, font_settings.scaled_size(12))
-            if state.time_accel_active:
-                text = tr("hud.time_accel")
-                color = YELLOW
-            else:
-                text = tr("hud.time_accel_hint")
-                color = LIGHT_GRAY
-            text_surface = font.render(text, False, color)
-            bottom_margin = assets.status_bar_height + 6
-            text_rect = text_surface.get_rect(
-                right=assets.screen_width - 12,
-                bottom=assets.screen_height - bottom_margin,
+            screen.blit(hint_surface, hint_rect)
+    except pygame.error as e:
+        print(f"Error rendering endurance timer: {e}")
+
+
+def _draw_time_accel_indicator(
+    screen: surface.Surface,
+    assets: RenderAssets,
+    *,
+    stage: Stage | None,
+    state: Any,
+) -> None:
+    if stage and stage.endurance_stage:
+        return
+    try:
+        font_settings = get_font_settings()
+        font = load_font(font_settings.resource, font_settings.scaled_size(12))
+        if state.time_accel_active:
+            text = tr("hud.time_accel")
+            color = YELLOW
+        else:
+            text = tr("hud.time_accel_hint")
+            color = LIGHT_GRAY
+        text_surface = font.render(text, False, color)
+        bottom_margin = assets.status_bar_height + 6
+        text_rect = text_surface.get_rect(
+            right=assets.screen_width - 12,
+            bottom=assets.screen_height - bottom_margin,
+        )
+        screen.blit(text_surface, text_rect)
+    except pygame.error as e:
+        print(f"Error rendering acceleration indicator: {e}")
+
+
+def _draw_survivor_messages(
+    screen: surface.Surface,
+    assets: RenderAssets,
+    survivor_messages: list[dict[str, Any]],
+) -> None:
+    if not survivor_messages:
+        return
+    try:
+        font_settings = get_font_settings()
+        font = load_font(font_settings.resource, font_settings.scaled_size(14))
+        base_y = assets.screen_height // 2 - 70
+        for idx, message in enumerate(survivor_messages[:3]):
+            text = message.get("text", "")
+            if not text:
+                continue
+            msg_surface = font.render(text, False, ORANGE)
+            msg_rect = msg_surface.get_rect(
+                center=(assets.screen_width // 2, base_y + idx * 18)
             )
-            screen.blit(text_surface, text_rect)
-        except pygame.error as e:
-            print(f"Error rendering acceleration indicator: {e}")
+            screen.blit(msg_surface, msg_rect)
+    except pygame.error as e:
+        print(f"Error rendering survivor message: {e}")
 
+
+def _build_objective_lines(
+    *,
+    stage: Stage | None,
+    state: Any,
+    player: Player,
+    active_car: Car | None,
+    has_fuel: bool,
+    buddy_onboard: int,
+    buddy_required: int,
+    survivors_onboard: int,
+) -> list[str]:
     objective_lines: list[str] = []
-    if stage and stage.survival_stage:
+    if stage and stage.endurance_stage:
         if state.dawn_ready:
             objective_lines.append(tr("objectives.get_outside"))
         else:
@@ -807,29 +1170,141 @@ def draw(
         objective_lines.append(
             tr("objectives.survivors_onboard", count=survivors_onboard, limit=limit)
         )
+    return objective_lines
 
-    if objective_lines:
-        _render_objective(objective_lines)
-    if survivor_messages:
-        try:
-            font_settings = get_font_settings()
-            font = load_font(font_settings.resource, font_settings.scaled_size(14))
-            base_y = assets.screen_height // 2 - 70
-            for idx, message in enumerate(survivor_messages[:3]):
-                text = message.get("text", "")
-                if not text:
-                    continue
-                msg_surface = font.render(text, False, ORANGE)
-                msg_rect = msg_surface.get_rect(
-                    center=(assets.screen_width // 2, base_y + idx * 18)
-                )
-                screen.blit(msg_surface, msg_rect)
-        except pygame.error as e:
-            print(f"Error rendering survivor message: {e}")
-    if stage and stage.survival_stage:
-        _render_survival_timer()
+
+def draw(
+    assets: RenderAssets,
+    screen: surface.Surface,
+    game_data: GameData,
+    *,
+    config: dict[str, Any],
+    hint_target: tuple[int, int] | None = None,
+    hint_color: tuple[int, int, int] | None = None,
+    do_flip: bool = True,
+    present_fn: Callable[[surface.Surface], None] | None = None,
+) -> None:
+    hint_color = hint_color or YELLOW
+    state = game_data.state
+    player = game_data.player
+    if player is None:
+        raise ValueError("draw requires an active player on game_data")
+
+    camera = game_data.camera
+    stage = game_data.stage
+    outer_rect = game_data.layout.outer_rect
+    outside_rects = game_data.layout.outside_rects or []
+    all_sprites = game_data.groups.all_sprites
+    fog_surfaces = game_data.fog
+    footprints = state.footprints
+    has_fuel = state.has_fuel
+    flashlight_count = state.flashlight_count
+    elapsed_play_ms = state.elapsed_play_ms
+    fuel_message_until = state.fuel_message_until
+    buddy_onboard = state.buddy_onboard
+    buddy_required = stage.buddy_required_count if stage else 0
+    survivors_onboard = state.survivors_onboard
+    survivor_messages = list(state.survivor_messages)
+    zombie_group = game_data.groups.zombie_group
+    active_car = game_data.car if game_data.car and game_data.car.alive() else None
+    if player.in_car and game_data.car and game_data.car.alive():
+        fov_target = game_data.car
     else:
-        _render_time_accel_indicator()
+        fov_target = player
+
+    palette = get_environment_palette(state.ambient_palette_key)
+    screen.fill(palette.outside)
+
+    _draw_play_area(
+        screen,
+        camera,
+        assets,
+        palette,
+        outer_rect,
+        outside_rects,
+        game_data.layout.fall_spawn_cells,
+    )
+    _draw_wall_shadows(
+        screen,
+        camera,
+        wall_cells=game_data.layout.wall_cells,
+        wall_group=game_data.groups.wall_group,
+        outer_wall_cells=game_data.layout.outer_wall_cells,
+        cell_size=game_data.cell_size,
+        light_source_pos=(
+            None
+            if (stage and stage.endurance_stage and state.dawn_ready)
+            else fov_target.rect.center
+        )
+        if fov_target
+        else None,
+    )
+    _draw_footprints(
+        screen,
+        camera,
+        assets,
+        footprints,
+        config=config,
+    )
+    _draw_entities(
+        screen,
+        camera,
+        all_sprites,
+        player,
+        has_fuel=has_fuel,
+    )
+
+    _draw_falling_fx(
+        screen,
+        camera,
+        state.falling_zombies,
+        state.flashlight_count,
+        state.dust_rings,
+    )
+
+    _draw_hint_indicator(
+        screen,
+        camera,
+        assets,
+        player,
+        hint_target,
+        hint_color=hint_color,
+        stage=stage,
+        flashlight_count=flashlight_count,
+    )
+    _draw_fog_of_war(
+        screen,
+        camera,
+        assets,
+        fog_surfaces,
+        fov_target,
+        stage=stage,
+        flashlight_count=flashlight_count,
+        dawn_ready=state.dawn_ready,
+    )
+    _draw_need_fuel_message(
+        screen,
+        assets,
+        has_fuel=has_fuel,
+        fuel_message_until=fuel_message_until,
+        elapsed_play_ms=elapsed_play_ms,
+    )
+
+    objective_lines = _build_objective_lines(
+        stage=stage,
+        state=state,
+        player=player,
+        active_car=active_car,
+        has_fuel=has_fuel,
+        buddy_onboard=buddy_onboard,
+        buddy_required=buddy_required,
+        survivors_onboard=survivors_onboard,
+    )
+    if objective_lines:
+        _draw_objective(objective_lines, screen=screen)
+    _draw_survivor_messages(screen, assets, survivor_messages)
+    _draw_endurance_timer(screen, assets, stage=stage, state=state)
+    _draw_time_accel_indicator(screen, assets, stage=stage, state=state)
     _draw_status_bar(
         screen,
         assets,
@@ -838,6 +1313,7 @@ def draw(
         seed=state.seed,
         debug_mode=state.debug_mode,
         zombie_group=zombie_group,
+        falling_spawn_carry=state.falling_spawn_carry,
     )
     if do_flip:
         if present_fn: