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

zombie_escape/screens/game_over.py

@@ -19,14 +19,8 @@ from ..input_utils import (
 from ..localization import translate as tr
 from ..models import GameData, Stage
 from ..render import RenderAssets, _draw_status_bar, compute_floor_cells, draw_level_overview, show_message
-from ..screens import (
-    ScreenID,
-    ScreenTransition,
-    nudge_window_scale,
-    present,
-    sync_window_size,
-    toggle_fullscreen,
-)
+from ..screens import ScreenID, ScreenTransition
+from ..windowing import nudge_window_scale, present, sync_window_size, toggle_fullscreen
 
 
 def game_over_screen(
@@ -87,6 +81,7 @@ def game_over_screen(
                     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=state.ambient_palette_key,
             )
 
@@ -113,7 +108,7 @@ def game_over_screen(
                 show_message(
                     screen,
                     tr("game_over.win"),
-                    22,
+                    11,
                     GREEN,
                     (screen_width // 2, screen_height // 2 - 26),
                 )
@@ -121,18 +116,10 @@ def game_over_screen(
                 show_message(
                     screen,
                     tr("game_over.lose"),
-                    22,
+                    11,
                     RED,
                     (screen_width // 2, screen_height // 2 - 26),
                 )
-                if state.game_over_message:
-                    show_message(
-                        screen,
-                        state.game_over_message,
-                        18,
-                        LIGHT_GRAY,
-                        (screen_width // 2, screen_height // 2 + 6),
-                    )
             summary_y = screen_height // 2 + 70
             if stage and (stage.rescue_stage or stage.buddy_required_count > 0):
                 total_rescued = state.survivors_rescued + state.buddy_rescued
@@ -140,7 +127,7 @@ def game_over_screen(
                 show_message(
                     screen,
                     msg,
-                    18,
+                    11,
                     LIGHT_GRAY,
                     (screen_width // 2, summary_y),
                 )
@@ -157,7 +144,7 @@ def game_over_screen(
                 show_message(
                     screen,
                     msg,
-                    18,
+                    11,
                     LIGHT_GRAY,
                     (screen_width // 2, summary_y),
                 )
@@ -165,7 +152,7 @@ def game_over_screen(
         show_message(
             screen,
             tr("game_over.prompt"),
-            18,
+            11,
             WHITE,
             (screen_width // 2, screen_height // 2 + 24),
         )

zombie_escape/screens/gameplay.py

@@ -5,7 +5,8 @@ from typing import TYPE_CHECKING, Any
 import pygame
 from pygame import surface, time
 
-from ..colors import RED, YELLOW
+from ..colors import LIGHT_GRAY, RED, WHITE, YELLOW
+from ..font_utils import load_font
 from ..gameplay_constants import (
     CAR_HINT_DELAY_MS_DEFAULT,
     SURVIVAL_TIME_ACCEL_SUBSTEPS,
@@ -20,6 +21,7 @@ from ..gameplay import (
     initialize_game_state,
     maintain_waiting_car_supply,
     nearest_waiting_car,
+    schedule_timed_message,
     place_flashlights,
     place_fuel_can,
     place_shoes,
@@ -32,6 +34,8 @@ from ..gameplay import (
     update_footprints,
     update_endurance_timer,
 )
+from ..gameplay.state import frames_to_ms, ms_to_frames
+from ..gameplay.constants import INTRO_MESSAGE_DISPLAY_FRAMES
 from ..input_utils import (
     CONTROLLER_BUTTON_DOWN,
     CONTROLLER_DEVICE_ADDED,
@@ -45,19 +49,14 @@ from ..input_utils import (
 )
 from ..gameplay.spawn import _alive_waiting_cars
 from ..world_grid import build_wall_index
-from ..localization import translate as tr
+from ..localization import get_font_settings, translate as tr
 from ..models import Stage
-from ..render import draw, draw_debug_overview, draw_pause_overlay, prewarm_fog_overlays, show_message, show_message_wrapped
+from ..render import draw, draw_debug_overview, draw_pause_overlay, prewarm_fog_overlays, show_message_wrapped
+from ..render_constants import GAMEPLAY_FONT_SIZE, TIMED_MESSAGE_LEFT_X, TIMED_MESSAGE_TOP_Y
 from ..rng import generate_seed, seed_rng
 from ..progress import record_stage_clear
-from ..screens import (
-    ScreenID,
-    ScreenTransition,
-    nudge_window_scale,
-    present,
-    sync_window_size,
-    toggle_fullscreen,
-)
+from ..screens import ScreenID, ScreenTransition
+from ..windowing import nudge_window_scale, present, sync_window_size, toggle_fullscreen
 
 if TYPE_CHECKING:
     from ..render import RenderAssets
@@ -93,9 +92,32 @@ def gameplay_screen(
         _set_mouse_hidden(False)
         return transition
 
+    def _show_loading_still() -> None:
+        screen.fill((0, 0, 0))
+        if stage.intro_key:
+            intro_text = tr(stage.intro_key)
+            font_settings = get_font_settings()
+            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() * font_settings.line_height_scale))
+            x = TIMED_MESSAGE_LEFT_X
+            y = TIMED_MESSAGE_TOP_Y
+            for line in intro_text.splitlines():
+                if not line:
+                    y += line_height
+                    continue
+                surface = font.render(line, False, WHITE)
+                screen.blit(surface, (x, y))
+                y += line_height
+        present(screen)
+        pygame.event.pump()
+
     seed_value = seed if seed is not None else generate_seed()
     applied_seed = seed_rng(seed_value)
 
+    loading_started_ms = pygame.time.get_ticks()
+    _show_loading_still()
+
     game_data = initialize_game_state(config, stage)
     game_data.state.seed = applied_seed
     game_data.state.debug_mode = debug_mode
@@ -113,6 +135,18 @@ def gameplay_screen(
         render_assets,
         stage=stage,
     )
+    if stage.intro_key and game_data.state.timed_message:
+        loading_elapsed_ms = max(0, pygame.time.get_ticks() - loading_started_ms)
+        remaining_ms = max(0, frames_to_ms(INTRO_MESSAGE_DISPLAY_FRAMES) - loading_elapsed_ms)
+        schedule_timed_message(
+            game_data.state,
+            tr(stage.intro_key),
+            duration_frames=max(0, ms_to_frames(remaining_ms)),
+            clear_on_input=True,
+            color=LIGHT_GRAY,
+            align="left",
+            now_ms=game_data.state.elapsed_play_ms,
+        )
     paused_manual = False
     paused_focus = False
     ignore_focus_loss_until = 0
@@ -154,6 +188,8 @@ def gameplay_screen(
     cell_size = game_data.cell_size
     if stage.requires_fuel:
         fuel_spawn_count = stage.fuel_spawn_count
+        if stage.endurance_stage:
+            fuel_spawn_count = 0
         fuel_can = place_fuel_can(
             layout_data["fuel_cells"] or layout_data["walkable_cells"],
             cell_size,
@@ -214,14 +250,6 @@ def gameplay_screen(
                         hint_color=None,
                         fps=current_fps,
                     )
-                    if game_data.state.game_over_message:
-                        show_message(
-                            screen,
-                            game_data.state.game_over_message,
-                            18,
-                            RED,
-                            (screen_width // 2, screen_height // 2 - 24),
-                        )
                     present(screen)
                     continue
             return _finalize(
@@ -315,13 +343,24 @@ def gameplay_screen(
 
         paused = paused_manual or paused_focus
         if paused:
-            draw(
-                render_assets,
-                screen,
-                game_data,
-                config=config,
-                fps=current_fps,
-            )
+            if debug_overview:
+                draw_debug_overview(
+                    render_assets,
+                    screen,
+                    overview_surface,
+                    game_data,
+                    config,
+                    screen_width=screen_width,
+                    screen_height=screen_height,
+                )
+            else:
+                draw(
+                    render_assets,
+                    screen,
+                    game_data,
+                    config=config,
+                    fps=current_fps,
+                )
             if show_pause_overlay:
                 draw_pause_overlay(screen)
             present(screen)
@@ -347,6 +386,12 @@ def gameplay_screen(
                 shoes_count=game_data.state.shoes_count,
                 pad_input=pad_vector,
             )
+            if (
+                game_data.state.timed_message
+                and game_data.state.timed_message.clear_on_input
+                and (player_dx or player_dy or car_dx or car_dy)
+            ):
+                game_data.state.timed_message = None
             update_entities(
                 game_data,
                 player_dx,

zombie_escape/screens/settings.py

@@ -9,7 +9,7 @@ from pygame import surface, time
 
 from ..colors import BLACK, GREEN, LIGHT_GRAY, WHITE
 from ..config import DEFAULT_CONFIG, save_config
-from ..font_utils import load_font
+from ..font_utils import blit_text_scaled, load_font, render_text_scaled
 from ..input_utils import (
     CONTROLLER_BUTTON_DOWN,
     CONTROLLER_BUTTON_DPAD_DOWN,
@@ -36,13 +36,18 @@ from ..localization import (
 from ..render import show_message, wrap_text
 from ..progress import user_progress_path
 from ..screens import (
-    nudge_window_scale,
+    TITLE_FONT_SCALE,
+    TITLE_HEADER_Y,
+    TITLE_SECTION_TOP,
+)
+from ..windowing import (
+    adjust_menu_logical_size,
+    nudge_menu_window_scale,
     present,
     sync_window_size,
     toggle_fullscreen,
 )
 
-
 def settings_screen(
     screen: surface.Surface,
     clock: time.Clock,
@@ -54,7 +59,10 @@ def settings_screen(
 ) -> dict[str, Any]:
     """Settings menu shown from the title screen."""
 
-    screen_width, screen_height = screen_size
+    settings_font_scale = TITLE_FONT_SCALE
+    screen_width, screen_height = screen.get_size()
+    if screen_width <= 0 or screen_height <= 0:
+        screen_width, screen_height = screen_size
     working = copy.deepcopy(config)
     set_language(working.get("language"))
     selected = 0
@@ -170,6 +178,18 @@ def settings_screen(
                     },
                 ],
             },
+            {
+                "label": tr("settings.sections.visual"),
+                "rows": [
+                    {
+                        "label": tr("settings.rows.shadows"),
+                        "path": ("visual", "shadows", "enabled"),
+                        "easy_value": True,
+                        "left_label": tr("common.on"),
+                        "right_label": tr("common.off"),
+                    },
+                ],
+            },
         ]
 
     def rebuild_rows() -> tuple[list[dict], list[dict], list[str]]:
@@ -196,6 +216,7 @@ def settings_screen(
                 return config
             if event.type in (pygame.WINDOWSIZECHANGED, pygame.VIDEORESIZE):
                 sync_window_size(event)
+                adjust_menu_logical_size()
                 continue
             if event.type == pygame.JOYDEVICEADDED or (
                 CONTROLLER_DEVICE_ADDED is not None and event.type == CONTROLLER_DEVICE_ADDED
@@ -215,13 +236,14 @@ def settings_screen(
                 return _exit_settings()
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_LEFTBRACKET:
-                    nudge_window_scale(0.5)
+                    nudge_menu_window_scale(0.5)
                     continue
                 if event.key == pygame.K_RIGHTBRACKET:
-                    nudge_window_scale(2.0)
+                    nudge_menu_window_scale(2.0)
                     continue
                 if event.key == pygame.K_f:
                     toggle_fullscreen()
+                    adjust_menu_logical_size()
                     continue
                 if event.key in (pygame.K_ESCAPE, pygame.K_BACKSPACE):
                     return _exit_settings()
@@ -316,23 +338,25 @@ def settings_screen(
         show_message(
             screen,
             tr("settings.title"),
-            26,
+            26 * settings_font_scale,
             LIGHT_GRAY,
-            (screen_width // 2, 20),
+            (screen_width // 2, TITLE_HEADER_Y),
+            scale_factor=settings_font_scale,
         )
 
         try:
             font_settings = get_font_settings()
-            label_font = load_font(font_settings.resource, font_settings.scaled_size(12))
-            value_font = load_font(font_settings.resource, font_settings.scaled_size(12))
-            section_font = load_font(font_settings.resource, font_settings.scaled_size(13))
+            label_size = font_settings.scaled_size(11 * settings_font_scale)
+            value_size = font_settings.scaled_size(11 * settings_font_scale)
+            section_size = font_settings.scaled_size(12 * settings_font_scale)
+            label_font = load_font(font_settings.resource, label_size)
             highlight_color = (70, 70, 70)
 
-            row_height = 20
-            start_y = 46
+            row_height = 16
+            start_y = TITLE_SECTION_TOP
 
-            segment_width = 30
-            segment_height = 18
+            segment_width = int(round(30 * 1.5 * 0.8))
+            segment_height = int(round(18 * 0.8))
             segment_gap = 10
             segment_total_width = segment_width * 2 + segment_gap
 
@@ -345,7 +369,13 @@ def settings_screen(
             section_states: dict[str, dict] = {}
             y_cursor = start_y
             for section in sections:
-                header_surface = section_font.render(section["label"], False, LIGHT_GRAY)
+                header_surface = render_text_scaled(
+                    font_settings.resource,
+                    section_size,
+                    section["label"],
+                    LIGHT_GRAY,
+                    scale_factor=settings_font_scale,
+                )
                 section_states[section["label"]] = {
                     "next_y": y_cursor + header_surface.get_height() + 4,
                     "header_surface": header_surface,
@@ -376,25 +406,34 @@ def settings_screen(
                 if idx == selected:
                     pygame.draw.rect(screen, highlight_color, highlight_rect)
 
-                label_surface = label_font.render(row["label"], False, WHITE)
-                label_rect = label_surface.get_rect(
+                label_height = label_font.get_linesize()
+                blit_text_scaled(
+                    screen,
+                    font_settings.resource,
+                    label_size,
+                    row["label"],
+                    WHITE,
+                    scale_factor=settings_font_scale,
                     topleft=(
                         col_x,
-                        row_y_current + (row_height - label_surface.get_height()) // 2,
-                    )
+                        row_y_current + (row_height - label_height) // 2,
+                    ),
                 )
-                screen.blit(label_surface, label_rect)
                 if row_type == "choice":
                     display_fn = row.get("get_display")
                     display_text = display_fn(value) if display_fn and value is not None else str(value)
-                    value_surface = value_font.render(display_text, False, WHITE)
-                    value_rect = value_surface.get_rect(
+                    blit_text_scaled(
+                        screen,
+                        font_settings.resource,
+                        value_size,
+                        display_text,
+                        WHITE,
+                        scale_factor=settings_font_scale,
                         midright=(
                             col_x + row_width,
                             row_y_current + row_height // 2,
-                        )
+                        ),
                     )
-                    screen.blit(value_surface, value_rect)
                 elif row_type == "toggle":
                     slider_y = row_y_current + (row_height - segment_height) // 2 - 2
                     slider_x = col_x + row_width - segment_total_width
@@ -415,16 +454,23 @@ def settings_screen(
                         outline_color = GREEN if active else LIGHT_GRAY
                         pygame.draw.rect(screen, active_color, rect)
                         pygame.draw.rect(screen, outline_color, rect, width=2)
-                        text_surface = value_font.render(text, False, WHITE)
-                        text_rect = text_surface.get_rect(center=rect.center)
-                        screen.blit(text_surface, text_rect)
+                        blit_text_scaled(
+                            screen,
+                            font_settings.resource,
+                            value_size,
+                            text,
+                            WHITE,
+                            scale_factor=settings_font_scale,
+                            center=rect.center,
+                        )
 
                     draw_segment(left_rect, row["left_label"], left_active)
                     draw_segment(right_rect, row["right_label"], right_active)
 
             hint_start_y = start_y
             hint_start_x = screen_width // 2 + 16
-            hint_font = load_font(font_settings.resource, font_settings.scaled_size(11))
+            hint_size = font_settings.scaled_size(11 * settings_font_scale)
+            hint_font = load_font(font_settings.resource, hint_size)
             hint_lines = [
                 tr("settings.hints.navigate"),
                 tr("settings.hints.adjust"),
@@ -432,33 +478,58 @@ def settings_screen(
                 tr("settings.hints.reset"),
                 tr("settings.hints.exit"),
             ]
-            hint_line_height = hint_font.get_linesize()
+            hint_line_height = int(round(hint_font.get_linesize() * font_settings.line_height_scale))
             hint_max_width = screen_width - hint_start_x - 16
             y_cursor = hint_start_y
             for line in hint_lines:
-                hint_surface = hint_font.render(line, False, WHITE)
-                hint_rect = hint_surface.get_rect(topleft=(hint_start_x, y_cursor))
-                screen.blit(hint_surface, hint_rect)
+                blit_text_scaled(
+                    screen,
+                    font_settings.resource,
+                    hint_size,
+                    line,
+                    WHITE,
+                    scale_factor=settings_font_scale,
+                    topleft=(hint_start_x, y_cursor),
+                )
                 y_cursor += hint_line_height
 
             y_cursor += 26
             window_hint = tr("menu.window_hint")
             for line in wrap_text(window_hint, hint_font, hint_max_width):
-                hint_surface = hint_font.render(line, False, WHITE)
-                hint_rect = hint_surface.get_rect(topleft=(hint_start_x, y_cursor))
-                screen.blit(hint_surface, hint_rect)
+                blit_text_scaled(
+                    screen,
+                    font_settings.resource,
+                    hint_size,
+                    line,
+                    WHITE,
+                    scale_factor=settings_font_scale,
+                    topleft=(hint_start_x, y_cursor),
+                )
                 y_cursor += hint_line_height
 
-            path_font = load_font(font_settings.resource, font_settings.scaled_size(11))
+            path_size = font_settings.scaled_size(11 * settings_font_scale)
+            path_font = load_font(font_settings.resource, path_size)
             config_text = tr("settings.config_path", path=str(config_path))
             progress_text = tr("settings.progress_path", path=str(user_progress_path()))
             line_height = path_font.get_linesize()
-            config_surface = path_font.render(config_text, False, LIGHT_GRAY)
-            progress_surface = path_font.render(progress_text, False, LIGHT_GRAY)
-            config_rect = config_surface.get_rect(midtop=(screen_width // 2, screen_height - 32 - line_height))
-            progress_rect = progress_surface.get_rect(midtop=(screen_width // 2, screen_height - 32))
-            screen.blit(config_surface, config_rect)
-            screen.blit(progress_surface, progress_rect)
+            blit_text_scaled(
+                screen,
+                font_settings.resource,
+                path_size,
+                config_text,
+                LIGHT_GRAY,
+                scale_factor=settings_font_scale,
+                midtop=(screen_width // 2, screen_height - 32 - line_height),
+            )
+            blit_text_scaled(
+                screen,
+                font_settings.resource,
+                path_size,
+                progress_text,
+                LIGHT_GRAY,
+                scale_factor=settings_font_scale,
+                midtop=(screen_width // 2, screen_height - 32),
+            )
         except pygame.error as e:
             print(f"Error rendering settings: {e}")