zombie-escape 1.14.4__py3-none-any.whl → 1.15.2__py3-none-any.whl

zombie_escape/render/hud.py

@@ -7,7 +7,7 @@ import pygame
 from pygame import sprite, surface
 
 from ..colors import LIGHT_GRAY, ORANGE, YELLOW
-from ..entities import Camera, Car, Player
+from ..entities import Car, Player
 from ..entities_constants import (
     FLASHLIGHT_HEIGHT,
     FLASHLIGHT_WIDTH,
@@ -20,18 +20,25 @@ from ..font_utils import load_font
 from ..gameplay_constants import SURVIVAL_FAKE_CLOCK_RATIO
 from ..localization import get_font_settings
 from ..localization import translate as tr
-from ..models import Stage
+from ..models import Stage, TimedMessage
 from ..render_assets import (
     RenderAssets,
     build_flashlight_surface,
     build_fuel_can_surface,
     build_shoes_surface,
 )
-from ..render_constants import FLASHLIGHT_FOG_SCALE_ONE, FLASHLIGHT_FOG_SCALE_TWO
+from ..render_constants import (
+    FLASHLIGHT_FOG_SCALE_ONE,
+    FLASHLIGHT_FOG_SCALE_TWO,
+    GAMEPLAY_FONT_SIZE,
+    HUD_ICON_SIZE,
+    TIMED_MESSAGE_BAND_ALPHA,
+    TIMED_MESSAGE_LEFT_X,
+    TIMED_MESSAGE_TOP_Y,
+)
 
 _HUD_ICON_CACHE: dict[str, surface.Surface] = {}
 
-HUD_ICON_SIZE = 12
 
 
 def _scale_icon_to_box(icon: surface.Surface, size: int) -> surface.Surface:
@@ -133,7 +140,7 @@ def _draw_status_bar(
 
     try:
         font_settings = get_font_settings()
-        font = load_font(font_settings.resource, font_settings.scaled_size(11))
+        font = load_font(font_settings.resource, font_settings.scaled_size(GAMEPLAY_FONT_SIZE))
         text_surface = font.render(status_text, False, color)
         text_rect = text_surface.get_rect(left=12, centery=bar_rect.centery)
         screen.blit(text_surface, text_rect)
@@ -145,10 +152,7 @@ def _draw_status_bar(
         if show_fps 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),
-            )
+            fps_rect = fps_surface.get_rect(left=12, bottom=max(2, bar_rect.top))
             screen.blit(fps_surface, fps_rect)
     except pygame.error as e:
         print(f"Error rendering status bar: {e}")
@@ -157,7 +161,7 @@ def _draw_status_bar(
 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))
+        font = load_font(font_settings.resource, font_settings.scaled_size(GAMEPLAY_FONT_SIZE))
         y = 8
         for line in lines:
             text_surface = font.render(line, False, YELLOW)
@@ -212,8 +216,10 @@ def _draw_endurance_timer(
     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_height = 6
+    text_bottom = assets.screen_height - assets.status_bar_height - bar_height - 8
+    bar_overlap = 6
+    y_pos = text_bottom + 2 - bar_overlap
     bar_rect = pygame.Rect(
         padding,
         y_pos,
@@ -226,16 +232,18 @@ def _draw_endurance_timer(
     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)
+        fill_color = (120, 20, 20, 160)
         if state.dawn_ready:
-            fill_color = (25, 40, 120)
+            fill_color = (25, 40, 120, 160)
         fill_rect = pygame.Rect(
             bar_rect.left,
             bar_rect.top,
             progress_width,
             bar_rect.height,
         )
-        pygame.draw.rect(screen, fill_color, fill_rect)
+        fill_surface = pygame.Surface((progress_width, bar_rect.height), pygame.SRCALPHA)
+        fill_surface.fill(fill_color)
+        screen.blit(fill_surface, fill_rect.topleft)
     display_ms = int(remaining_ms * SURVIVAL_FAKE_CLOCK_RATIO)
     display_ms = max(0, display_ms)
     display_hours = display_ms // 3_600_000
@@ -244,19 +252,19 @@ def _draw_endurance_timer(
     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))
+        font = load_font(font_settings.resource, font_settings.scaled_size(GAMEPLAY_FONT_SIZE))
         text_surface = font.render(timer_text, False, LIGHT_GRAY)
-        text_rect = text_surface.get_rect(left=bar_rect.left, bottom=bar_rect.top - 2)
+        text_rect = text_surface.get_rect(left=bar_rect.left, bottom=text_bottom)
         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)
