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

zombie_escape/screens/game_over.py

@@ -6,15 +6,19 @@ import pygame
 from pygame import surface, time
 
 from ..colors import BLACK, GREEN, LIGHT_GRAY, RED, WHITE
+from ..gameplay_constants import SURVIVAL_FAKE_CLOCK_RATIO
+from ..input_utils import (
+    CONTROLLER_BUTTON_DOWN,
+    CONTROLLER_DEVICE_ADDED,
+    CONTROLLER_DEVICE_REMOVED,
+    init_first_controller,
+    init_first_joystick,
+    is_confirm_event,
+    is_select_event,
+)
 from ..localization import translate as tr
 from ..models import GameData, Stage
-from ..render import (
-    RenderAssets,
-    draw_level_overview,
-    _draw_status_bar,
-    show_message,
-)
-from ..input_utils import is_confirm_event, is_select_event
+from ..render import RenderAssets, _draw_status_bar, compute_floor_cells, draw_level_overview, show_message
 from ..screens import (
     ScreenID,
     ScreenTransition,
@@ -23,7 +27,6 @@ from ..screens import (
     sync_window_size,
     toggle_fullscreen,
 )
-from ..gameplay_constants import SURVIVAL_FAKE_CLOCK_RATIO
 
 
 def game_over_screen(
@@ -46,6 +49,8 @@ def game_over_screen(
     state = game_data.state
     wall_group = game_data.groups.wall_group
     footprints_enabled = config.get("footprints", {}).get("enabled", True)
+    controller = init_first_controller()
+    joystick = init_first_joystick() if controller is None else None
 
     while True:
         if not state.overview_created:
@@ -53,11 +58,22 @@ def game_over_screen(
             level_width = level_rect.width
             level_height = level_rect.height
             overview_surface = pygame.Surface((level_width, level_height))
+            cell_size = render_assets.internal_wall_grid_snap
+            floor_cells: set[tuple[int, int]] = set()
+            if cell_size > 0:
+                floor_cells = compute_floor_cells(
+                    cols=max(0, level_width // cell_size),
+                    rows=max(0, level_height // cell_size),
+                    wall_cells=game_data.layout.wall_cells,
+                    outer_wall_cells=game_data.layout.outer_wall_cells,
+                    pitfall_cells=game_data.layout.pitfall_cells,
+                )
             footprints_to_draw = state.footprints if footprints_enabled else []
             draw_level_overview(
                 render_assets,
                 overview_surface,
                 wall_group,
+                floor_cells,
                 game_data.player,
                 game_data.car,
                 game_data.waiting_cars,
@@ -84,18 +100,14 @@ def game_over_screen(
                 scaled_w = int(scaled_h * level_aspect)
             scaled_w = max(1, scaled_w)
             scaled_h = max(1, scaled_h)
-            state.scaled_overview = pygame.transform.smoothscale(
-                overview_surface, (scaled_w, scaled_h)
-            )
+            state.scaled_overview = pygame.transform.smoothscale(overview_surface, (scaled_w, scaled_h))
             state.overview_created = True
 
         screen.fill(BLACK)
         if state.scaled_overview:
             screen.blit(
                 state.scaled_overview,
-                state.scaled_overview.get_rect(
-                    center=(screen_width // 2, screen_height // 2)
-                ),
+                state.scaled_overview.get_rect(center=(screen_width // 2, screen_height // 2)),
             )
             if state.game_won:
                 show_message(
@@ -193,6 +205,22 @@ def game_over_screen(
                         stage=stage,
                         seed=state.seed,
                     )
-            if event.type in (pygame.CONTROLLERBUTTONDOWN, pygame.JOYBUTTONDOWN):
+            if event.type == pygame.JOYDEVICEADDED or (
+                CONTROLLER_DEVICE_ADDED is not None and event.type == CONTROLLER_DEVICE_ADDED
+            ):
+                if controller is None:
+                    controller = init_first_controller()
+                if controller is None:
+                    joystick = init_first_joystick()
+            if event.type == pygame.JOYDEVICEREMOVED or (
+                CONTROLLER_DEVICE_REMOVED is not None and event.type == CONTROLLER_DEVICE_REMOVED
+            ):
+                if controller and not controller.get_init():
+                    controller = None
+                if joystick and not joystick.get_init():
+                    joystick = None
+            if event.type == pygame.JOYBUTTONDOWN or (
+                CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN
+            ):
                 if is_select_event(event) or is_confirm_event(event):
                     return ScreenTransition(ScreenID.TITLE)

zombie_escape/screens/gameplay.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any
 import pygame
 from pygame import surface, time
 
-from ..colors import LIGHT_GRAY, RED, WHITE, YELLOW
+from ..colors import RED, YELLOW
 from ..gameplay_constants import (
     CAR_HINT_DELAY_MS_DEFAULT,
     SURVIVAL_TIME_ACCEL_SUBSTEPS,
@@ -47,7 +47,7 @@ from ..gameplay.spawn import _alive_waiting_cars
 from ..world_grid import build_wall_index
 from ..localization import translate as tr
 from ..models import Stage
-from ..render import draw, prewarm_fog_overlays, show_message
+from ..render import draw, draw_debug_overview, draw_pause_overlay, prewarm_fog_overlays, show_message, show_message_wrapped
 from ..rng import generate_seed, seed_rng
 from ..progress import record_stage_clear
 from ..screens import (
@@ -116,6 +116,7 @@ def gameplay_screen(
     paused_manual = False
     paused_focus = False
     ignore_focus_loss_until = 0
+    debug_overview = False
     controller = init_first_controller()
     joystick = init_first_joystick() if controller is None else None
     _set_mouse_hidden(pygame.mouse.get_focused())
@@ -124,21 +125,14 @@ def gameplay_screen(
         layout_data = generate_level_from_blueprint(game_data, config)
     except MapGenerationError:
         # If generation fails after retries, show error and back to title
-        draw(
-            render_assets,
-            screen,
-            game_data,
-            config=config,
-            hint_color=None,
-            fps=fps,
-            present_fn=present,
-        )
-        show_message(
+        screen.fill((0, 0, 0))
+        show_message_wrapped(
             screen,
             tr("errors.map_generation_failed"),
             16,
             RED,
             (screen_width // 2, screen_height // 2),
+            max_width=screen_width - 40,
         )
         present(screen)
         pygame.time.delay(3000)
@@ -146,16 +140,12 @@ def gameplay_screen(
 
     sync_ambient_palette_with_flashlights(game_data, force=True)
     initial_waiting = max(0, stage.waiting_car_target_count)
-    player, waiting_cars = setup_player_and_cars(
-        game_data, layout_data, car_count=initial_waiting
-    )
+    player, waiting_cars = setup_player_and_cars(game_data, layout_data, car_count=initial_waiting)
     game_data.player = player
     game_data.waiting_cars = waiting_cars
     game_data.car = None
     # Only top up if initial placement spawned fewer than the intended baseline (shouldn't happen)
-    maintain_waiting_car_supply(
-        game_data, minimum=stage.waiting_car_target_count
-    )
+    maintain_waiting_car_supply(game_data, minimum=stage.waiting_car_target_count)
     apply_passenger_speed_penalty(game_data)
 
     spawn_survivors(game_data, layout_data)
@@ -204,6 +194,8 @@ def gameplay_screen(
 
     spawn_initial_zombies(game_data, player, layout_data, config)
     update_footprints(game_data, config)
+    level_rect = game_data.layout.field_rect
+    overview_surface = pygame.Surface((level_rect.width, level_rect.height))
     while True:
         dt = clock.tick(fps) / 1000.0
         current_fps = clock.get_fps()
@@ -221,7 +213,6 @@ def gameplay_screen(
                         config=config,
                         hint_color=None,
                         fps=current_fps,
-                        present_fn=present,
                     )
                     if game_data.state.game_over_message:
                         show_message(
@@ -257,16 +248,14 @@ def gameplay_screen(
             if event.type == pygame.MOUSEBUTTONDOWN:
                 paused_focus = False
             if event.type == pygame.JOYDEVICEADDED or (
-                CONTROLLER_DEVICE_ADDED is not None
-                and event.type == CONTROLLER_DEVICE_ADDED
+                CONTROLLER_DEVICE_ADDED is not None and event.type == CONTROLLER_DEVICE_ADDED
             ):
                 if controller is None:
                     controller = init_first_controller()
                 if controller is None:
                     joystick = init_first_joystick()
             if event.type == pygame.JOYDEVICEREMOVED or (
-                CONTROLLER_DEVICE_REMOVED is not None
-                and event.type == CONTROLLER_DEVICE_REMOVED
+                CONTROLLER_DEVICE_REMOVED is not None and event.type == CONTROLLER_DEVICE_REMOVED
             ):
                 if controller and not controller.get_init():
                     controller = None
@@ -282,14 +271,8 @@ def gameplay_screen(
                 if event.key == pygame.K_f:
                     toggle_fullscreen(game_data=game_data)
                     continue
-                if event.key == pygame.K_s and (
-                    pygame.key.get_mods() & pygame.KMOD_CTRL
-                ):
-                    state_snapshot = {
-                        k: v
-                        for k, v in vars(game_data.state).items()
-                        if k != "footprints"
-                    }
+                if event.key == pygame.K_s and (pygame.key.get_mods() & pygame.KMOD_CTRL):
+                    state_snapshot = {k: v for k, v in vars(game_data.state).items() if k != "footprints"}
                     print("STATE DEBUG:", state_snapshot)
                     continue
                 if debug_mode:
@@ -297,6 +280,8 @@ def gameplay_screen(
                         return ScreenTransition(ScreenID.TITLE)
                     if event.key == pygame.K_p:
                         paused_manual = not paused_manual
+                    if event.key == pygame.K_o:
+                        debug_overview = not debug_overview
                     continue
                 if paused_manual:
                     if event.key == pygame.K_ESCAPE:
@@ -308,8 +293,7 @@ def gameplay_screen(
                     paused_manual = True
                     continue
             if event.type == pygame.JOYBUTTONDOWN or (
-                CONTROLLER_BUTTON_DOWN is not None
-                and event.type == CONTROLLER_BUTTON_DOWN
+                CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN
             ):
                 if debug_mode:
                     if is_select_event(event):
@@ -336,69 +320,20 @@ def gameplay_screen(
                 screen,
                 game_data,
                 config=config,
-                do_flip=not show_pause_overlay,
                 fps=current_fps,
-                present_fn=present,
             )
             if show_pause_overlay:
-                overlay = pygame.Surface((screen_width, screen_height), pygame.SRCALPHA)
-                overlay.fill((0, 0, 0, 150))
-                pause_radius = 53
-                cx = screen_width // 2
-                cy = screen_height // 2 - 18
-                pygame.draw.circle(
-                    overlay,
-                    LIGHT_GRAY,
-                    (cx, cy),
-                    pause_radius,
-                    width=3,
-                )
-                bar_width = 10
-                bar_height = 38
-                gap = 12
-                pygame.draw.rect(
-                    overlay,
-                    LIGHT_GRAY,
-                    (cx - gap - bar_width, cy - bar_height // 2, bar_width, bar_height),
-                )
-                pygame.draw.rect(
-                    overlay,
-                    LIGHT_GRAY,
-                    (cx + gap, cy - bar_height // 2, bar_width, bar_height),
-                )
-                screen.blit(overlay, (0, 0))
-                show_message(
-                    screen,
-                    tr("hud.paused"),
-                    18,
-                    WHITE,
-                    (screen_width // 2, 28),
-                )
-                show_message(
-                    screen,
-                    tr("hud.pause_hint"),
-                    16,
-                    LIGHT_GRAY,
-                    (screen_width // 2, screen_height // 2 + 70),
-                )
-                present(screen)
+                draw_pause_overlay(screen)
+            present(screen)
             continue
 
         keys = pygame.key.get_pressed()
-        accel_allowed = not (
-            game_data.state.game_over or game_data.state.game_won
-        )
-        accel_active = accel_allowed and is_accel_active(
-            keys, controller, joystick
-        )
+        accel_allowed = not (game_data.state.game_over or game_data.state.game_won)
+        accel_active = accel_allowed and is_accel_active(keys, controller, joystick)
         game_data.state.time_accel_active = accel_active
         substeps = SURVIVAL_TIME_ACCEL_SUBSTEPS if accel_active else 1
-        sub_dt = (
-            min(dt, SURVIVAL_TIME_ACCEL_MAX_SUBSTEP) if accel_active else dt
-        )
-        wall_index = build_wall_index(
-            game_data.groups.wall_group, cell_size=game_data.cell_size
-        )
+        sub_dt = min(dt, SURVIVAL_TIME_ACCEL_MAX_SUBSTEP) if accel_active else dt
+        wall_index = build_wall_index(game_data.groups.wall_group, cell_size=game_data.cell_size)
         for _ in range(substeps):
             player_ref = game_data.player
             if player_ref is None:
@@ -436,6 +371,19 @@ def gameplay_screen(
         if player is None:
             raise ValueError("Player missing from game data")
 
+        if debug_overview:
+            draw_debug_overview(
+                render_assets,
+                screen,
+                overview_surface,
+                game_data,
+                config,
+                screen_width=screen_width,
+                screen_height=screen_height,
+            )
+            present(screen)
+            continue
+
         car_hint_conf = config.get("car_hint", {})
         hint_delay = car_hint_conf.get("delay_ms", CAR_HINT_DELAY_MS_DEFAULT)
         elapsed_ms = game_data.state.elapsed_play_ms
@@ -450,36 +398,25 @@ def gameplay_screen(
         if hint_enabled:
             if not has_fuel and game_data.fuel and game_data.fuel.alive():
                 target_type = "fuel"
-            elif not player.in_car and (
-                active_car or _alive_waiting_cars(game_data)
-            ):
+            elif not player.in_car and (active_car or _alive_waiting_cars(game_data)):
                 target_type = "car"
             else:
                 target_type = None
 
             if target_type != hint_target_type:
                 game_data.state.hint_target_type = target_type
-                game_data.state.hint_expires_at = (
-                    elapsed_ms + hint_delay if target_type else 0
-                )
+                game_data.state.hint_expires_at = elapsed_ms + hint_delay if target_type else 0
                 hint_expires_at = game_data.state.hint_expires_at
                 hint_target_type = target_type
 
-            if (
-                target_type
-                and hint_expires_at
-                and elapsed_ms >= hint_expires_at
-                and not player.in_car
-            ):
+            if target_type and hint_expires_at and elapsed_ms >= hint_expires_at and not player.in_car:
                 if target_type == "fuel" and game_data.fuel and game_data.fuel.alive():
                     hint_target = game_data.fuel.rect.center
                 elif target_type == "car":
                     if active_car:
                         hint_target = active_car.rect.center
                     else:
-                        waiting_target = nearest_waiting_car(
-                            game_data, (player.x, player.y)
-                        )
+                        waiting_target = nearest_waiting_car(game_data, (player.x, player.y))
                         if waiting_target:
                             hint_target = waiting_target.rect.center
 
@@ -491,8 +428,8 @@ def gameplay_screen(
             hint_target=hint_target,
             hint_color=hint_color,
             fps=current_fps,
-            present_fn=present,
         )
+        present(screen)
 
     # Should not reach here, but return to title if it happens
     return _finalize(ScreenTransition(ScreenID.TITLE))

zombie_escape/screens/settings.py

@@ -33,7 +33,7 @@ from ..localization import (
 from ..localization import (
     translate as tr,
 )
-from ..render import show_message
+from ..render import show_message, wrap_text
 from ..progress import user_progress_path
 from ..screens import (
     nudge_window_scale,
@@ -43,54 +43,6 @@ from ..screens import (
 )
 
 
-def _wrap_long_segment(
-    segment: str, font: pygame.font.Font, max_width: int
-) -> list[str]:
-    lines: list[str] = []
-    current = ""
-    for char in segment:
-        candidate = current + char
-        if font.size(candidate)[0] <= max_width or not current:
-            current = candidate
-        else:
-            lines.append(current)
-            current = char
-    if current:
-        lines.append(current)
-    return lines
-
-
-def _wrap_text(text: str, font: pygame.font.Font, max_width: int) -> list[str]:
-    if max_width <= 0:
-        return [text]
-    paragraphs = text.splitlines() or [text]
-    lines: list[str] = []
-    for paragraph in paragraphs:
-        if not paragraph:
-            lines.append("")
-            continue
-        words = paragraph.split(" ")
-        if len(words) == 1:
-            lines.extend(_wrap_long_segment(paragraph, font, max_width))
-            continue
-        current = ""
-        for word in words:
-            candidate = f"{current} {word}".strip() if current else word
-            if font.size(candidate)[0] <= max_width:
-                current = candidate
-                continue
-            if current:
-                lines.append(current)
-            if font.size(word)[0] <= max_width:
-                current = word
-            else:
-                lines.extend(_wrap_long_segment(word, font, max_width))
-                current = ""
-        if current:
-            lines.append(current)
-    return lines
-
-
 def settings_screen(
     screen: surface.Surface,
     clock: time.Clock,
@@ -246,16 +198,14 @@ def settings_screen(
                 sync_window_size(event)
                 continue
             if event.type == pygame.JOYDEVICEADDED or (
-                CONTROLLER_DEVICE_ADDED is not None
-                and event.type == CONTROLLER_DEVICE_ADDED
+                CONTROLLER_DEVICE_ADDED is not None and event.type == CONTROLLER_DEVICE_ADDED
             ):
                 if controller is None:
                     controller = init_first_controller()
                 if controller is None:
                     joystick = init_first_joystick()
             if event.type == pygame.JOYDEVICEREMOVED or (
-                CONTROLLER_DEVICE_REMOVED is not None
-                and event.type == CONTROLLER_DEVICE_REMOVED
+                CONTROLLER_DEVICE_REMOVED is not None and event.type == CONTROLLER_DEVICE_REMOVED
             ):
                 if controller and not controller.get_init():
                     controller = None
@@ -302,8 +252,7 @@ def settings_screen(
                     working = copy.deepcopy(DEFAULT_CONFIG)
                     set_language(working.get("language"))
             if event.type == pygame.JOYBUTTONDOWN or (
-                CONTROLLER_BUTTON_DOWN is not None
-                and event.type == CONTROLLER_BUTTON_DOWN
+                CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN
             ):
                 current_row = rows[selected]
                 row_type = current_row.get("type", "toggle")
@@ -315,15 +264,9 @@ def settings_screen(
                     elif row_type == "choice":
                         cycle_choice(current_row, 1)
                 if CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN:
-                    if (
-                        CONTROLLER_BUTTON_DPAD_UP is not None
-                        and event.button == CONTROLLER_BUTTON_DPAD_UP
-                    ):
+                    if CONTROLLER_BUTTON_DPAD_UP is not None and event.button == CONTROLLER_BUTTON_DPAD_UP:
                         selected = (selected - 1) % row_count
-                    if (
-                        CONTROLLER_BUTTON_DPAD_DOWN is not None
-                        and event.button == CONTROLLER_BUTTON_DPAD_DOWN
-                    ):
+                    if CONTROLLER_BUTTON_DPAD_DOWN is not None and event.button == CONTROLLER_BUTTON_DPAD_DOWN:
                         selected = (selected + 1) % row_count
                     if (
                         CONTROLLER_BUTTON_DPAD_LEFT is not None
@@ -380,15 +323,9 @@ def settings_screen(
 
         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_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))
             highlight_color = (70, 70, 70)
 
             row_height = 20
@@ -408,20 +345,14 @@ 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 = section_font.render(section["label"], False, LIGHT_GRAY)
                 section_states[section["label"]] = {
                     "next_y": y_cursor + header_surface.get_height() + 4,
                     "header_surface": header_surface,
                     "header_pos": (column_margin, y_cursor),
                 }
                 rows_in_section = len(section["rows"])
-                y_cursor = (
-                    section_states[section["label"]]["next_y"]
-                    + rows_in_section * row_height
-                    + section_spacing
-                )
+                y_cursor = section_states[section["label"]]["next_y"] + rows_in_section * row_height + section_spacing
 
             for state in section_states.values():
                 screen.blit(state["header_surface"], state["header_pos"])
@@ -441,9 +372,7 @@ def settings_screen(
                 row_y_current = state["next_y"]
                 state["next_y"] += row_height
 
-                highlight_rect = pygame.Rect(
-                    col_x, row_y_current - 2, row_width, row_height
-                )
+                highlight_rect = pygame.Rect(col_x, row_y_current - 2, row_width, row_height)
                 if idx == selected:
                     pygame.draw.rect(screen, highlight_color, highlight_rect)
 
@@ -457,11 +386,7 @@ def settings_screen(
                 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)
-                    )
+                    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(
                         midright=(
@@ -473,9 +398,7 @@ def settings_screen(
                 elif row_type == "toggle":
                     slider_y = row_y_current + (row_height - segment_height) // 2 - 2
                     slider_x = col_x + row_width - segment_total_width
-                    left_rect = pygame.Rect(
-                        slider_x, slider_y, segment_width, segment_height
-                    )
+                    left_rect = pygame.Rect(slider_x, slider_y, segment_width, segment_height)
                     right_rect = pygame.Rect(
                         left_rect.right + segment_gap,
                         slider_y,
@@ -486,9 +409,7 @@ def settings_screen(
                     left_active = value == row["easy_value"]
                     right_active = not left_active
 
-                    def draw_segment(
-                        rect: pygame.Rect, text: str, active: bool
-                    ) -> None:
+                    def draw_segment(rect: pygame.Rect, text: str, active: bool) -> None:
                         base_color = (35, 35, 35)
                         active_color = (60, 90, 60) if active else base_color
                         outline_color = GREEN if active else LIGHT_GRAY
@@ -522,7 +443,7 @@ def settings_screen(
 
             y_cursor += 26
             window_hint = tr("menu.window_hint")
-            for line in _wrap_text(window_hint, hint_font, hint_max_width):
+            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)
@@ -530,18 +451,12 @@ def settings_screen(
 
             path_font = load_font(font_settings.resource, font_settings.scaled_size(11))
             config_text = tr("settings.config_path", path=str(config_path))
-            progress_text = tr(
-                "settings.progress_path", path=str(user_progress_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)
-            )
+            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)
         except pygame.error as e: