zombie-escape 1.10.1__py3-none-any.whl → 1.12.3__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,11 +46,25 @@ 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,
@@ -49,6 +73,10 @@ from .render_constants import (
 
 _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(
@@ -113,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,
@@ -149,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,
@@ -195,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():
@@ -233,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."""
@@ -241,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:
@@ -262,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":
@@ -601,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(
@@ -646,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
@@ -663,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}")
 
@@ -672,11 +807,16 @@ def _draw_play_area(
     camera: Camera,
     assets: RenderAssets,
     palette: Any,
-    outer_rect: tuple[int, int, int, int],
-    outside_rects: list[pygame.Rect],
+    field_rect: pygame.Rect,
+    outside_cells: set[tuple[int, int]],
     fall_spawn_cells: set[tuple[int, int]],
 ) -> tuple[int, int, int, int, set[tuple[int, int]]]:
-    xs, ys, xe, ye = outer_rect
+    xs, ys, xe, ye = (
+        field_rect.left,
+        field_rect.top,
+        field_rect.right,
+        field_rect.bottom,
+    )
     xs //= assets.internal_wall_grid_snap
     ys //= assets.internal_wall_grid_snap
     xe //= assets.internal_wall_grid_snap
@@ -691,15 +831,6 @@ def _draw_play_area(
     play_area_screen_rect = camera.apply_rect(play_area_rect)
     pygame.draw.rect(screen, palette.floor_primary, play_area_screen_rect)
 
-    outside_cells = {
-        (r.x // assets.internal_wall_grid_snap, r.y // assets.internal_wall_grid_snap)
-        for r in outside_rects
-    }
-    for rect_obj in outside_rects:
-        sr = camera.apply_rect(rect_obj)
-        if sr.colliderect(screen.get_rect()):
-            pygame.draw.rect(screen, palette.outside, sr)
-
     view_world = pygame.Rect(
         -camera.camera.x,
         -camera.camera.y,
@@ -720,6 +851,19 @@ def _draw_play_area(
     for y in range(start_y, end_y):
         for x in range(start_x, end_x):
             if (x, y) in outside_cells:
+                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(r)
+                if sr.colliderect(screen.get_rect()):
+                    pygame.draw.rect(screen, palette.outside, sr)
                 continue
             use_secondary = ((x // 2) + (y // 2)) % 2 == 0
             if (x, y) in fall_spawn_cells:
@@ -760,7 +904,7 @@ def abs_clip(value: float, min_v: float, max_v: float) -> float:
 
 
 def _draw_wall_shadows(
-    screen: surface.Surface,
+    shadow_layer: surface.Surface,
     camera: Camera,
     *,
     wall_cells: set[tuple[int, int]],
@@ -769,9 +913,9 @@ def _draw_wall_shadows(
     cell_size: int,
     light_source_pos: tuple[int, int] | None,
     alpha: int = 68,
-) -> None:
+) -> 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)
@@ -782,13 +926,15 @@ 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
     drew = False
     clip_max = shadow_size * 0.25
@@ -813,11 +959,140 @@ def _draw_wall_shadows(
         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,
+    outside_cells: set[tuple[int, int]] | None,
+    cell_size: int,
+    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
+    if cell_size <= 0:
+        outside_cells = None
+    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
+        if outside_cells:
+            cell = (
+                int(entity.rect.centerx // cell_size),
+                int(entity.rect.centery // cell_size),
+            )
+            if cell in outside_cells:
+                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,
+    outside_cells: set[tuple[int, int]] | None,
+    cell_size: int,
+    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
+    if outside_cells and cell_size > 0:
+        cell = (
+            int(entity.rect.centerx // cell_size),
+            int(entity.rect.centery // cell_size),
+        )
+        if cell in outside_cells:
+            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(
@@ -906,11 +1181,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,
@@ -995,6 +1266,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,
@@ -1183,6 +1483,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
@@ -1192,13 +1493,14 @@ def draw(
 
     camera = game_data.camera
     stage = game_data.stage
-    outer_rect = game_data.layout.outer_rect
-    outside_rects = game_data.layout.outside_rects or []
+    field_rect = game_data.layout.field_rect
+    outside_cells = game_data.layout.outside_cells
     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
+    shoes_count = state.shoes_count
     elapsed_play_ms = state.elapsed_play_ms
     fuel_message_until = state.fuel_message_until
     buddy_onboard = state.buddy_onboard
@@ -1220,12 +1522,14 @@ def draw(
         camera,
         assets,
         palette,
-        outer_rect,
-        outside_rects,
+        field_rect,
+        outside_cells,
         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,
@@ -1239,6 +1543,41 @@ def draw(
         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,
+        outside_cells=outside_cells,
+        cell_size=game_data.cell_size,
+    )
+    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,
+            outside_cells=outside_cells,
+            cell_size=game_data.cell_size,
+            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,
+            outside_cells=outside_cells,
+            cell_size=game_data.cell_size,
+            shadow_radius=player_shadow_radius,
+            alpha=player_shadow_alpha,
+        )
+    if drew_shadow:
+        screen.blit(shadow_layer, (0, 0))
     _draw_footprints(
         screen,
         camera,
@@ -1302,6 +1641,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)
@@ -1314,6 +1660,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: