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

zombie_escape/render/shadows.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+import math
+
+import pygame
+from pygame import sprite, surface
+
+from ..entities import Camera, Car, Player, SteelBeam, Survivor, Zombie
+from ..entities_constants import JUMP_SHADOW_OFFSET, ZOMBIE_RADIUS
+from ..render_constants import (
+    ENTITY_SHADOW_ALPHA,
+    ENTITY_SHADOW_EDGE_SOFTNESS,
+    ENTITY_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] = {}
+
+
+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 _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 _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(
+    shadow_layer: 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,
+) -> bool:
+    if not wall_cells or cell_size <= 0 or light_source_pos is None:
+        return False
+    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 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,
+        alpha,
+        edge_softness=0.12,
+    )
+    screen_rect = shadow_layer.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,
+            special_flags=pygame.BLEND_RGBA_MAX,
+        )
+        drew = True
+    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
+
+        jump_dy = 0.0
+        if getattr(entity, "is_jumping", False):
+            jump_dy = JUMP_SHADOW_OFFSET
+
+        shadow_rect = shadow_surface.get_rect(center=(int(cx + offset_x), int(cy + offset_y + jump_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,
+            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
+
+    jump_dy = 0.0
+    if getattr(entity, "is_jumping", False):
+        jump_dy = JUMP_SHADOW_OFFSET
+
+    shadow_rect = shadow_surface.get_rect(center=(int(cx + offset_x), int(cy + offset_y + jump_dy)))
+    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

zombie_escape/render_assets.py

@@ -46,9 +46,7 @@ def _draw_outlined_circle(
         pygame.draw.circle(surface, outline_color, center, radius, width=outline_width)
 
 
-def _brighten_color(
-    color: tuple[int, int, int], *, factor: float = 1.25
-) -> tuple[int, int, int]:
+def _brighten_color(color: tuple[int, int, int], *, factor: float = 1.25) -> tuple[int, int, int]:
     return tuple(min(255, int(c * factor + 0.5)) for c in color)
 
 
@@ -58,9 +56,7 @@ _PLAYER_UPSCALE_FACTOR = 4
 _CAR_UPSCALE_FACTOR = 4
 
 _PLAYER_DIRECTIONAL_CACHE: dict[tuple[int, int], list[pygame.Surface]] = {}
-_SURVIVOR_DIRECTIONAL_CACHE: dict[
-    tuple[int, bool, bool, int], list[pygame.Surface]
-] = {}
+_SURVIVOR_DIRECTIONAL_CACHE: dict[tuple[int, bool, bool, int], list[pygame.Surface]] = {}
 _ZOMBIE_DIRECTIONAL_CACHE: dict[tuple[int, bool, int], list[pygame.Surface]] = {}
 _RUBBLE_SURFACE_CACHE: dict[tuple, pygame.Surface] = {}
 
@@ -70,9 +66,7 @@ RUBBLE_SCALE_RATIO = 0.9
 RUBBLE_SHADOW_RATIO = 0.9
 
 
-def _scale_color(
-    color: tuple[int, int, int], *, ratio: float
-) -> tuple[int, int, int]:
+def _scale_color(color: tuple[int, int, int], *, ratio: float) -> tuple[int, int, int]:
     return tuple(max(0, min(255, int(c * ratio + 0.5))) for c in color)
 
 
@@ -80,9 +74,7 @@ def rubble_offset_for_size(size: int) -> int:
     return max(1, int(round(size * RUBBLE_OFFSET_RATIO)))
 
 
-def angle_bin_from_vector(
-    dx: float, dy: float, *, bins: int = ANGLE_BINS
-) -> int | None:
+def angle_bin_from_vector(dx: float, dy: float, *, bins: int = ANGLE_BINS) -> int | None:
     if dx == 0 and dy == 0:
         return None
     angle = math.atan2(dy, dx)
@@ -388,9 +380,7 @@ def resolve_steel_beam_colors(
     return STEEL_BEAM_COLOR, STEEL_BEAM_LINE_COLOR
 
 
-def build_player_directional_surfaces(
-    radius: int, *, bins: int = ANGLE_BINS
-) -> list[pygame.Surface]:
+def build_player_directional_surfaces(radius: int, *, bins: int = ANGLE_BINS) -> list[pygame.Surface]:
     cache_key = (radius, bins)
     if cache_key in _PLAYER_DIRECTIONAL_CACHE:
         return _PLAYER_DIRECTIONAL_CACHE[cache_key]
@@ -545,9 +535,7 @@ def paint_car_surface(
         up_width = width * upscale
         up_height = height * upscale
         up_surface = pygame.Surface((up_width, up_height), pygame.SRCALPHA)
-        _paint_car_surface_base(
-            up_surface, width=up_width, height=up_height, color=color
-        )
+        _paint_car_surface_base(up_surface, width=up_width, height=up_height, color=color)
         scaled = pygame.transform.smoothscale(up_surface, (width, height))
         surface.fill((0, 0, 0, 0))
         surface.blit(scaled, (0, 0))
@@ -604,9 +592,7 @@ def _paint_car_surface_base(
     pygame.draw.ellipse(surface, headlight_color, headlight_right)
 
 
-def build_car_directional_surfaces(
-    base_surface: pygame.Surface, *, bins: int = ANGLE_BINS
-) -> list[pygame.Surface]:
+def build_car_directional_surfaces(base_surface: pygame.Surface, *, bins: int = ANGLE_BINS) -> list[pygame.Surface]:
     """Return pre-rotated car surfaces matching angle_bin_from_vector bins."""
     surfaces: list[pygame.Surface] = []
     upscale = _CAR_UPSCALE_FACTOR
@@ -660,9 +646,7 @@ def paint_wall_surface(
     ) -> None:
         face_width, face_height = face_size or target.get_size()
         if bevel_depth > 0 and any(bevel_mask):
-            face_polygon = build_beveled_polygon(
-                face_width, face_height, bevel_depth, bevel_mask
-            )
+            face_polygon = build_beveled_polygon(face_width, face_height, bevel_depth, bevel_mask)
             pygame.draw.polygon(target, border_color, face_polygon)
         else:
             target.fill(border_color)
@@ -671,9 +655,7 @@ def paint_wall_surface(
         if inner_rect.width > 0 and inner_rect.height > 0:
             inner_depth = max(0, bevel_depth - border_width)
             if inner_depth > 0 and any(bevel_mask):
-                inner_polygon = build_beveled_polygon(
-                    inner_rect.width, inner_rect.height, inner_depth, bevel_mask
-                )
+                inner_polygon = build_beveled_polygon(inner_rect.width, inner_rect.height, inner_depth, bevel_mask)
                 inner_offset_polygon = [
                     (
                         int(point[0] + inner_rect.left),
@@ -703,9 +685,7 @@ def paint_wall_surface(
         side_color = tuple(int(c * side_shade_ratio) for c in fill_color)
         side_surface = pygame.Surface(rect_obj.size, pygame.SRCALPHA)
         if bevel_depth > 0 and any(bevel_mask):
-            side_polygon = build_beveled_polygon(
-                rect_obj.width, rect_obj.height, bevel_depth, bevel_mask
-            )
+            side_polygon = build_beveled_polygon(rect_obj.width, rect_obj.height, bevel_depth, bevel_mask)
             pygame.draw.polygon(side_surface, side_color, side_polygon)
         else:
             pygame.draw.rect(side_surface, side_color, rect_obj)
@@ -785,9 +765,7 @@ def build_rubble_wall_surface(
     final_surface = pygame.Surface((safe_size, safe_size), pygame.SRCALPHA)
     center = final_surface.get_rect().center
 
-    shadow_rect = shadow_surface.get_rect(
-        center=(center[0] + offset_px, center[1] + offset_px)
-    )
+    shadow_rect = shadow_surface.get_rect(center=(center[0] + offset_px, center[1] + offset_px))
     final_surface.blit(shadow_surface, shadow_rect.topleft)
 
     top_rect = top_surface.get_rect(center=center)

zombie_escape/rng.py

@@ -43,9 +43,7 @@ class DeterministicRNG:
         self._state[0] = seed32
         for i in range(1, self._N):
             prev = self._state[i - 1]
-            self._state[i] = (
-                (1812433253 * (prev ^ (prev >> 30)) + i) & 0xFFFFFFFF
-            )
+            self._state[i] = (1812433253 * (prev ^ (prev >> 30)) + i) & 0xFFFFFFFF
         self._index = self._N
 
     @property
@@ -93,17 +91,15 @@ class DeterministicRNG:
             self._twist()
         y = self._state[self._index]
         self._index += 1
-        y ^= (y >> 11)
+        y ^= y >> 11
         y ^= (y << 7) & 0x9D2C5680
         y ^= (y << 15) & 0xEFC60000
-        y ^= (y >> 18)
+        y ^= y >> 18
         return y & 0xFFFFFFFF
 
     def _twist(self) -> None:
         for i in range(self._N):
-            x = (self._state[i] & self._UPPER_MASK) + (
-                self._state[(i + 1) % self._N] & self._LOWER_MASK
-            )
+            x = (self._state[i] & self._UPPER_MASK) + (self._state[(i + 1) % self._N] & self._LOWER_MASK)
             xA = x >> 1
             if x & 1:
                 xA ^= self._MATRIX_A

zombie_escape/screens/__init__.py

@@ -93,18 +93,14 @@ def present(logical_surface: surface.Surface) -> None:
         if (scaled_width, scaled_height) == logical_size:
             scaled_surface = logical_surface
         else:
-            scaled_surface = pygame.transform.scale(
-                logical_surface, (scaled_width, scaled_height)
-            )
+            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:
+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
 
@@ -116,11 +112,9 @@ def apply_window_scale(
     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
-    )
+    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(window_width, window_height)
+    _update_window_caption()
 
     if game_data is not None:
         game_data.state.overview_created = False
@@ -128,28 +122,22 @@ def apply_window_scale(
     return new_window
 
 
-def nudge_window_scale(
-    multiplier: float, *, game_data: "GameData | None" = None
-) -> surface.Surface:
+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:
+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
-        )
+        window = pygame.display.set_mode((window_width, window_height), pygame.RESIZABLE)
         _restore_window()
-        _update_window_caption(window_width, window_height)
+        _update_window_caption()
         _update_window_size((window_width, window_height), source="toggle_windowed")
     else:
         last_window_scale = current_window_scale
@@ -157,7 +145,7 @@ def toggle_fullscreen(
         window = pygame.display.set_mode(_fetch_window_size(None), pygame.RESIZABLE)
         _maximize_window()
         window_width, window_height = _fetch_window_size(window)
-        _update_window_caption(window_width, window_height)
+        _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:
@@ -165,9 +153,7 @@ def toggle_fullscreen(
     return window
 
 
-def sync_window_size(
-    event: pygame.event.Event, *, game_data: "GameData | None" = None
-) -> None:
+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)
@@ -179,16 +165,14 @@ def sync_window_size(
     if not size:
         return
     window_width, window_height = _normalize_window_size(size)
-    _update_window_size(
-        (window_width, window_height), source="window_event"
-    )
+    _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(window_width, window_height)
+    _update_window_caption()
     if game_data is not None:
         game_data.state.overview_created = False
 
@@ -219,8 +203,8 @@ def _update_window_size(size: tuple[int, int], *, source: str) -> None:
         last_logged_window_size = size
 
 
-def _update_window_caption(window_width: int, window_height: int) -> None:
-    pygame.display.set_caption(f"Zombie Escape ({window_width}x{window_height})")
+def _update_window_caption() -> None:
+    pygame.display.set_caption("Zombie Escape")
 
 
 def _maximize_window() -> None: