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

zombie_escape/render.py

@@ -23,11 +23,21 @@ from .entities import (
     Flashlight,
     FuelCan,
     Player,
+    Shoes,
     SteelBeam,
     Survivor,
     Wall,
+    Zombie,
+)
+from .entities_constants import (
+    FLASHLIGHT_HEIGHT,
+    FLASHLIGHT_WIDTH,
+    FUEL_CAN_HEIGHT,
+    FUEL_CAN_WIDTH,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
+    ZOMBIE_RADIUS,
 )
-from .entities_constants import ZOMBIE_RADIUS
 from .font_utils import load_font
 from .gameplay_constants import (
     DEFAULT_FLASHLIGHT_SPAWN_COUNT,
@@ -36,15 +46,37 @@ from .gameplay_constants import (
 from .localization import get_font_settings
 from .localization import translate as tr
 from .models import DustRing, FallingZombie, Footprint, GameData, Stage
-from .render_assets import RenderAssets, resolve_steel_beam_colors, resolve_wall_colors
+from .render_assets import (
+    RenderAssets,
+    build_flashlight_surface,
+    build_fuel_can_surface,
+    build_shoes_surface,
+    resolve_steel_beam_colors,
+    resolve_wall_colors,
+)
 from .render_constants import (
+    ENTITY_SHADOW_ALPHA,
+    ENTITY_SHADOW_EDGE_SOFTNESS,
+    ENTITY_SHADOW_RADIUS_MULT,
     FALLING_DUST_COLOR,
     FALLING_WHIRLWIND_COLOR,
     FALLING_ZOMBIE_COLOR,
+    FLASHLIGHT_FOG_SCALE_ONE,
+    FLASHLIGHT_FOG_SCALE_TWO,
+    PLAYER_SHADOW_ALPHA_MULT,
+    PLAYER_SHADOW_RADIUS_MULT,
+    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] = {}
+_SHADOW_CIRCLE_CACHE: dict[tuple[int, int, float], surface.Surface] = {}
+_HUD_ICON_CACHE: dict[str, surface.Surface] = {}
+
+HUD_ICON_SIZE = 12
 
 
 def _get_shadow_tile_surface(
@@ -57,34 +89,45 @@ def _get_shadow_tile_surface(
     if key in _SHADOW_TILE_CACHE:
         return _SHADOW_TILE_CACHE[key]
     size = key[0]
-    surf = pygame.Surface((size, size), pygame.SRCALPHA)
+    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:
-        surf.fill((0, 0, 0, base_alpha))
+        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(size * softness))
-    base_radius = max(1, int(size * 0.18))
-
-    def draw_layer(inset: int, layer_alpha: int) -> None:
-        rect_size = size - inset * 2
+    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:
-            return
+            continue
         radius = max(0, base_radius - inset)
+        layer_alpha = int(base_alpha * (min_ratio + (1.0 - min_ratio) * t))
         pygame.draw.rect(
-            surf,
+            render_surf,
             (0, 0, 0, layer_alpha),
             pygame.Rect(inset, inset, rect_size, rect_size),
             border_radius=radius,
         )
 
-    outer_alpha = int(base_alpha * 0.45)
-    mid_alpha = int(base_alpha * 0.7)
-    draw_layer(0, outer_alpha)
-    draw_layer(max(1, fade_band // 2), mid_alpha)
-    draw_layer(fade_band, base_alpha)
+    if oversample > 1:
+        surf = pygame.transform.smoothscale(render_surf, (size, size))
+    else:
+        surf = render_surf
     _SHADOW_TILE_CACHE[key] = surf
     return surf
 
@@ -98,6 +141,98 @@ def _get_shadow_layer(size: tuple[int, int]) -> surface.Surface:
     return layer
 
 
+def _scale_icon_to_box(icon: surface.Surface, size: int) -> surface.Surface:
+    target_size = max(1, size)
+    width = max(1, icon.get_width())
+    height = max(1, icon.get_height())
+    scale = min(target_size / width, target_size / height)
+    target_width = max(1, int(width * scale))
+    target_height = max(1, int(height * scale))
+    scaled = pygame.transform.smoothscale(icon, (target_width, target_height))
+    boxed = pygame.Surface((target_size, target_size), pygame.SRCALPHA)
+    boxed.blit(
+        scaled,
+        (
+            (target_size - target_width) // 2,
+            (target_size - target_height) // 2,
+        ),
+    )
+    return boxed
+
+
+def _get_hud_icon(kind: str) -> surface.Surface:
+    cached = _HUD_ICON_CACHE.get(kind)
+    if cached is not None:
+        return cached
+    if kind == "fuel":
+        icon = build_fuel_can_surface(FUEL_CAN_WIDTH, FUEL_CAN_HEIGHT)
+    elif kind == "flashlight":
+        icon = build_flashlight_surface(FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT)
+    elif kind == "shoes":
+        icon = build_shoes_surface(SHOES_WIDTH, SHOES_HEIGHT)
+    else:
+        icon = pygame.Surface((1, 1), pygame.SRCALPHA)
+    icon = _scale_icon_to_box(icon, HUD_ICON_SIZE)
+    _HUD_ICON_CACHE[kind] = icon
+    return icon
+
+
+def _get_shadow_circle_surface(
+    radius: int,
+    alpha: int,
+    *,
+    edge_softness: float = 0.12,
+) -> surface.Surface:
+    key = (max(1, radius), max(0, min(255, alpha)), edge_softness)
+    if key in _SHADOW_CIRCLE_CACHE:
+        return _SHADOW_CIRCLE_CACHE[key]
+    radius = key[0]
+    oversample = SHADOW_OVERSAMPLE
+    render_radius = radius * oversample
+    render_size = render_radius * 2
+    render_surf = pygame.Surface((render_size, render_size), pygame.SRCALPHA)
+    base_alpha = key[1]
+    if edge_softness <= 0:
+        pygame.draw.circle(
+            render_surf,
+            (0, 0, 0, base_alpha),
+            (render_radius, render_radius),
+            render_radius,
+        )
+        if oversample > 1:
+            surf = pygame.transform.smoothscale(render_surf, (radius * 2, radius * 2))
+        else:
+            surf = render_surf
+        _SHADOW_CIRCLE_CACHE[key] = surf
+        return surf
+
+    softness = max(0.0, min(1.0, edge_softness))
+    fade_band = max(1, int(render_radius * softness))
+    steps = SHADOW_STEPS
+    min_ratio = SHADOW_MIN_RATIO
+    render_surf.fill((0, 0, 0, 0))
+    for idx in range(steps):
+        t = idx / (steps - 1) if steps > 1 else 1.0
+        inset = int(fade_band * t)
+        circle_radius = render_radius - inset
+        if circle_radius <= 0:
+            continue
+        layer_alpha = int(base_alpha * (min_ratio + (1.0 - min_ratio) * t))
+        pygame.draw.circle(
+            render_surf,
+            (0, 0, 0, layer_alpha),
+            (render_radius, render_radius),
+            circle_radius,
+        )
+
+    if oversample > 1:
+        surf = pygame.transform.smoothscale(render_surf, (radius * 2, radius * 2))
+    else:
+        surf = render_surf
+    _SHADOW_CIRCLE_CACHE[key] = surf
+    return surf
+
+
 def show_message(
     screen: surface.Surface,
     text: str,
@@ -134,7 +269,7 @@ def draw_level_overview(
     *,
     fuel: FuelCan | None = None,
     flashlights: list[Flashlight] | None = None,
-    stage: Stage | None = None,
+    shoes: list[Shoes] | None = None,
     buddies: list[Survivor] | None = None,
     survivors: list[Survivor] | None = None,
     palette_key: str | None = None,
@@ -180,11 +315,15 @@ def draw_level_overview(
         for flashlight in flashlights:
             if flashlight.alive():
                 pygame.draw.rect(
-                    surface, (240, 230, 150), flashlight.rect, border_radius=2
+                    surface, YELLOW, flashlight.rect, border_radius=2
                 )
                 pygame.draw.rect(
                     surface, BLACK, flashlight.rect, width=2, border_radius=2
                 )
+    if shoes:
+        for item in shoes:
+            if item.alive():
+                surface.blit(item.image, item.rect)
     if survivors:
         for survivor in survivors:
             if survivor.alive():
@@ -218,7 +357,6 @@ def draw_level_overview(
 
 def _get_fog_scale(
     assets: RenderAssets,
-    stage: Stage | None,
     flashlight_count: int,
 ) -> float:
     """Return current fog scale factoring in flashlight bonus."""
@@ -226,8 +364,9 @@ def _get_fog_scale(
     flashlight_count = max(0, int(flashlight_count))
     if flashlight_count <= 0:
         return scale
-    bonus_step = max(0.0, assets.flashlight_bonus_step)
-    return scale + bonus_step * flashlight_count
+    if flashlight_count == 1:
+        return max(scale, FLASHLIGHT_FOG_SCALE_ONE)
+    return max(scale, FLASHLIGHT_FOG_SCALE_TWO)
 
 
 def _max_flashlight_pickups() -> int:
@@ -247,7 +386,7 @@ class FogProfile(Enum):
 
     def _scale(self, assets: RenderAssets, stage: Stage | None) -> float:
         count = max(0, min(self.flashlight_count, _max_flashlight_pickups()))
-        return _get_fog_scale(assets, stage, count)
+        return _get_fog_scale(assets, count)
 
     @staticmethod
     def _from_flashlight_count(count: int) -> "FogProfile":
@@ -280,19 +419,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 = [
@@ -306,14 +447,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
@@ -354,7 +501,6 @@ 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()
@@ -390,7 +536,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."""
 
@@ -579,6 +725,7 @@ def _draw_status_bar(
     debug_mode: bool = False,
     zombie_group: sprite.Group | None = None,
     falling_spawn_carry: int | None = None,
+    fps: float | None = None,
 ) -> None:
     """Render a compact status bar with current config flags and stage info."""
     bar_rect = pygame.Rect(
@@ -597,7 +744,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"
 
@@ -620,6 +771,8 @@ def _draw_status_bar(
             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)}")
+        if fps is not None:
+            parts.append(f"FPS:{fps:.1f}")
 
     status_text = " | ".join(parts)
     color = LIGHT_GRAY
@@ -637,6 +790,14 @@ def _draw_status_bar(
                 right=bar_rect.right - 12, centery=bar_rect.centery
             )
             screen.blit(seed_surface, seed_rect)
+        if debug_mode and fps is not None:
+            fps_text = f"FPS:{fps:.1f}"
+            fps_surface = font.render(fps_text, False, LIGHT_GRAY)
+            fps_rect = fps_surface.get_rect(
+                left=12,
+                bottom=max(2, bar_rect.top - 4),
+            )
+            screen.blit(fps_surface, fps_rect)
     except pygame.error as e:
         print(f"Error rendering status bar: {e}")
 
@@ -723,8 +884,18 @@ def _draw_play_area(
     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,
+    shadow_layer: surface.Surface,
     camera: Camera,
     *,
     wall_cells: set[tuple[int, int]],
@@ -732,10 +903,10 @@ def _draw_wall_shadows(
     outer_wall_cells: set[tuple[int, int]] | None,
     cell_size: int,
     light_source_pos: tuple[int, int] | None,
-    alpha: int = 54,
-) -> None:
+    alpha: int = 68,
+) -> bool:
     if not wall_cells or cell_size <= 0 or light_source_pos is None:
-        return
+        return False
     inner_wall_cells = set(wall_cells)
     if outer_wall_cells:
         inner_wall_cells.difference_update(outer_wall_cells)
@@ -746,41 +917,153 @@ def _draw_wall_shadows(
                 cell_y = int(wall.rect.centery // cell_size)
                 inner_wall_cells.add((cell_x, cell_y))
     if not inner_wall_cells:
-        return
+        return False
     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()
+    shadow_surface = _get_shadow_tile_surface(
+        shadow_size,
+        alpha,
+        edge_softness=0.12,
+    )
+    screen_rect = shadow_layer.get_rect()
     px, py = light_source_pos
-    offset = max(2, int(cell_size * 0.3 * (shadow_size / cell_size) * 1.2))
     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
-        dy = center_y - py
-        dist = math.hypot(dx, dy)
-        if dist <= 1e-3:
-            continue
-        nx = dx / dist
-        ny = dy / dist
+        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 + nx * offset),
-            int(center_y + ny * offset),
+            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)
+        shadow_layer.blit(
+            shadow_surface,
+            shadow_screen_rect.topleft,
+            special_flags=pygame.BLEND_RGBA_MAX,
+        )
         drew = True
-    if drew:
-        shadow_layer.set_alpha(alpha)
-        screen.blit(shadow_layer, (0, 0))
+    return drew
+
+
+def _draw_entity_shadows(
+    shadow_layer: surface.Surface,
+    camera: Camera,
+    all_sprites: sprite.LayeredUpdates,
+    *,
+    light_source_pos: tuple[int, int] | None,
+    exclude_car: Car | None,
+    shadow_radius: int = int(ZOMBIE_RADIUS * ENTITY_SHADOW_RADIUS_MULT),
+    alpha: int = ENTITY_SHADOW_ALPHA,
+) -> bool:
+    if light_source_pos is None or shadow_radius <= 0:
+        return False
+    shadow_surface = _get_shadow_circle_surface(
+        shadow_radius,
+        alpha,
+        edge_softness=ENTITY_SHADOW_EDGE_SOFTNESS,
+    )
+    screen_rect = shadow_layer.get_rect()
+    px, py = light_source_pos
+    offset_dist = max(1.0, shadow_radius * 0.6)
+    drew = False
+    for entity in all_sprites:
+        if not entity.alive():
+            continue
+        if isinstance(entity, Player):
+            continue
+        if isinstance(entity, Car):
+            if exclude_car is not None and entity is exclude_car:
+                continue
+        if not isinstance(entity, (Zombie, Survivor, Car)):
+            continue
+        cx, cy = entity.rect.center
+        dx = cx - px
+        dy = cy - py
+        dist = math.hypot(dx, dy)
+        if dist > 0.001:
+            scale = offset_dist / dist
+            offset_x = dx * scale
+            offset_y = dy * scale
+        else:
+            offset_x = 0.0
+            offset_y = 0.0
+        shadow_rect = shadow_surface.get_rect(
+            center=(int(cx + offset_x), int(cy + offset_y))
+        )
+        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,
+            special_flags=pygame.BLEND_RGBA_MAX,
+        )
+        drew = True
+    return drew
+
+
+def _draw_single_entity_shadow(
+    shadow_layer: surface.Surface,
+    camera: Camera,
+    *,
+    entity: pygame.sprite.Sprite | None,
+    light_source_pos: tuple[int, int] | None,
+    shadow_radius: int,
+    alpha: int,
+    edge_softness: float = ENTITY_SHADOW_EDGE_SOFTNESS,
+) -> bool:
+    if (
+        entity is None
+        or not entity.alive()
+        or light_source_pos is None
+        or shadow_radius <= 0
+    ):
+        return False
+    shadow_surface = _get_shadow_circle_surface(
+        shadow_radius,
+        alpha,
+        edge_softness=edge_softness,
+    )
+    screen_rect = shadow_layer.get_rect()
+    px, py = light_source_pos
+    cx, cy = entity.rect.center
+    dx = cx - px
+    dy = cy - py
+    dist = math.hypot(dx, dy)
+    offset_dist = max(1.0, shadow_radius * 0.6)
+    if dist > 0.001:
+        scale = offset_dist / dist
+        offset_x = dx * scale
+        offset_y = dy * scale
+    else:
+        offset_x = 0.0
+        offset_y = 0.0
+    shadow_rect = shadow_surface.get_rect(
+        center=(int(cx + offset_x), int(cy + offset_y))
+    )
+    shadow_screen_rect = camera.apply_rect(shadow_rect)
+    if not shadow_screen_rect.colliderect(screen_rect):
+        return False
+    shadow_layer.blit(
+        shadow_surface,
+        shadow_screen_rect.topleft,
+        special_flags=pygame.BLEND_RGBA_MAX,
+    )
+    return True
 
 
 def _draw_footprints(
@@ -869,11 +1152,7 @@ def _draw_hint_indicator(
 ) -> None:
     if not hint_target:
         return
-    current_fov_scale = _get_fog_scale(
-        assets,
-        stage,
-        flashlight_count,
-    )
+    current_fov_scale = _get_fog_scale(assets, flashlight_count)
     hint_ring_radius = assets.fov_radius * 0.5 * current_fov_scale
     _draw_hint_arrow(
         screen,
@@ -958,6 +1237,35 @@ def _draw_objective(lines: list[str], *, screen: surface.Surface) -> None:
         print(f"Error rendering objective: {e}")
 
 
+def _draw_inventory_icons(
+    screen: surface.Surface,
+    assets: RenderAssets,
+    *,
+    has_fuel: bool,
+    flashlight_count: int,
+    shoes_count: int,
+) -> None:
+    icons: list[surface.Surface] = []
+    if has_fuel:
+        icons.append(_get_hud_icon("fuel"))
+    for _ in range(max(0, int(flashlight_count))):
+        icons.append(_get_hud_icon("flashlight"))
+    for _ in range(max(0, int(shoes_count))):
+        icons.append(_get_hud_icon("shoes"))
+    if not icons:
+        return
+    spacing = 3
+    padding = 8
+    total_width = sum(icon.get_width() for icon in icons)
+    total_width += spacing * max(0, len(icons) - 1)
+    start_x = assets.screen_width - padding - total_width
+    y = 8
+    x = max(padding, start_x)
+    for icon in icons:
+        screen.blit(icon, (x, y))
+        x += icon.get_width() + spacing
+
+
 def _draw_endurance_timer(
     screen: surface.Surface,
     assets: RenderAssets,
@@ -1146,6 +1454,7 @@ def draw(
     hint_color: tuple[int, int, int] | None = None,
     do_flip: bool = True,
     present_fn: Callable[[surface.Surface], None] | None = None,
+    fps: float | None = None,
 ) -> None:
     hint_color = hint_color or YELLOW
     state = game_data.state
@@ -1162,6 +1471,7 @@ def draw(
     footprints = state.footprints
     has_fuel = state.has_fuel
     flashlight_count = state.flashlight_count
+    shoes_count = state.shoes_count
     elapsed_play_ms = state.elapsed_play_ms
     fuel_message_until = state.fuel_message_until
     buddy_onboard = state.buddy_onboard
@@ -1187,19 +1497,52 @@ def draw(
         outside_rects,
         game_data.layout.fall_spawn_cells,
     )
-    _draw_wall_shadows(
-        screen,
+    shadow_layer = _get_shadow_layer(screen.get_size())
+    shadow_layer.fill((0, 0, 0, 0))
+    drew_shadow = _draw_wall_shadows(
+        shadow_layer,
         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
+            None
+            if (stage and stage.endurance_stage and state.dawn_ready)
+            else fov_target.rect.center
         )
         if fov_target
         else None,
     )
+    drew_shadow |= _draw_entity_shadows(
+        shadow_layer,
+        camera,
+        all_sprites,
+        light_source_pos=fov_target.rect.center if fov_target else None,
+        exclude_car=active_car if player.in_car else None,
+    )
+    player_shadow_alpha = max(1, int(ENTITY_SHADOW_ALPHA * PLAYER_SHADOW_ALPHA_MULT))
+    player_shadow_radius = int(ZOMBIE_RADIUS * PLAYER_SHADOW_RADIUS_MULT)
+    if player.in_car:
+        drew_shadow |= _draw_single_entity_shadow(
+            shadow_layer,
+            camera,
+            entity=active_car,
+            light_source_pos=fov_target.rect.center if fov_target else None,
+            shadow_radius=player_shadow_radius,
+            alpha=player_shadow_alpha,
+        )
+    else:
+        drew_shadow |= _draw_single_entity_shadow(
+            shadow_layer,
+            camera,
+            entity=player,
+            light_source_pos=fov_target.rect.center if fov_target else None,
+            shadow_radius=player_shadow_radius,
+            alpha=player_shadow_alpha,
+        )
+    if drew_shadow:
+        screen.blit(shadow_layer, (0, 0))
     _draw_footprints(
         screen,
         camera,
@@ -1263,6 +1606,13 @@ def draw(
     )
     if objective_lines:
         _draw_objective(objective_lines, screen=screen)
+    _draw_inventory_icons(
+        screen,
+        assets,
+        has_fuel=has_fuel,
+        flashlight_count=flashlight_count,
+        shoes_count=shoes_count,
+    )
     _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)
@@ -1275,6 +1625,7 @@ def draw(
         debug_mode=state.debug_mode,
         zombie_group=zombie_group,
         falling_spawn_carry=state.falling_spawn_carry,
+        fps=fps,
     )
     if do_flip:
         if present_fn: