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

zombie_escape/font_utils.py

@@ -41,5 +41,52 @@ def load_font(resource: str | None, size: int) -> pygame.font.Font:
     return font
 
 
+def render_text_scaled(
+    resource: str | None,
+    size: int,
+    text: str,
+    color: tuple[int, int, int],
+    *,
+    scale_factor: int = 1,
+    antialias: bool = False,
+) -> pygame.Surface:
+    """Render text, optionally supersampling then downscaling."""
+    normalized_size = max(1, int(size))
+    if scale_factor <= 1:
+        font = load_font(resource, normalized_size)
+        return font.render(text, antialias, color)
+    high_size = max(1, int(round(normalized_size * scale_factor)))
+    font_high = load_font(resource, high_size)
+    high_surface = font_high.render(text, antialias, color)
+    target_width = max(1, int(round(high_surface.get_width() / scale_factor)))
+    target_height = max(1, int(round(high_surface.get_height() / scale_factor)))
+    return pygame.transform.scale(high_surface, (target_width, target_height))
+
+
+def blit_text_scaled(
+    target: pygame.Surface,
+    resource: str | None,
+    size: int,
+    text: str,
+    color: tuple[int, int, int],
+    *,
+    scale_factor: int = 1,
+    antialias: bool = False,
+    **rect_kwargs: int | tuple[int, int],
+) -> pygame.Rect:
+    """Render scaled text and blit it to target using rect kwargs."""
+    surface = render_text_scaled(
+        resource,
+        size,
+        text,
+        color,
+        scale_factor=scale_factor,
+        antialias=antialias,
+    )
+    rect = surface.get_rect(**rect_kwargs)
+    target.blit(surface, rect)
+    return rect
+
+
 def clear_font_cache() -> None:
     _FONT_CACHE.clear()

zombie_escape/gameplay/__init__.py

@@ -22,7 +22,7 @@ from .spawn import (
     spawn_waiting_car,
     spawn_weighted_zombie,
 )
