zombie-escape 1.8.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

zombie_escape/render_constants.py

@@ -11,6 +11,9 @@ HUMANOID_OUTLINE_COLOR = (0, 80, 200)
 HUMANOID_OUTLINE_WIDTH = 1
 BUDDY_COLOR = (0, 180, 63)
 SURVIVOR_COLOR = (198, 198, 198)
+FALLING_ZOMBIE_COLOR = (45, 45, 45)
+FALLING_WHIRLWIND_COLOR = (200, 200, 200, 120)
+FALLING_DUST_COLOR = (70, 70, 70, 130)
 
 
 @dataclass(frozen=True)
@@ -27,7 +30,6 @@ class RenderAssets:
     player_radius: int
     fov_radius: int
     fog_radius_scale: float
-    fog_hatch_pixel_scale: int
     fog_rings: list[FogRing]
     footprint_radius: int
     footprint_overview_radius: int
@@ -35,11 +37,13 @@ class RenderAssets:
     footprint_min_fade: float
     internal_wall_grid_snap: int
     flashlight_bonus_step: float
+    flashlight_hatch_extra_scale: float
+
 
 FOG_RADIUS_SCALE = 1.2
-FOG_HATCH_PIXEL_SCALE = 2
 
 FLASHLIGHT_FOG_SCALE_STEP = 0.3
+FLASHLIGHT_HATCH_EXTRA_SCALE = 0.12
 
 FOOTPRINT_RADIUS = 2
 FOOTPRINT_OVERVIEW_RADIUS = 3
@@ -47,14 +51,20 @@ FOOTPRINT_COLOR = (110, 200, 255)
 FOOTPRINT_LIFETIME_MS = 135000
 FOOTPRINT_MIN_FADE = 0.3
 
+SHADOW_OVERSAMPLE = 2
+SHADOW_STEPS = 10
+SHADOW_MIN_RATIO = 0.0
+SHADOW_RADIUS_RATIO = 0.3
+
 FOG_RINGS = [
-    FogRing(radius_factor=0.529, thickness=2),
-    FogRing(radius_factor=0.639, thickness=4),
-    FogRing(radius_factor=0.748, thickness=6),
-    FogRing(radius_factor=0.858, thickness=8),
-    FogRing(radius_factor=0.968, thickness=12),
+    FogRing(radius_factor=0.536, thickness=2),
+    FogRing(radius_factor=0.645, thickness=3),
+    FogRing(radius_factor=0.754, thickness=5),
+    FogRing(radius_factor=0.863, thickness=8),
+    FogRing(radius_factor=0.972, thickness=12),
 ]
 
+
 def build_render_assets(cell_size: int) -> RenderAssets:
     return RenderAssets(
         screen_width=SCREEN_WIDTH,
@@ -63,7 +73,6 @@ def build_render_assets(cell_size: int) -> RenderAssets:
         player_radius=PLAYER_RADIUS,
         fov_radius=FOV_RADIUS,
         fog_radius_scale=FOG_RADIUS_SCALE,
-        fog_hatch_pixel_scale=FOG_HATCH_PIXEL_SCALE,
         fog_rings=FOG_RINGS,
         footprint_radius=FOOTPRINT_RADIUS,
         footprint_overview_radius=FOOTPRINT_OVERVIEW_RADIUS,
@@ -71,17 +80,26 @@ def build_render_assets(cell_size: int) -> RenderAssets:
         footprint_min_fade=FOOTPRINT_MIN_FADE,
         internal_wall_grid_snap=cell_size,
         flashlight_bonus_step=FLASHLIGHT_FOG_SCALE_STEP,
+        flashlight_hatch_extra_scale=FLASHLIGHT_HATCH_EXTRA_SCALE,
     )
 
 
 __all__ = [
     "BUDDY_COLOR",
+    "FALLING_ZOMBIE_COLOR",
+    "FALLING_WHIRLWIND_COLOR",
+    "FALLING_DUST_COLOR",
     "HUMANOID_OUTLINE_COLOR",
     "HUMANOID_OUTLINE_WIDTH",
     "SURVIVOR_COLOR",
     "FogRing",
     "RenderAssets",
     "FOG_RADIUS_SCALE",
+    "SHADOW_OVERSAMPLE",
+    "SHADOW_STEPS",
+    "SHADOW_MIN_RATIO",
+    "SHADOW_RADIUS_RATIO",
     "FLASHLIGHT_FOG_SCALE_STEP",
+    "FLASHLIGHT_HATCH_EXTRA_SCALE",
     "build_render_assets",
 ]