+            accel_rect = accel_surface.get_rect(right=bar_rect.right, bottom=text_bottom)
             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)
+            hint_rect = hint_surface.get_rect(right=bar_rect.right, bottom=text_bottom)
             screen.blit(hint_surface, hint_rect)
     except pygame.error as e:
         print(f"Error rendering endurance timer: {e}")
@@ -273,7 +281,7 @@ def _draw_time_accel_indicator(
         return
     try:
         font_settings = get_font_settings()
-        font = load_font(font_settings.resource, font_settings.scaled_size(12))
+        font = load_font(font_settings.resource, font_settings.scaled_size(GAMEPLAY_FONT_SIZE))
         if state.time_accel_active:
             text = tr("hud.time_accel")
             color = YELLOW
@@ -300,19 +308,69 @@ def _draw_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]):
+        font_size = font_settings.scaled_size(GAMEPLAY_FONT_SIZE * 2)
+        font = load_font(font_settings.resource, font_size)
+        line_height = int(round(font.get_linesize() * 2))
+        base_y = assets.screen_height // 2 - (line_height * 2)
+        for idx, message in enumerate(survivor_messages[:5]):
             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))
+            msg_rect = msg_surface.get_rect(center=(assets.screen_width // 2, base_y + idx * line_height))
             screen.blit(msg_surface, msg_rect)
     except pygame.error as e:
         print(f"Error rendering survivor message: {e}")
 
 
+def _draw_timed_message(
+    screen: surface.Surface,
+    assets: RenderAssets,
+    *,
+    message: TimedMessage | None,
+    elapsed_play_ms: int,
+) -> None:
+    if not message:
+        return
+    if message.expires_at_ms <= 0:
+        return
+    if elapsed_play_ms > message.expires_at_ms:
+        return
+    try:
+        font_settings = get_font_settings()
+        font_size = font_settings.scaled_size(GAMEPLAY_FONT_SIZE * 2)
+        font = load_font(font_settings.resource, font_size)
+        text_color = message.color or LIGHT_GRAY
+        line_height = int(round(font.get_linesize() * font_settings.line_height_scale))
+        lines = message.text.splitlines() or [message.text]
+        rendered_lines = [font.render(line, False, text_color) for line in lines]
+        max_width = max(surface.get_width() for surface in rendered_lines)
+        total_height = line_height * len(rendered_lines)
+        if message.align == "left":
+            text_rect = pygame.Rect(TIMED_MESSAGE_LEFT_X, TIMED_MESSAGE_TOP_Y, max_width, total_height)
+        else:
+            center_x = assets.screen_width // 2
+            center_y = assets.screen_height // 2
+            text_rect = pygame.Rect(0, 0, max_width, total_height)
+            text_rect.center = (center_x, center_y)
+        padding_x = 16
+        padding_y = max(8, int(round(line_height * 0.35)))
+        band_rect = text_rect.inflate(padding_x * 2, padding_y * 2)
+        band_surface = pygame.Surface(band_rect.size, pygame.SRCALPHA)
+        band_surface.fill((0, 0, 0, TIMED_MESSAGE_BAND_ALPHA))
+        screen.blit(band_surface, band_rect.topleft)
+        y = text_rect.top
+        for surface in rendered_lines:
+            if message.align == "left":
+                line_rect = surface.get_rect(topleft=(text_rect.left, y))
+            else:
+                line_rect = surface.get_rect(centerx=text_rect.centerx, y=y)
+            screen.blit(surface, line_rect)
+            y += line_height
+    except pygame.error as e:
+        print(f"Error rendering timed message: {e}")
+
+
 def _build_objective_lines(
     *,
     stage: Stage | None,
@@ -320,7 +378,7 @@ def _build_objective_lines(
     player: Player,
     active_car: Car | None,
     has_fuel: bool,
-    buddy_onboard: int,
+    buddy_merged_count: int,
     buddy_required: int,
     survivors_onboard: int,
 ) -> list[str]:
@@ -330,23 +388,37 @@ def _build_objective_lines(
             objective_lines.append(tr("objectives.get_outside"))
         else:
             objective_lines.append(tr("objectives.survive_until_dawn"))
-    elif stage and stage.buddy_required_count > 0:
-        buddy_ready = buddy_onboard >= buddy_required
-        if not active_car:
-            objective_lines.append(tr("objectives.pickup_buddy"))
-            if stage.requires_fuel and not has_fuel:
-                objective_lines.append(tr("objectives.find_fuel"))
+        if stage.buddy_required_count > 0:
+            buddy_ready = buddy_merged_count >= buddy_required
+            if not buddy_ready:
+                if buddy_required == 1:
+                    objective_lines.append(tr("objectives.merge_buddy_single"))
+                else:
+                    objective_lines.append(
+                        tr("objectives.merge_buddy_multi", count=buddy_merged_count, limit=buddy_required)
+                    )
+        return objective_lines
+
+    if stage and stage.buddy_required_count > 0:
+        buddy_ready = buddy_merged_count >= buddy_required
+        if not buddy_ready:
+            if buddy_required == 1:
+                objective_lines.append(tr("objectives.merge_buddy_single"))
             else:
-                objective_lines.append(tr("objectives.find_car"))
-        else:
-            if stage.requires_fuel and not has_fuel:
-                objective_lines.append(tr("objectives.find_fuel"))
-            elif not buddy_ready:
-                objective_lines.append(tr("objectives.board_buddy"))
-                objective_lines.append(tr("objectives.buddy_onboard", count=buddy_onboard))
-                objective_lines.append(tr("objectives.escape"))
+                objective_lines.append(
+                    tr("objectives.merge_buddy_multi", count=buddy_merged_count, limit=buddy_required)
+                )
+        if not stage.endurance_stage:
+            if not active_car:
+                if stage.requires_fuel and not has_fuel:
+                    objective_lines.append(tr("objectives.find_fuel"))
+                else:
+                    objective_lines.append(tr("objectives.find_car"))
             else:
-                objective_lines.append(tr("objectives.escape"))
+                if stage.requires_fuel and not has_fuel:
+                    objective_lines.append(tr("objectives.find_fuel"))
+                else:
+                    objective_lines.append(tr("objectives.escape"))
     elif stage and stage.requires_fuel and not has_fuel:
         objective_lines.append(tr("objectives.find_fuel"))
     elif stage and stage.rescue_stage:

zombie_escape/render/overview.py

@@ -3,10 +3,13 @@ from __future__ import annotations
 import pygame
 from pygame import sprite, surface
 
-from ..colors import BLACK, BLUE, FOOTPRINT_COLOR, WHITE, YELLOW, get_environment_palette
+from ..colors import BLACK, BLUE, FOOTPRINT_COLOR, YELLOW, WHITE, get_environment_palette
 from ..entities import Car, Flashlight, FuelCan, Player, Shoes, SteelBeam, Survivor, Wall
+from ..font_utils import load_font
+from ..localization import get_font_settings
 from ..models import Footprint, GameData
 from ..render_assets import RenderAssets, resolve_steel_beam_colors, resolve_wall_colors
+from .hud import _get_fog_scale
 
 
 def compute_floor_cells(
@@ -24,6 +27,31 @@ def compute_floor_cells(
     return {(x, y) for y in range(rows) for x in range(cols) if (x, y) not in blocked}
 
 
+def _draw_overview_tag(
+    surface: surface.Surface,
+    font: pygame.font.Font,
+    text: str,
+    item_rect: pygame.Rect,
+    *,
+    fg: tuple[int, int, int] = YELLOW,
+    padding: tuple[int, int] = (4, 2),
+) -> None:
+    label = font.render(text, False, fg)
+    label_rect = label.get_rect()
+    padded = label_rect.inflate(padding[0] * 2, padding[1] * 2)
+    top_left = (item_rect.left, item_rect.top)
+    bottom_left = (item_rect.left, item_rect.bottom - padded.height)
+    if top_left[1] < 0 or top_left[1] + padded.height > surface.get_height():
+        x, y = bottom_left
+    else:
+        x, y = top_left
+    x = max(0, min(surface.get_width() - padded.width, x))
+    y = max(0, min(surface.get_height() - padded.height, y))
+    padded.topleft = (x, y)
+    label_rect.center = padded.center
+    surface.blit(label, label_rect)
+
+
 def draw_level_overview(
     assets: RenderAssets,
     surface: surface.Surface,
@@ -39,12 +67,14 @@ def draw_level_overview(
     shoes: list[Shoes] | None = None,
     buddies: list[Survivor] | None = None,
     survivors: list[Survivor] | None = None,
+    fall_spawn_cells: set[tuple[int, int]] | None = None,
     palette_key: str | None = None,
 ) -> None:
     palette = get_environment_palette(palette_key)
     base_floor = palette.floor_primary
     dark_floor = tuple(max(0, int(channel * 0.35)) for channel in base_floor)
     floor_color = tuple(max(0, int(channel * 0.65)) for channel in base_floor)
+    fall_floor = tuple(max(0, int(channel * 0.55)) for channel in palette.fall_zone_primary)
     surface.fill(dark_floor)
     cell_size = assets.internal_wall_grid_snap
     if cell_size > 0:
@@ -59,6 +89,18 @@ def draw_level_overview(
                     cell_size,
                 ),
             )
+        if fall_spawn_cells:
+            for x, y in fall_spawn_cells:
+                pygame.draw.rect(
+                    surface,
+                    fall_floor,
+                    pygame.Rect(
+                        x * cell_size,
+                        y * cell_size,
+                        cell_size,
+                        cell_size,
+                    ),
+                )
 
     for wall in wall_group:
         if wall.max_health > 0:
@@ -179,6 +221,7 @@ def draw_debug_overview(
             if survivor.alive() and survivor.is_buddy and not survivor.rescued
         ],
         survivors=list(game_data.groups.survivor_group),
+        fall_spawn_cells=game_data.layout.fall_spawn_cells,
         palette_key=game_data.state.ambient_palette_key,
     )
     zombie_color = (200, 80, 80)
@@ -191,6 +234,21 @@ def draw_debug_overview(
                 zombie.rect.center,
                 zombie_radius,
             )
+    fov_target = None
+    if game_data.player and game_data.player.in_car and game_data.car and game_data.car.alive():
+        fov_target = game_data.car
+    elif game_data.player:
+        fov_target = game_data.player
+    if fov_target:
+        fov_scale = _get_fog_scale(assets, game_data.state.flashlight_count)
+        fov_radius = max(1, int(assets.fov_radius * fov_scale))
+        pygame.draw.circle(
+            overview_surface,
+            (255, 255, 120),
+            fov_target.rect.center,
+            fov_radius,
+            width=2,
+        )
     cam_offset = game_data.camera.camera
     camera_rect = pygame.Rect(
         -cam_offset.x,
@@ -212,7 +270,40 @@ def draw_debug_overview(
     scaled_h = max(1, scaled_h)
     scaled_overview = pygame.transform.smoothscale(overview_surface, (scaled_w, scaled_h))
     screen.fill(BLACK)
+    scaled_rect = scaled_overview.get_rect(center=(screen_width // 2, screen_height // 2))
     screen.blit(
         scaled_overview,
-        scaled_overview.get_rect(center=(screen_width // 2, screen_height // 2)),
+        scaled_rect,
     )
+    try:
+        font_settings = get_font_settings()
+        label_font = load_font(font_settings.resource, font_settings.scaled_size(11))
+    except pygame.error as e:
+        print(f"Error loading overview font: {e}")
+        return
+    scale_x = scaled_w / max(1, level_rect.width)
+    scale_y = scaled_h / max(1, level_rect.height)
+
+    def _scaled_rect(rect: pygame.Rect) -> pygame.Rect:
+        return pygame.Rect(
+            int(scaled_rect.left + rect.left * scale_x),
+            int(scaled_rect.top + rect.top * scale_y),
+            max(1, int(rect.width * scale_x)),
+            max(1, int(rect.height * scale_y)),
+        )
+
+    if game_data.car and game_data.car.alive():
+        _draw_overview_tag(screen, label_font, "C", _scaled_rect(game_data.car.rect))
+    for parked in game_data.waiting_cars:
+        if parked.alive():
+            _draw_overview_tag(screen, label_font, "C", _scaled_rect(parked.rect))
+    if game_data.fuel and game_data.fuel.alive():
+        _draw_overview_tag(screen, label_font, "F", _scaled_rect(game_data.fuel.rect))
+    if game_data.flashlights:
+        for flashlight in game_data.flashlights:
+            if flashlight.alive():
+                _draw_overview_tag(screen, label_font, "L", _scaled_rect(flashlight.rect))
+    if game_data.shoes:
+        for item in game_data.shoes:
+            if item.alive():
+                _draw_overview_tag(screen, label_font, "S", _scaled_rect(item.rect))

zombie_escape/render/shadows.py

@@ -22,7 +22,7 @@ _SHADOW_LAYER_CACHE: dict[tuple[int, int], surface.Surface] = {}
 _SHADOW_CIRCLE_CACHE: dict[tuple[int, int, float], surface.Surface] = {}
 
 
-def _get_shadow_tile_surface(
+def _get_shadow_cell_surface(
     cell_size: int,
     alpha: int,
     *,
@@ -176,7 +176,7 @@ def _draw_wall_shadows(
         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_surface = _get_shadow_cell_surface(
         shadow_size,
         alpha,
         edge_softness=0.12,

zombie_escape/render_constants.py

@@ -20,6 +20,12 @@ FALLING_WHIRLWIND_COLOR = (200, 200, 200, 120)
 FALLING_DUST_COLOR = (70, 70, 70, 130)
 ANGLE_BINS = 16
 HAND_SPREAD_RAD = math.radians(75)
+GAMEPLAY_FONT_SIZE = 11
+HUD_ICON_SIZE = 12
+FADE_IN_DURATION_MS = 900
+TIMED_MESSAGE_LEFT_X = 20
+TIMED_MESSAGE_TOP_Y = 48
+TIMED_MESSAGE_BAND_ALPHA = 80
 
 
 @dataclass(frozen=True)
@@ -113,6 +119,12 @@ __all__ = [
     "ZOMBIE_NOSE_COLOR",
     "ANGLE_BINS",
     "HAND_SPREAD_RAD",
+    "GAMEPLAY_FONT_SIZE",
+    "HUD_ICON_SIZE",
+    "FADE_IN_DURATION_MS",
+    "TIMED_MESSAGE_LEFT_X",
+    "TIMED_MESSAGE_TOP_Y",
+    "TIMED_MESSAGE_BAND_ALPHA",
     "HUMANOID_OUTLINE_COLOR",
     "HUMANOID_OUTLINE_WIDTH",
     "SURVIVOR_COLOR",

zombie_escape/screens/__init__.py

@@ -10,21 +10,10 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import TYPE_CHECKING
 
-import pygame
-from pygame import surface
-
 try:  # pragma: no cover - version fallback not critical for tests
     from ..__about__ import __version__
 except Exception:  # pragma: no cover - fallback version
     __version__ = "0.0.0-unknown"
-from ..screen_constants import (
-    DEFAULT_WINDOW_SCALE,
-    SCREEN_HEIGHT,
-    SCREEN_WIDTH,
-    WINDOW_SCALE_MAX,
-    WINDOW_SCALE_MIN,
-)
-
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from ..models import GameData, Stage
 
@@ -52,186 +41,14 @@ class ScreenTransition:
     seed_is_auto: bool = False
 
 
-current_window_scale = DEFAULT_WINDOW_SCALE  # Applied to the OS window only
-current_maximized = False
-last_window_scale = DEFAULT_WINDOW_SCALE
-current_window_size = (
-    int(SCREEN_WIDTH * DEFAULT_WINDOW_SCALE),
-    int(SCREEN_HEIGHT * DEFAULT_WINDOW_SCALE),
-)
-last_logged_window_size = current_window_size
-
 __all__ = [
     "ScreenID",
     "ScreenTransition",
-    "present",
-    "apply_window_scale",
-    "nudge_window_scale",
-    "toggle_fullscreen",
-    "sync_window_size",
+    "TITLE_FONT_SCALE",
+    "TITLE_HEADER_Y",
+    "TITLE_SECTION_TOP",
 ]
 
-
-def present(logical_surface: surface.Surface) -> None:
-    """Scale the logical surface directly to the window and flip buffers."""
-    window = pygame.display.get_surface()
-    if window is None:
-        return
-    window_size = _fetch_window_size(window)
-    _update_window_size(window_size, source="frame")
-    logical_size = logical_surface.get_size()
-    if window_size == logical_size:
-        window.blit(logical_surface, (0, 0))
-    else:
-        # Preserve aspect ratio with letterboxing.
-        scale_x = window_size[0] / max(1, logical_size[0])
-        scale_y = window_size[1] / max(1, logical_size[1])
-        scale = min(scale_x, scale_y)
-        scaled_width = max(1, int(logical_size[0] * scale))
-        scaled_height = max(1, int(logical_size[1] * scale))
-        window.fill((0, 0, 0))
-        if (scaled_width, scaled_height) == logical_size:
-            scaled_surface = logical_surface
-        else:
-            scaled_surface = pygame.transform.scale(logical_surface, (scaled_width, scaled_height))
-        offset_x = (window_size[0] - scaled_width) // 2
-        offset_y = (window_size[1] - scaled_height) // 2
-        window.blit(scaled_surface, (offset_x, offset_y))
-    pygame.display.flip()
-
-
-def apply_window_scale(scale: float, *, game_data: "GameData | None" = None) -> surface.Surface:
-    """Resize the OS window; logical render surface stays constant."""
-    global current_window_scale, current_maximized, last_window_scale
-
-    clamped_scale = max(WINDOW_SCALE_MIN, min(WINDOW_SCALE_MAX, scale))
-    current_window_scale = clamped_scale
-    last_window_scale = clamped_scale
-    current_maximized = False
-
-    window_width = max(1, int(SCREEN_WIDTH * current_window_scale))
-    window_height = max(1, int(SCREEN_HEIGHT * current_window_scale))
-
-    new_window = pygame.display.set_mode((window_width, window_height), pygame.RESIZABLE)
-    _update_window_size((window_width, window_height), source="apply_scale")
-    _update_window_caption()
-
-    if game_data is not None:
-        game_data.state.overview_created = False
-
-    return new_window
-
-
-def nudge_window_scale(multiplier: float, *, game_data: "GameData | None" = None) -> surface.Surface:
-    """Scale the window relative to the current zoom level."""
-    target_scale = current_window_scale * multiplier
-    return apply_window_scale(target_scale, game_data=game_data)
-
-
-def toggle_fullscreen(*, game_data: "GameData | None" = None) -> surface.Surface | None:
-    """Toggle a maximized window without persisting the setting."""
-    global current_maximized, last_window_scale
-    if current_maximized:
-        current_maximized = False
-        window_width = max(1, int(SCREEN_WIDTH * last_window_scale))
-        window_height = max(1, int(SCREEN_HEIGHT * last_window_scale))
-        window = pygame.display.set_mode((window_width, window_height), pygame.RESIZABLE)
-        _restore_window()
-        _update_window_caption()
-        _update_window_size((window_width, window_height), source="toggle_windowed")
-    else:
-        last_window_scale = current_window_scale
-        current_maximized = True
-        window = pygame.display.set_mode(_fetch_window_size(None), pygame.RESIZABLE)
-        _maximize_window()
-        window_width, window_height = _fetch_window_size(window)
-        _update_window_caption()
-        _update_window_size((window_width, window_height), source="toggle_fullscreen")
-    pygame.mouse.set_visible(not current_maximized)
-    if game_data is not None:
-        game_data.state.overview_created = False
-    return window
-
-
-def sync_window_size(event: pygame.event.Event, *, game_data: "GameData | None" = None) -> None:
-    """Synchronize tracked window size with SDL window events."""
-    global current_window_scale, last_window_scale
-    size = getattr(event, "size", None)
-    if not size:
-        width = getattr(event, "x", None)
-        height = getattr(event, "y", None)
-        if width is not None and height is not None:
-            size = (width, height)
-    if not size:
-        return
-    window_width, window_height = _normalize_window_size(size)
-    _update_window_size((window_width, window_height), source="window_event")
-    if not current_maximized:
-        scale_x = window_width / max(1, SCREEN_WIDTH)
-        scale_y = window_height / max(1, SCREEN_HEIGHT)
-        scale = max(WINDOW_SCALE_MIN, min(WINDOW_SCALE_MAX, min(scale_x, scale_y)))
-        current_window_scale = scale
-        last_window_scale = scale
-    _update_window_caption()
-    if game_data is not None:
-        game_data.state.overview_created = False
-
-
-def _fetch_window_size(window: surface.Surface | None) -> tuple[int, int]:
-    if hasattr(pygame.display, "get_window_size"):
-        size = pygame.display.get_window_size()
-        if size != (0, 0):
-            return _normalize_window_size(size)
-    if window is not None:
-        return _normalize_window_size(window.get_size())
-    window_width = max(1, int(SCREEN_WIDTH * last_window_scale))
-    window_height = max(1, int(SCREEN_HEIGHT * last_window_scale))
-    return window_width, window_height
-
-
-def _normalize_window_size(size: tuple[int, int]) -> tuple[int, int]:
-    width = max(1, int(size[0]))
-    height = max(1, int(size[1]))
-    return width, height
-
-
-def _update_window_size(size: tuple[int, int], *, source: str) -> None:
-    global current_window_size, last_logged_window_size
-    current_window_size = size
-    if size != last_logged_window_size:
-        print(f"WINDOW_SIZE {source}={size[0]}x{size[1]}")
-        last_logged_window_size = size
-
-
-def _update_window_caption() -> None:
-    pygame.display.set_caption("Zombie Escape")
-
-
-def _maximize_window() -> None:
-    try:
-        from pygame import _sdl2 as sdl2  # type: ignore[import-not-found]
-    except Exception:
-        return
-    try:
-        window = sdl2.Window.from_display_module()
-    except Exception:
-        return
-    try:
-        window.maximize()
-    except Exception:
-        return
-
-
-def _restore_window() -> None:
-    try:
-        from pygame import _sdl2 as sdl2  # type: ignore[import-not-found]
-    except Exception:
-        return
-    try:
-        window = sdl2.Window.from_display_module()
-    except Exception:
-        return
-    try:
-        window.restore()
-    except Exception:
-        return
+TITLE_FONT_SCALE = 1
+TITLE_HEADER_Y = 20
+TITLE_SECTION_TOP = 45