-from .state import carbonize_outdoor_zombies, initialize_game_state, update_endurance_timer
+from .state import carbonize_outdoor_zombies, initialize_game_state, schedule_timed_message, update_endurance_timer
 from .survivors import (
     add_survivor_message,
     apply_passenger_speed_penalty,
@@ -72,6 +72,7 @@ __all__ = [
     "get_shrunk_sprite",
     "update_footprints",
     "initialize_game_state",
+    "schedule_timed_message",
     "setup_player_and_cars",
     "spawn_initial_zombies",
     "update_endurance_timer",

zombie_escape/gameplay/constants.py

@@ -8,6 +8,8 @@ from ..entities_constants import ZOMBIE_AGING_DURATION_FRAMES
 SURVIVOR_SPEED_PENALTY_PER_PASSENGER = 0.08
 SURVIVOR_OVERLOAD_DAMAGE_RATIO = 0.2
 SURVIVOR_MESSAGE_DURATION_MS = 2000
+INTRO_MESSAGE_DISPLAY_FRAMES = 180
+SCREAM_MESSAGE_DISPLAY_FRAMES = 60
 
 # --- Footprint settings (gameplay) ---
 FOOTPRINT_STEP_DISTANCE = 40
@@ -32,6 +34,8 @@ __all__ = [
     "SURVIVOR_SPEED_PENALTY_PER_PASSENGER",
     "SURVIVOR_OVERLOAD_DAMAGE_RATIO",
     "SURVIVOR_MESSAGE_DURATION_MS",
+    "INTRO_MESSAGE_DISPLAY_FRAMES",
+    "SCREAM_MESSAGE_DISPLAY_FRAMES",
     "FOOTPRINT_STEP_DISTANCE",
     "FOOTPRINT_MAX",
     "MAX_ZOMBIES",

zombie_escape/gameplay/interactions.py

@@ -5,6 +5,9 @@ from typing import Any
 import pygame
 
 from ..entities_constants import (
+    BUDDY_FOLLOW_START_DISTANCE,
+    BUDDY_FOLLOW_STOP_DISTANCE,
+    BUDDY_MERGE_DISTANCE,
     CAR_HEIGHT,
     CAR_WIDTH,
     FLASHLIGHT_HEIGHT,
@@ -14,7 +17,6 @@ from ..entities_constants import (
     HUMANOID_RADIUS,
     SHOES_HEIGHT,
     SHOES_WIDTH,
-    SURVIVOR_APPROACH_RADIUS,
     SURVIVOR_MAX_SAFE_PASSENGERS,
 )
 from .constants import (
@@ -22,9 +24,12 @@ from .constants import (
     FUEL_HINT_DURATION_MS,
     SURVIVOR_OVERLOAD_DAMAGE_RATIO,
 )
+from ..colors import BLUE, YELLOW
 from ..localization import translate as tr
 from ..models import GameData
 from ..rng import get_rng
+from ..render_constants import BUDDY_COLOR
+from ..screen_constants import FPS
 from ..entities import Car
 from .footprints import get_shrunk_sprite
 from .spawn import maintain_waiting_car_supply
@@ -36,8 +41,10 @@ from .survivors import (
     increase_survivor_capacity,
     respawn_buddies_near_player,
 )
-from .utils import rect_visible_on_screen
+from .utils import is_entity_in_fov, rect_visible_on_screen
 from .ambient import sync_ambient_palette_with_flashlights
+from .constants import SCREAM_MESSAGE_DISPLAY_FRAMES
+from .state import schedule_timed_message
 
 
 def _interaction_radius(width: float, height: float) -> float:
@@ -45,6 +52,12 @@ def _interaction_radius(width: float, height: float) -> float:
     return HUMANOID_RADIUS + (width + height) / 4
 
 
+def _ms_to_frames(ms: int) -> int:
+    if ms <= 0:
+        return 0
+    return max(1, int(round(ms / (1000 / max(1, FPS)))))
+
+
 RNG = get_rng()
 
 
@@ -65,6 +78,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     camera = game_data.camera
     stage = game_data.stage
     cell_size = game_data.cell_size
+    need_fuel_text = tr("hud.need_fuel")
     maintain_waiting_car_supply(game_data)
     active_car = car if car and car.alive() else None
     waiting_cars = game_data.waiting_cars
@@ -101,7 +115,8 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     if fuel and fuel.alive() and not state.has_fuel and not player.in_car:
         if _player_near_point(fuel.rect.center, fuel_interaction_radius):
             state.has_fuel = True
-            state.fuel_message_until = 0
+            if state.timed_message == need_fuel_text:
+                schedule_timed_message(state, None, duration_frames=0)
             state.hint_expires_at = 0
             state.hint_target_type = None
             fuel.kill()
@@ -145,7 +160,6 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     buddies = [
         survivor for survivor in survivor_group if survivor.alive() and survivor.is_buddy and not survivor.rescued
     ]
-
     # Buddy interactions (Stage 3)
     if stage.buddy_required_count > 0 and buddies:
         for buddy in list(buddies):
@@ -154,7 +168,10 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
             buddy_on_screen = rect_visible_on_screen(camera, buddy.rect)
             if not player.in_car:
                 dist_to_player_sq = (player.x - buddy.x) ** 2 + (player.y - buddy.y) ** 2
-                if dist_to_player_sq <= SURVIVOR_APPROACH_RADIUS * SURVIVOR_APPROACH_RADIUS:
+                if buddy.following:
+                    if dist_to_player_sq >= BUDDY_FOLLOW_STOP_DISTANCE * BUDDY_FOLLOW_STOP_DISTANCE:
+                        buddy.following = False
+                elif dist_to_player_sq <= BUDDY_FOLLOW_START_DISTANCE * BUDDY_FOLLOW_START_DISTANCE:
                     buddy.set_following()
             elif player.in_car and active_car and shrunk_car:
                 g = pygame.sprite.Group()
@@ -174,8 +191,24 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                     continue
 
             if buddy.alive() and pygame.sprite.spritecollide(buddy, zombie_group, False, pygame.sprite.collide_circle):
-                if buddy_on_screen:
-                    state.game_over_message = tr("game_over.scream")
+                fov_target = None
+                if player.in_car and active_car:
+                    fov_target = active_car
+                else:
+                    fov_target = player
+                buddy_in_fov = is_entity_in_fov(
+                    buddy.rect,
+                    fov_target=fov_target,
+                    flashlight_count=state.flashlight_count,
+                )
+                if buddy_on_screen and buddy_in_fov:
+                    schedule_timed_message(
+                        state,
+                        tr("game_over.scream"),
+                        duration_frames=SCREAM_MESSAGE_DISPLAY_FRAMES,
+                        clear_on_input=False,
+                        color=BUDDY_COLOR,
+                    )
                     state.game_over = True
                     state.game_over_at = state.game_over_at or pygame.time.get_ticks()
                 else:
@@ -183,9 +216,23 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                         new_cell = RNG.choice(walkable_cells)
                         buddy.teleport(_cell_center(new_cell))
                     else:
-                        buddy.teleport((game_data.level_width // 2, game_data.level_height // 2))
+                        buddy.teleport(game_data.layout.field_rect.center)
                     buddy.following = False
 
+    if stage.buddy_required_count > 0:
+        near_following_count = 0
+        max_dist_sq = BUDDY_MERGE_DISTANCE * BUDDY_MERGE_DISTANCE
+        for buddy in buddies:
+            if not buddy.following:
+                continue
+            dx = player.x - buddy.x
+            dy = player.y - buddy.y
+            if (dx * dx + dy * dy) <= max_dist_sq:
+                near_following_count += 1
+        state.buddy_merged_count = state.buddy_onboard + near_following_count
+    else:
+        state.buddy_merged_count = 0
+
     # Player entering an active car already under control
     if not player.in_car and _player_near_car(active_car) and active_car and active_car.health > 0:
         if state.has_fuel:
@@ -196,8 +243,13 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
             print("Player entered car!")
         else:
             if not stage.endurance_stage:
-                now_ms = state.elapsed_play_ms
-                state.fuel_message_until = now_ms + FUEL_HINT_DURATION_MS
+                schedule_timed_message(
+                    state,
+                    need_fuel_text,
+                    duration_frames=_ms_to_frames(FUEL_HINT_DURATION_MS),
+                    clear_on_input=False,
+                    color=YELLOW,
+                )
                 state.hint_target_type = "fuel"
 
     # Claim a waiting/parked car when the player finally reaches it
@@ -224,8 +276,13 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                 print("Player claimed a waiting car!")
             else:
                 if not stage.endurance_stage:
-                    now_ms = state.elapsed_play_ms
-                    state.fuel_message_until = now_ms + FUEL_HINT_DURATION_MS
+                    schedule_timed_message(
+                        state,
+                        need_fuel_text,
+                        duration_frames=_ms_to_frames(FUEL_HINT_DURATION_MS),
+                        clear_on_input=False,
+                        color=YELLOW,
+                    )
                     state.hint_target_type = "fuel"
 
     # Bonus: collide a parked car while driving to repair/extend capabilities
@@ -307,7 +364,13 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
             if not state.game_over:
                 state.game_over = True
                 state.game_over_at = pygame.time.get_ticks()
-                state.game_over_message = tr("game_over.scream")
+                schedule_timed_message(
+                    state,
+                    tr("game_over.scream"),
+                    duration_frames=SCREAM_MESSAGE_DISPLAY_FRAMES,
+                    clear_on_input=False,
+                    color=BLUE,
+                )
 
     # Player escaping on foot after dawn (Stage 5)
     if (
@@ -318,17 +381,21 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         and (player_cell := _rect_center_cell(player.rect)) is not None
         and player_cell in outside_cells
     ):
-        state.game_won = True
+        buddy_ready = True
+        if stage.buddy_required_count > 0:
+            buddy_ready = state.buddy_merged_count >= stage.buddy_required_count
+        if buddy_ready:
+            state.game_won = True
 
     # Player escaping the level
     if player.in_car and car and car.alive() and state.has_fuel:
         buddy_ready = True
         if stage.buddy_required_count > 0:
-            buddy_ready = state.buddy_onboard >= stage.buddy_required_count
+            buddy_ready = state.buddy_merged_count >= stage.buddy_required_count
         car_cell = _rect_center_cell(car.rect)
         if buddy_ready and car_cell is not None and car_cell in outside_cells:
             if stage.buddy_required_count > 0:
-                state.buddy_rescued = min(stage.buddy_required_count, state.buddy_onboard)
+                state.buddy_rescued = min(stage.buddy_required_count, state.buddy_merged_count)
             if stage.rescue_stage and state.survivors_onboard:
                 state.survivors_rescued += state.survivors_onboard
                 state.survivors_onboard = 0

zombie_escape/gameplay/layout.py

@@ -70,17 +70,12 @@ def generate_level_from_blueprint(game_data: GameData, config: dict[str, Any]) -
         pitfall_zones=stage.pitfall_zones,
         base_seed=game_data.state.seed,
     )
-    if isinstance(blueprint_data, dict):
-        blueprint = blueprint_data.get("grid", [])
-        steel_cells_raw = blueprint_data.get("steel_cells", set())
-        car_reachable_cells = blueprint_data.get("car_reachable_cells", set())
-    else:
-        blueprint = blueprint_data
-        steel_cells_raw = set()
-        car_reachable_cells = set()
+    game_data.blueprint = blueprint_data
+    blueprint = blueprint_data.grid
+    steel_cells_raw = blueprint_data.steel_cells
+    car_reachable_cells = blueprint_data.car_reachable_cells
 
     steel_cells = {(int(x), int(y)) for x, y in steel_cells_raw} if steel_enabled else set()
-    game_data.layout.car_walkable_cells = car_reachable_cells
     cell_size = game_data.cell_size
     outer_wall_cells = {(x, y) for y, row in enumerate(blueprint) for x, ch in enumerate(row) if ch == "B"}
     wall_cells = {(x, y) for y, row in enumerate(blueprint) for x, ch in enumerate(row) if ch in {"B", "1"}}
@@ -95,7 +90,6 @@ def generate_level_from_blueprint(game_data: GameData, config: dict[str, Any]) -
     pitfall_cells: set[tuple[int, int]] = set()
     player_cells: list[tuple[int, int]] = []
     car_cells: list[tuple[int, int]] = []
-    zombie_cells: list[tuple[int, int]] = []
     fuel_cells: list[tuple[int, int]] = []
     flashlight_cells: list[tuple[int, int]] = []
     shoes_cells: list[tuple[int, int]] = []
@@ -230,8 +224,6 @@ def generate_level_from_blueprint(game_data: GameData, config: dict[str, Any]) -
                 player_cells.append((x, y))
             if ch == "C":
                 car_cells.append((x, y))
-            if ch == "Z":
-                zombie_cells.append((x, y))
             if ch == "f":
                 fuel_cells.append((x, y))
             if ch == "l":
@@ -252,14 +244,17 @@ def generate_level_from_blueprint(game_data: GameData, config: dict[str, Any]) -
     game_data.layout.field_rect = pygame.Rect(
         0,
         0,
-        game_data.level_width,
-        game_data.level_height,
+        stage.grid_cols * game_data.cell_size,
+        stage.grid_rows * game_data.cell_size,
     )
+    game_data.layout.grid_cols = stage.grid_cols
+    game_data.layout.grid_rows = stage.grid_rows
     game_data.layout.outside_cells = outside_cells
     game_data.layout.walkable_cells = walkable_cells
     game_data.layout.outer_wall_cells = outer_wall_cells
     game_data.layout.wall_cells = wall_cells
     game_data.layout.pitfall_cells = pitfall_cells
+    game_data.layout.car_walkable_cells = car_reachable_cells
     fall_spawn_cells = _expand_zone_cells(
         stage.fall_spawn_zones,
         grid_cols=stage.grid_cols,
@@ -284,7 +279,6 @@ def generate_level_from_blueprint(game_data: GameData, config: dict[str, Any]) -
     return {
         "player_cells": player_cells,
         "car_cells": car_cells,
-        "zombie_cells": zombie_cells,
         "fuel_cells": fuel_cells,
         "flashlight_cells": flashlight_cells,
         "shoes_cells": shoes_cells,

zombie_escape/gameplay/movement.py

@@ -16,6 +16,8 @@ from ..entities_constants import (
     HUMANOID_WALL_BUMP_FRAMES,
     PLAYER_SPEED,
     ZOMBIE_SEPARATION_DISTANCE,
+    ZOMBIE_TRACKER_CROWD_BAND_WIDTH,
+    ZOMBIE_TRACKER_GRID_CROWD_COUNT,
     ZOMBIE_WALL_HUG_SENSOR_DISTANCE,
 )
 from ..gameplay_constants import (
@@ -23,12 +25,15 @@ from ..gameplay_constants import (
     SHOES_SPEED_MULTIPLIER_TWO,
 )
 from ..models import FallingZombie, GameData
-from ..world_grid import WallIndex, apply_tile_edge_nudge, walls_for_radius
+from ..rng import get_rng
+from ..world_grid import WallIndex, apply_cell_edge_nudge, walls_for_radius
 from .constants import MAX_ZOMBIES
 from .spawn import spawn_weighted_zombie, update_falling_zombies
 from .survivors import update_survivors
 from .utils import rect_visible_on_screen
 
+RNG = get_rng()
+
 
 def process_player_input(
     keys: Sequence[bool],
@@ -126,10 +131,8 @@ def update_entities(
     camera = game_data.camera
     stage = game_data.stage
     active_car = car if car and car.alive() else None
-    wall_cells = game_data.layout.wall_cells
     pitfall_cells = game_data.layout.pitfall_cells
-    walkable_cells = game_data.layout.walkable_cells
-    bevel_corners = game_data.layout.bevel_corners
+    field_rect = game_data.layout.field_rect
 
     all_walls = list(wall_group) if wall_index is None else None
 
@@ -141,22 +144,19 @@ def update_entities(
             center,
             radius,
             cell_size=game_data.cell_size,
-            grid_cols=stage.grid_cols,
-            grid_rows=stage.grid_rows,
+            grid_cols=game_data.layout.grid_cols,
+            grid_rows=game_data.layout.grid_rows,
         )
 
     # Update player/car movement
     if player.in_car and active_car:
-        car_dx, car_dy = apply_tile_edge_nudge(
+        car_dx, car_dy = apply_cell_edge_nudge(
             active_car.x,
             active_car.y,
             car_dx,
             car_dy,
+            layout=game_data.layout,
             cell_size=game_data.cell_size,
-            wall_cells=wall_cells,
-            bevel_corners=bevel_corners,
-            grid_cols=stage.grid_cols,
-            grid_rows=stage.grid_rows,
         )
         car_walls = _walls_near((active_car.x, active_car.y), 150.0)
         active_car.move(
@@ -167,22 +167,26 @@ def update_entities(
             cell_size=game_data.cell_size,
             pitfall_cells=pitfall_cells,
         )
+        if field_rect is not None:
+            car_allow_rect = field_rect.inflate(active_car.rect.width, active_car.rect.height)
+            clamped_rect = active_car.rect.clamp(car_allow_rect)
+            if clamped_rect.topleft != active_car.rect.topleft:
+                active_car.rect = clamped_rect
+                active_car.x = float(active_car.rect.centerx)
+                active_car.y = float(active_car.rect.centery)
         player.rect.center = active_car.rect.center
         player.x, player.y = active_car.x, active_car.y
     elif not player.in_car:
         # Ensure player is in all_sprites if not in car
         if player not in all_sprites:
             all_sprites.add(player, layer=2)
-        player_dx, player_dy = apply_tile_edge_nudge(
+        player_dx, player_dy = apply_cell_edge_nudge(
             player.x,
             player.y,
             player_dx,
             player_dy,
+            layout=game_data.layout,
             cell_size=game_data.cell_size,
-            wall_cells=wall_cells,
-            bevel_corners=bevel_corners,
-            grid_cols=stage.grid_cols,
-            grid_rows=stage.grid_rows,
         )
         player.move(
             player_dx,
@@ -190,10 +194,7 @@ def update_entities(
             wall_group,
             wall_index=wall_index,
             cell_size=game_data.cell_size,
-            level_width=game_data.level_width,
-            level_height=game_data.level_height,
-            pitfall_cells=pitfall_cells,
-            walkable_cells=walkable_cells,
+            layout=game_data.layout,
         )
     else:
         # Player flagged as in-car but car is gone; drop them back to foot control
@@ -248,6 +249,28 @@ def update_entities(
 
     zombies_sorted: list[Zombie] = sorted(list(zombie_group), key=lambda z: z.x)
 
+    tracker_buckets: dict[tuple[int, int, int], list[Zombie]] = {}
+    tracker_cell_size = ZOMBIE_TRACKER_CROWD_BAND_WIDTH
+    angle_step = math.pi / 4.0
+    for zombie in zombies_sorted:
+        if not zombie.alive() or not zombie.tracker:
+            continue
+        zombie.tracker_force_wander = False
+        dx = zombie.last_move_dx
+        dy = zombie.last_move_dy
+        if abs(dx) <= 0.001 and abs(dy) <= 0.001:
+            continue
+        angle = math.atan2(dy, dx)
+        angle_bin = int(round(angle / angle_step)) % 8
+        cell_x = int(zombie.x // tracker_cell_size)
+        cell_y = int(zombie.y // tracker_cell_size)
+        tracker_buckets.setdefault((cell_x, cell_y, angle_bin), []).append(zombie)
+
+    for bucket in tracker_buckets.values():
+        if len(bucket) < ZOMBIE_TRACKER_GRID_CROWD_COUNT:
+            continue
+        RNG.choice(bucket).tracker_force_wander = True
+
     def _nearby_zombies(index: int) -> list[Zombie]:
         center = zombies_sorted[index]
         neighbors: list[Zombie] = []
@@ -303,14 +326,7 @@ def update_entities(
             nearby_candidates,
             footprints=game_data.state.footprints,
             cell_size=game_data.cell_size,
-            grid_cols=stage.grid_cols,
-            grid_rows=stage.grid_rows,
-            level_width=game_data.level_width,
-            level_height=game_data.level_height,
-            outer_wall_cells=game_data.layout.outer_wall_cells,
-            wall_cells=game_data.layout.wall_cells,
-            pitfall_cells=game_data.layout.pitfall_cells,
-            bevel_corners=game_data.layout.bevel_corners,
+            layout=game_data.layout,
         )
 
         # Check zombie pitfall
@@ -327,7 +343,7 @@ def update_entities(
             fall = FallingZombie(
                 start_pos=(int(zombie.x), int(zombie.y)),
                 target_pos=pitfall_target,
-                started_at_ms=pygame.time.get_ticks(),
+                started_at_ms=game_data.state.elapsed_play_ms,
                 pre_fx_ms=0,
                 fall_duration_ms=500,
                 dust_duration_ms=0,

zombie_escape/gameplay/spawn.py

@@ -17,7 +17,6 @@ from ..entities import (
 )
 from ..entities_constants import (
     FAST_ZOMBIE_BASE_SPEED,
-    FOV_RADIUS,
     PLAYER_SPEED,
     ZOMBIE_AGING_DURATION_FRAMES,
     ZOMBIE_SPEED,
@@ -26,13 +25,8 @@ from ..gameplay_constants import (
     DEFAULT_FLASHLIGHT_SPAWN_COUNT,
     DEFAULT_SHOES_SPAWN_COUNT,
 )
-from ..level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS, DEFAULT_TILE_SIZE
+from ..level_constants import DEFAULT_CELL_SIZE, DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS
 from ..models import DustRing, FallingZombie, GameData, Stage
-from ..render_constants import (
-    FLASHLIGHT_FOG_SCALE_ONE,
-    FLASHLIGHT_FOG_SCALE_TWO,
-    FOG_RADIUS_SCALE,
-)
 from ..rng import get_rng
 from .constants import (
     FALLING_ZOMBIE_DUST_DURATION_MS,
@@ -43,6 +37,7 @@ from .constants import (
     ZOMBIE_TRACKER_AGING_DURATION_FRAMES,
 )
 from .utils import (
+    fov_radius_for_flashlights,
     find_exterior_spawn_position,
     find_interior_spawn_positions,
     find_nearby_offscreen_spawn_position,
@@ -111,17 +106,6 @@ def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
     return False, True
 
 
-def _fov_radius_for_flashlights(flashlight_count: int) -> float:
-    count = max(0, int(flashlight_count))
-    if count <= 0:
-        scale = FOG_RADIUS_SCALE
-    elif count == 1:
-        scale = FLASHLIGHT_FOG_SCALE_ONE
-    else:
-        scale = FLASHLIGHT_FOG_SCALE_TWO
-    return FOV_RADIUS * scale
-
-
 def _is_spawn_position_clear(
     game_data: GameData,
     candidate: Zombie,
@@ -168,7 +152,7 @@ def _pick_fall_spawn_position(
     target_sprite = car if player.in_car and car and car.alive() else player
     target_center = target_sprite.rect.center
     cell_size = game_data.cell_size
-    fov_radius = _fov_radius_for_flashlights(game_data.state.flashlight_count)
+    fov_radius = fov_radius_for_flashlights(game_data.state.flashlight_count)
     min_dist_sq = min_distance * min_distance
     max_dist_sq = fov_radius * fov_radius
     wall_cells = game_data.layout.wall_cells
@@ -212,7 +196,7 @@ def _schedule_falling_zombie(
     zombie_group = game_data.groups.zombie_group
     if len(zombie_group) + len(state.falling_zombies) >= MAX_ZOMBIES:
         return "blocked"
-    min_distance = game_data.stage.tile_size * 0.5
+    min_distance = game_data.stage.cell_size * 0.5
     tracker, wall_hugging = _pick_zombie_variant(game_data.stage)
 
     def _candidate_clear(pos: tuple[int, int]) -> bool:
@@ -239,7 +223,7 @@ def _schedule_falling_zombie(
     fall = FallingZombie(
         start_pos=start_pos,
         target_pos=(int(spawn_pos[0]), int(spawn_pos[1])),
-        started_at_ms=pygame.time.get_ticks(),
+        started_at_ms=game_data.state.elapsed_play_ms,
         pre_fx_ms=FALLING_ZOMBIE_PRE_FX_MS,
         fall_duration_ms=FALLING_ZOMBIE_DURATION_MS,
         dust_duration_ms=FALLING_ZOMBIE_DUST_DURATION_MS,
@@ -290,15 +274,15 @@ def _create_zombie(
         )
         aging_duration_frames = max(1.0, aging_duration_frames * ratio)
     if start_pos is None:
-        tile_size = stage.tile_size if stage else DEFAULT_TILE_SIZE
+        cell_size = stage.cell_size if stage else DEFAULT_CELL_SIZE
         if stage is None:
             grid_cols = DEFAULT_GRID_COLS
             grid_rows = DEFAULT_GRID_ROWS
         else:
             grid_cols = stage.grid_cols
             grid_rows = stage.grid_rows
-        level_width = grid_cols * tile_size
-        level_height = grid_rows * tile_size
+        level_width = grid_cols * cell_size
+        level_height = grid_rows * cell_size
         if hint_pos is not None:
             points = [random_position_outside_building(level_width, level_height) for _ in range(5)]
             points.sort(key=lambda p: (p[0] - hint_pos[0]) ** 2 + (p[1] - hint_pos[1]) ** 2)
@@ -625,12 +609,13 @@ def setup_player_and_cars(
     all_sprites = game_data.groups.all_sprites
     walkable_cells: list[tuple[int, int]] = layout_data["walkable_cells"]
     cell_size = game_data.cell_size
+    level_rect = game_data.layout.field_rect
 
     def _pick_center(cells: list[tuple[int, int]]) -> tuple[int, int]:
         return (
             _cell_center(RNG.choice(cells), cell_size)
             if cells
-            else (game_data.level_width // 2, game_data.level_height // 2)
+            else level_rect.center
         )
 
     player_pos = _pick_center(layout_data["player_cells"] or walkable_cells)
@@ -677,10 +662,10 @@ def spawn_initial_zombies(
     zombie_group = game_data.groups.zombie_group
     all_sprites = game_data.groups.all_sprites
 
+    cell_size = game_data.cell_size
     spawn_cells = layout_data["walkable_cells"]
     if not spawn_cells:
         return
-    cell_size = game_data.cell_size
 
     if game_data.stage.id == "debug_tracker":
         player_pos = player.rect.center
@@ -860,9 +845,10 @@ def spawn_exterior_zombie(
         return None
     zombie_group = game_data.groups.zombie_group
     all_sprites = game_data.groups.all_sprites
+    level_rect = game_data.layout.field_rect
     spawn_pos = find_exterior_spawn_position(
-        game_data.level_width,
-        game_data.level_height,
+        level_rect.width,
+        level_rect.height,
         hint_pos=(player.x, player.y),
     )
     new_zombie = _create_zombie(
@@ -879,7 +865,7 @@ def update_falling_zombies(game_data: GameData, config: dict[str, Any]) -> None:
     state = game_data.state
     if not state.falling_zombies:
         return
-    now = pygame.time.get_ticks()
+    now = state.elapsed_play_ms
     zombie_group = game_data.groups.zombie_group
     all_sprites = game_data.groups.all_sprites
     for fall in list(state.falling_zombies):