zombie_escape/screens/__init__.py

@@ -159,6 +159,7 @@ def toggle_fullscreen(
         window_width, window_height = _fetch_window_size(window)
         _update_window_caption(window_width, window_height)
         _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

zombie_escape/screens/game_over.py

@@ -130,16 +130,16 @@ def game_over_screen(
                     LIGHT_GRAY,
                     (screen_width // 2, summary_y),
                 )
-            elif stage and stage.survival_stage:
-                elapsed_ms = max(0, state.survival_elapsed_ms)
-                goal_ms = max(0, state.survival_goal_ms)
+            elif stage and stage.endurance_stage:
+                elapsed_ms = max(0, state.endurance_elapsed_ms)
+                goal_ms = max(0, state.endurance_goal_ms)
                 if goal_ms:
                     elapsed_ms = min(elapsed_ms, goal_ms)
                 display_ms = int(elapsed_ms * SURVIVAL_FAKE_CLOCK_RATIO)
                 hours = display_ms // 3_600_000
                 minutes = (display_ms % 3_600_000) // 60_000
                 time_label = f"{int(hours):02d}:{int(minutes):02d}"
-                msg = tr("game_over.survival_duration", time=time_label)
+                msg = tr("game_over.endurance_duration", time=time_label)
                 show_message(
                     screen,
                     msg,

zombie_escape/screens/gameplay.py

@@ -8,7 +8,6 @@ from pygame import surface, time
 from ..colors import LIGHT_GRAY, RED, WHITE, YELLOW
 from ..gameplay_constants import (
     CAR_HINT_DELAY_MS_DEFAULT,
-    DEFAULT_FLASHLIGHT_SPAWN_COUNT,
     SURVIVAL_TIME_ACCEL_SUBSTEPS,
     SURVIVAL_TIME_ACCEL_MAX_SUBSTEP,
 )
@@ -29,7 +28,7 @@ from ..gameplay import (
     sync_ambient_palette_with_flashlights,
     update_entities,
     update_footprints,
-    update_survival_timer,
+    update_endurance_timer,
 )
 from ..input_utils import (
     CONTROLLER_BUTTON_DOWN,
@@ -43,7 +42,7 @@ from ..input_utils import (
     read_gamepad_move,
 )
 from ..gameplay.spawn import _alive_waiting_cars
-from ..entities import build_wall_index
+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
@@ -83,11 +82,11 @@ def gameplay_screen(
     game_data = initialize_game_state(config, stage)
     game_data.state.seed = applied_seed
     game_data.state.debug_mode = debug_mode
-    if debug_mode and stage.survival_stage:
-        goal_ms = max(0, stage.survival_goal_ms)
+    if debug_mode and stage.endurance_stage:
+        goal_ms = max(0, stage.endurance_goal_ms)
         if goal_ms > 0:
             remaining = 3 * 60 * 1000  # 3 minutes in ms
-            game_data.state.survival_elapsed_ms = max(0, goal_ms - remaining)
+            game_data.state.endurance_elapsed_ms = max(0, goal_ms - remaining)
             game_data.state.dawn_ready = False
             game_data.state.dawn_prompt_at = None
             game_data.state.dawn_carbonized = False
@@ -99,7 +98,6 @@ def gameplay_screen(
     paused_manual = False
     paused_focus = False
     ignore_focus_loss_until = 0
-    last_fov_target = None
     controller = init_first_controller()
     joystick = init_first_joystick() if controller is None else None
 
@@ -131,19 +129,18 @@ def gameplay_screen(
         if fuel_can:
             game_data.fuel = fuel_can
             game_data.groups.all_sprites.add(fuel_can, layer=1)
+    flashlight_count = stage.initial_flashlight_count
     flashlights = place_flashlights(
         layout_data["walkable_cells"],
         player,
         cars=game_data.waiting_cars,
-        count=max(1, DEFAULT_FLASHLIGHT_SPAWN_COUNT),
+        count=max(0, flashlight_count),
     )
     game_data.flashlights = flashlights
     game_data.groups.all_sprites.add(flashlights, layer=1)
 
     spawn_initial_zombies(game_data, player, layout_data, config)
     update_footprints(game_data, config)
-    last_fov_target = player
-
     while True:
         dt = clock.tick(fps) / 1000.0
         if game_data.state.game_over or game_data.state.game_won:
@@ -157,7 +154,6 @@ def gameplay_screen(
                         render_assets,
                         screen,
                         game_data,
-                        last_fov_target,
                         config=config,
                         hint_color=None,
                         present_fn=present,
@@ -261,7 +257,6 @@ def gameplay_screen(
                 render_assets,
                 screen,
                 game_data,
-                last_fov_target,
                 config=config,
                 do_flip=not show_pause_overlay,
                 present_fn=present,
@@ -325,7 +320,6 @@ def gameplay_screen(
         wall_index = build_wall_index(
             game_data.groups.wall_group, cell_size=game_data.cell_size
         )
-        frame_fov_target = None
         for _ in range(substeps):
             player_ref = game_data.player
             if player_ref is None:
@@ -349,19 +343,12 @@ def gameplay_screen(
             if accel_active:
                 step_ms = max(1, step_ms)
             game_data.state.elapsed_play_ms += step_ms
-            update_survival_timer(game_data, step_ms)
+            update_endurance_timer(game_data, step_ms)
             cleanup_survivor_messages(game_data.state)
-            sub_fov_target = check_interactions(game_data, config)
-            if sub_fov_target:
-                frame_fov_target = sub_fov_target
+            check_interactions(game_data, config)
             if game_data.state.game_over or game_data.state.game_won:
                 break
 
-        if frame_fov_target:
-            last_fov_target = frame_fov_target
-        else:
-            frame_fov_target = last_fov_target
-
         player = game_data.player
         if player is None:
             raise ValueError("Player missing from game data")
@@ -370,7 +357,7 @@ def gameplay_screen(
         hint_delay = car_hint_conf.get("delay_ms", CAR_HINT_DELAY_MS_DEFAULT)
         elapsed_ms = game_data.state.elapsed_play_ms
         has_fuel = game_data.state.has_fuel
-        hint_enabled = car_hint_conf.get("enabled", True) and not stage.survival_stage
+        hint_enabled = car_hint_conf.get("enabled", True) and not stage.endurance_stage
         hint_target = None
         hint_color = YELLOW
         hint_expires_at = game_data.state.hint_expires_at
@@ -417,7 +404,6 @@ def gameplay_screen(
             render_assets,
             screen,
             game_data,
-            frame_fov_target,
             config=config,
             hint_target=hint_target,
             hint_color=hint_color,

zombie_escape/stage_constants.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from .entities_constants import ZOMBIE_AGING_DURATION_FRAMES
 from .gameplay_constants import SURVIVOR_SPAWN_RATE
+from .level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS
 from .models import Stage
 
 STAGES: list[Stage] = [
@@ -23,6 +24,7 @@ STAGES: list[Stage] = [
         requires_fuel=True,
         exterior_spawn_weight=0.97,
         interior_spawn_weight=0.03,
+        initial_interior_spawn_rate=0.007,
     ),
     Stage(
         id="stage3",
@@ -33,6 +35,7 @@ STAGES: list[Stage] = [
         requires_fuel=True,
         exterior_spawn_weight=0.97,
         interior_spawn_weight=0.03,
+        initial_interior_spawn_rate=0.007,
     ),
     Stage(
         id="stage4",
@@ -42,6 +45,7 @@ STAGES: list[Stage] = [
         rescue_stage=True,
         waiting_car_target_count=2,
         survivor_spawn_rate=SURVIVOR_SPAWN_RATE,
+        initial_interior_spawn_rate=0.007,
     ),
     Stage(
         id="stage5",
@@ -49,8 +53,8 @@ STAGES: list[Stage] = [
         description_key="stages.stage5.description",
         available=True,
         requires_fuel=True,
-        survival_stage=True,
-        survival_goal_ms=1_200_000,
+        endurance_stage=True,
+        endurance_goal_ms=1_200_000,
         fuel_spawn_count=0,
         exterior_spawn_weight=0.4,
         interior_spawn_weight=0.6,
@@ -137,6 +141,90 @@ STAGES: list[Stage] = [
         waiting_car_target_count=1,
         survivor_spawn_rate=0.35,
     ),
+    Stage(
+        id="stage11",
+        name_key="stages.stage11.name",
+        description_key="stages.stage11.description",
+        grid_cols=120,
+        grid_rows=7,
+        available=True,
+        wall_algorithm="sparse",
+        exterior_spawn_weight=0.3,
+        interior_spawn_weight=0.7,
+        zombie_normal_ratio=0.5,
+        zombie_tracker_ratio=0.5,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.1,
+        waiting_car_target_count=1,
+    ),
+    Stage(
+        id="stage12",
+        name_key="stages.stage12.name",
+        description_key="stages.stage12.description",
+        grid_cols=32,
+        grid_rows=32,
+        available=True,
+        requires_fuel=True,
+        exterior_spawn_weight=0.5,
+        interior_spawn_weight=0.2,
+        interior_fall_spawn_weight=0.3,
+        fall_spawn_zones=[
+            (3, 3, 12, 12),
+            (3, 17, 12, 12),
+            (17, 3, 12, 12),
+            (17, 17, 12, 12),
+        ],
+        initial_flashlight_count=5,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+    ),
+    Stage(
+        id="stage13",
+        name_key="stages.stage13.name",
+        description_key="stages.stage13.description",
+        available=True,
+        wall_algorithm="grid_wire",
+        buddy_required_count=1,
+        requires_fuel=True,
+        exterior_spawn_weight=0.6,
+        interior_spawn_weight=0.1,
+        interior_fall_spawn_weight=0.3,
+        zombie_normal_ratio=0.4,
+        zombie_tracker_ratio=0.3,
+        zombie_wall_follower_ratio=0.3,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_flashlight_count=3,
+        fall_spawn_zones=[
+            (x, y, 2, 2)
+            for y in range(2, DEFAULT_GRID_ROWS - 2, 4)
+            for x in range(2, DEFAULT_GRID_COLS - 2, 4)
+        ],
+    ),
+    Stage(
+        id="stage14",
+        name_key="stages.stage14.name",
+        description_key="stages.stage14.description",
+        grid_cols=42,
+        grid_rows=27,
+        available=False,
+        requires_fuel=True,
+        exterior_spawn_weight=0.2,
+        interior_spawn_weight=0.1,
+        interior_fall_spawn_weight=0.7,
+        fall_spawn_zones=[
+            (4, 10, 3, 3),
+            (5, 20, 3, 3),
+            (15, 17, 3, 3),
+            (22, 16, 3, 3),
+            (17, 20, 3, 3),
+            (26, 22, 3, 3),
+            (31, 17, 3, 3),
+            (33, 10, 3, 3),
+            (34, 7, 3, 3),
+            (35, 13, 3, 3),
+        ],
+        initial_flashlight_count=5,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+    ),
 ]
 DEFAULT_STAGE_ID = "stage1"
 

zombie_escape/world_grid.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import math
+from typing import Iterable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .entities import Wall
+
+
+WallIndex = dict[tuple[int, int], list["Wall"]]
+
+
+def build_wall_index(walls: Iterable["Wall"], *, cell_size: int) -> WallIndex:
+    index: WallIndex = {}
+    if cell_size <= 0:
+        return index
+    for wall in walls:
+        cell_x = int(wall.rect.centerx // cell_size)
+        cell_y = int(wall.rect.centery // cell_size)
+        index.setdefault((cell_x, cell_y), []).append(wall)
+    return index
+
+
+def _infer_grid_size_from_index(wall_index: WallIndex) -> tuple[int | None, int | None]:
+    if not wall_index:
+        return None, None
+    max_col = max(cell[0] for cell in wall_index)
+    max_row = max(cell[1] for cell in wall_index)
+    return max_col + 1, max_row + 1
+
+
+def walls_for_radius(
+    wall_index: WallIndex,
+    center: tuple[float, float],
+    radius: float,
+    *,
+    cell_size: int,
+    grid_cols: int | None = None,
+    grid_rows: int | None = None,
+) -> list["Wall"]:
+    if grid_cols is None or grid_rows is None:
+        grid_cols, grid_rows = _infer_grid_size_from_index(wall_index)
+    if grid_cols is None or grid_rows is None:
+        return []
+    search_radius = radius + cell_size
+    min_x = max(0, int((center[0] - search_radius) // cell_size))
+    max_x = min(grid_cols - 1, int((center[0] + search_radius) // cell_size))
+    min_y = max(0, int((center[1] - search_radius) // cell_size))
+    max_y = min(grid_rows - 1, int((center[1] + search_radius) // cell_size))
+    candidates: list[Wall] = []
+    for cy in range(min_y, max_y + 1):
+        for cx in range(min_x, max_x + 1):
+            candidates.extend(wall_index.get((cx, cy), []))
+    return candidates
+
+
+def apply_tile_edge_nudge(
+    x: float,
+    y: float,
+    dx: float,
+    dy: float,
+    *,
+    cell_size: int,
+    wall_cells: set[tuple[int, int]] | None,
+    bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] | None = None,
+    grid_cols: int,
+    grid_rows: int,
+    strength: float = 0.03,
+    edge_margin_ratio: float = 0.15,
+    min_margin: float = 2.0,
+) -> tuple[float, float]:
+    if dx == 0 and dy == 0:
+        return dx, dy
+    if cell_size <= 0 or not wall_cells:
+        return dx, dy
+    cell_x = int(x // cell_size)
+    cell_y = int(y // cell_size)
+    if cell_x < 0 or cell_y < 0 or cell_x >= grid_cols or cell_y >= grid_rows:
+        return dx, dy
+    speed = math.hypot(dx, dy)
+    if speed <= 0:
+        return dx, dy
+
+    edge_margin = max(min_margin, cell_size * edge_margin_ratio)
+    left_dist = x - (cell_x * cell_size)
+    right_dist = ((cell_x + 1) * cell_size) - x
+    top_dist = y - (cell_y * cell_size)
+    bottom_dist = ((cell_y + 1) * cell_size) - y
+
+    def apply_push(dist: float, direction: float) -> float:
+        if dist >= edge_margin:
+            return 0.0
+        ratio = (edge_margin - dist) / edge_margin
+        return ratio * speed * strength * direction
+
+    if (cell_x - 1, cell_y) in wall_cells:
+        dx += apply_push(left_dist, 1.0)
+    if (cell_x + 1, cell_y) in wall_cells:
+        dx += apply_push(right_dist, -1.0)
+    if (cell_x, cell_y - 1) in wall_cells:
+        dy += apply_push(top_dist, 1.0)
+    if (cell_x, cell_y + 1) in wall_cells:
+        dy += apply_push(bottom_dist, -1.0)
+
+    def apply_corner_push(dist_a: float, dist_b: float, boost: float = 1.0) -> float:
+        if dist_a >= edge_margin or dist_b >= edge_margin:
+            return 0.0
+        ratio = (edge_margin - min(dist_a, dist_b)) / edge_margin
+        return ratio * speed * strength * boost
+
+    if bevel_corners:
+        boosted = 1.25
+        corner_wall = bevel_corners.get((cell_x - 1, cell_y - 1))
+        if corner_wall and corner_wall[2]:
+            push = apply_corner_push(left_dist, top_dist, boosted)
+            dx += push
+            dy += push
+        corner_wall = bevel_corners.get((cell_x + 1, cell_y - 1))
+        if corner_wall and corner_wall[3]:
+            push = apply_corner_push(right_dist, top_dist, boosted)
+            dx -= push
+            dy += push
+        corner_wall = bevel_corners.get((cell_x + 1, cell_y + 1))
+        if corner_wall and corner_wall[0]:
+            push = apply_corner_push(right_dist, bottom_dist, boosted)
+            dx -= push
+            dy -= push
+        corner_wall = bevel_corners.get((cell_x - 1, cell_y + 1))
+        if corner_wall and corner_wall[1]:
+            push = apply_corner_push(left_dist, bottom_dist, boosted)
+            dx += push
+            dy -= push
+
+    return dx, dy

zombie_escape/zombie_escape.py

@@ -22,7 +22,7 @@ from .gameplay import calculate_car_speed_for_passengers
 from .level_constants import DEFAULT_TILE_SIZE
 from .localization import set_language
 from .models import GameData, Stage
-from .render_constants import build_render_assets
+from .render_constants import RenderAssets, build_render_assets
 from .screen_constants import (
     DEFAULT_WINDOW_SCALE,
     FPS,
@@ -95,6 +95,7 @@ def main() -> None:
     from .screens.gameplay import gameplay_screen
 
     apply_window_scale(DEFAULT_WINDOW_SCALE)
+    pygame.mouse.set_visible(True)
     screen = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT)).convert_alpha()
     clock = pygame.time.Clock()
 
@@ -109,15 +110,54 @@ def main() -> None:
         save_config(config, config_path)
     set_language(config.get("language"))
 
+    def _profiled_gameplay_screen(
+        screen: pygame.Surface,
+        clock: pygame.time.Clock,
+        config: dict[str, Any],
+        fps: int,
+        stage: Stage,
+        *,
+        show_pause_overlay: bool,
+        seed: int | None,
+        render_assets: RenderAssets,
+        debug_mode: bool,
+    ) -> ScreenTransition:
+        import cProfile
+        import pstats
+
+        profiler = cProfile.Profile()
+        try:
+            return profiler.runcall(
+                gameplay_screen,
+                screen,
+                clock,
+                config,
+                fps,
+                stage,
+                show_pause_overlay=show_pause_overlay,
+                seed=seed,
+                render_assets=render_assets,
+                debug_mode=debug_mode,
+            )
+        finally:
+            output_path = Path(args.profile_output)
+            profiler.dump_stats(output_path)
+            summary_path = output_path.with_suffix(".txt")
+            with summary_path.open("w", encoding="utf-8") as handle:
+                stats = pstats.Stats(
+                    profiler,
+                    stream=handle,
+                ).sort_stats("tottime")
+                stats.print_stats(50)
+            print(f"Profile saved to {output_path} and {summary_path}")
+
     next_screen = ScreenID.TITLE
-    pending_stage: Stage | None = None
-    pending_game_data: GameData | None = None
-    pending_config: dict[str, Any] | None = None
-    pending_seed: int | None = None
+    transition: ScreenTransition | None = None
     running = True
 
     while running:
-        transition: ScreenTransition | None = None
+        incoming = transition
+        transition = None
 
         if next_screen == ScreenID.TITLE:
             seed_input = None if title_seed_is_auto else title_seed_text
@@ -147,56 +187,26 @@ def main() -> None:
             set_language(config.get("language"))
             transition = ScreenTransition(ScreenID.TITLE)
         elif next_screen == ScreenID.GAMEPLAY:
-            stage = pending_stage
-            pending_stage = None
-            seed_value = pending_seed
-            pending_seed = None
+            stage = incoming.stage
+            seed_value = incoming.seed
             if stage is None:
                 transition = ScreenTransition(ScreenID.TITLE)
             else:
                 last_stage_id = stage.id
+                render_assets = build_render_assets(stage.tile_size)
                 try:
-                    if args.profile:
-                        import cProfile
-                        import pstats
-
-                        profiler = cProfile.Profile()
-                        try:
-                            render_assets = build_render_assets(stage.tile_size)
-                            transition = profiler.runcall(
-                                gameplay_screen,
-                                screen,
-                                clock,
-                                config,
-                                FPS,
-                                stage,
-                                show_pause_overlay=not debug_mode,
-                                seed=seed_value,
-                                render_assets=render_assets,
-                                debug_mode=debug_mode,
-                            )
-                        finally:
-                            output_path = Path(args.profile_output)
-                            profiler.dump_stats(output_path)
-                            summary_path = output_path.with_suffix(".txt")
-                            stats = pstats.Stats(profiler).sort_stats("tottime")
-                            with summary_path.open("w", encoding="utf-8") as handle:
-                                stats.stream = handle
-                                stats.print_stats(50)
-                            print(f"Profile saved to {output_path} and {summary_path}")
-                    else:
-                        render_assets = build_render_assets(stage.tile_size)
-                        transition = gameplay_screen(
-                            screen,
-                            clock,
-                            config,
-                            FPS,
-                            stage,
-                            show_pause_overlay=not debug_mode,
-                            seed=seed_value,
-                            render_assets=render_assets,
-                            debug_mode=debug_mode,
-                        )
+                    gs = _profiled_gameplay_screen if args.profile else gameplay_screen
+                    transition = gs(
+                        screen,
+                        clock,
+                        config,
+                        FPS,
+                        stage,
+                        show_pause_overlay=not debug_mode,
+                        seed=seed_value,
+                        render_assets=render_assets,
+                        debug_mode=debug_mode,
+                    )
                 except SystemExit:
                     running = False
                     break
@@ -206,12 +216,10 @@ def main() -> None:
                     running = False
                     break
         elif next_screen == ScreenID.GAME_OVER:
-            game_data = pending_game_data
-            stage = pending_stage
-            config_payload = pending_config
-            pending_game_data = None
-            pending_stage = None
-            pending_config = None
+            game_data = incoming.game_data if incoming else None
+            stage = incoming.stage if incoming else None
+            config_payload = incoming.config if incoming else None
+            assert config_payload is not None
             if game_data is not None:
                 render_assets = build_render_assets(game_data.cell_size)
             elif stage is not None:
@@ -235,10 +243,6 @@ def main() -> None:
         if not transition:
             break
 
-        pending_stage = transition.stage
-        pending_game_data = transition.game_data
-        pending_config = transition.config
-        pending_seed = transition.seed
         if transition.next_screen == ScreenID.GAMEPLAY:
             title_seed_text = cli_seed_text
             title_seed_is_auto = cli_seed_is_auto