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

zombie_escape/entities_constants.py

@@ -34,6 +34,9 @@ ZOMBIE_SEPARATION_DISTANCE = ZOMBIE_RADIUS * 2.2
 ZOMBIE_AGING_DURATION_FRAMES = FPS * 60 * 6  # ~6 minutes at target framerate
 ZOMBIE_AGING_MIN_SPEED_RATIO = 0.3
 ZOMBIE_TRACKER_SCENT_RADIUS = 70
+ZOMBIE_TRACKER_SCAN_RADIUS_MULTIPLIER = 2
+ZOMBIE_TRACKER_SCENT_TOP_K = 3
+ZOMBIE_TRACKER_SCAN_INTERVAL_MS = int(1000 * 30 / FPS)
 ZOMBIE_TRACKER_WANDER_INTERVAL_MS = 2500
 ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE = 24
 ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG = 45
@@ -81,6 +84,9 @@ __all__ = [
     "ZOMBIE_AGING_DURATION_FRAMES",
     "ZOMBIE_AGING_MIN_SPEED_RATIO",
     "ZOMBIE_TRACKER_SCENT_RADIUS",
+    "ZOMBIE_TRACKER_SCAN_RADIUS_MULTIPLIER",
+    "ZOMBIE_TRACKER_SCENT_TOP_K",
+    "ZOMBIE_TRACKER_SCAN_INTERVAL_MS",
     "ZOMBIE_TRACKER_WANDER_INTERVAL_MS",
     "ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE",
     "ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG",

zombie_escape/gameplay/__init__.py

@@ -21,7 +21,7 @@ from .spawn import (
     spawn_waiting_car,
     spawn_weighted_zombie,
 )
-from .state import carbonize_outdoor_zombies, initialize_game_state, update_survival_timer
+from .state import carbonize_outdoor_zombies, initialize_game_state, update_endurance_timer
 from .survivors import (
     add_survivor_message,
     apply_passenger_speed_penalty,
@@ -71,7 +71,7 @@ __all__ = [
     "initialize_game_state",
     "setup_player_and_cars",
     "spawn_initial_zombies",
-    "update_survival_timer",
+    "update_endurance_timer",
     "carbonize_outdoor_zombies",
     "process_player_input",
     "update_entities",

zombie_escape/gameplay/constants.py

@@ -15,7 +15,7 @@ FOOTPRINT_MAX = 320
 
 # --- Zombie settings ---
 MAX_ZOMBIES = 400
-ZOMBIE_SPAWN_PLAYER_BUFFER = 140
+ZOMBIE_SPAWN_PLAYER_BUFFER = 230
 ZOMBIE_TRACKER_AGING_DURATION_FRAMES = ZOMBIE_AGING_DURATION_FRAMES
 
 # --- Car and fuel settings ---

zombie_escape/gameplay/footprints.py

@@ -5,7 +5,7 @@ from typing import Any
 import pygame
 
 from .constants import FOOTPRINT_MAX, FOOTPRINT_STEP_DISTANCE
-from ..models import GameData
+from ..models import Footprint, GameData
 
 
 def get_shrunk_sprite(
@@ -51,7 +51,7 @@ def update_footprints(game_data: GameData, config: dict[str, Any]) -> None:
             dist_sq is not None
             and dist_sq >= FOOTPRINT_STEP_DISTANCE * FOOTPRINT_STEP_DISTANCE
         ):
-            footprints.append({"pos": (player.x, player.y), "time": now})
+            footprints.append(Footprint(pos=(player.x, player.y), time=now))
             state.last_footprint_pos = (player.x, player.y)
 
     if len(footprints) > FOOTPRINT_MAX:

zombie_escape/gameplay/interactions.py

@@ -45,9 +45,7 @@ def _interaction_radius(width: float, height: float) -> float:
 RNG = get_rng()
 
 
-def check_interactions(
-    game_data: GameData, config: dict[str, Any]
-) -> pygame.sprite.Sprite | None:
+def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     """Check and handle interactions between entities."""
     player = game_data.player
     assert player is not None
@@ -193,7 +191,7 @@ def check_interactions(
             state.hint_target_type = None
             print("Player entered car!")
         else:
-            if not stage.survival_stage:
+            if not stage.endurance_stage:
                 now_ms = state.elapsed_play_ms
                 state.fuel_message_until = now_ms + FUEL_HINT_DURATION_MS
                 state.hint_target_type = "fuel"
@@ -221,7 +219,7 @@ def check_interactions(
                 maintain_waiting_car_supply(game_data)
                 print("Player claimed a waiting car!")
             else:
-                if not stage.survival_stage:
+                if not stage.endurance_stage:
                     now_ms = state.elapsed_play_ms
                     state.fuel_message_until = now_ms + FUEL_HINT_DURATION_MS
                     state.hint_target_type = "fuel"
@@ -321,7 +319,7 @@ def check_interactions(
 
     # Player escaping on foot after dawn (Stage 5)
     if (
-        stage.survival_stage
+        stage.endurance_stage
         and state.dawn_ready
         and not player.in_car
         and outside_rects
@@ -344,11 +342,7 @@ def check_interactions(
             if stage.rescue_stage and state.survivors_onboard:
                 state.survivors_rescued += state.survivors_onboard
                 state.survivors_onboard = 0
-                state.next_overload_check_ms = 0
                 apply_passenger_speed_penalty(game_data)
             state.game_won = True
 
-    # Return fog of view target
-    if not state.game_over and not state.game_won:
-        return car if player.in_car and car and car.alive() else player
     return None

zombie_escape/gameplay/layout.py

@@ -23,6 +23,26 @@ def _rect_for_cell(x_idx: int, y_idx: int, cell_size: int) -> pygame.Rect:
     )
 
 
+def _expand_zone_cells(
+    zones: list[tuple[int, int, int, int]],
+    *,
+    grid_cols: int,
+    grid_rows: int,
+) -> set[tuple[int, int]]:
+    cells: set[tuple[int, int]] = set()
+    for col, row, width, height in zones:
+        if width <= 0 or height <= 0:
+            continue
+        start_x = max(0, col)
+        start_y = max(0, row)
+        end_x = min(grid_cols, col + width)
+        end_y = min(grid_rows, row + height)
+        for y in range(start_y, end_y):
+            for x in range(start_x, end_x):
+                cells.add((x, y))
+    return cells
+
+
 def generate_level_from_blueprint(
     game_data: GameData, config: dict[str, Any]
 ) -> dict[str, list[pygame.Rect]]:
@@ -78,12 +98,16 @@ def generate_level_from_blueprint(
     palette = get_environment_palette(game_data.state.ambient_palette_key)
 
     def add_beam_to_groups(beam: SteelBeam) -> None:
-        if getattr(beam, "_added_to_groups", False):
+        if beam._added_to_groups:
             return
         wall_group.add(beam)
         all_sprites.add(beam, layer=0)
         beam._added_to_groups = True
 
+    def remove_wall_cell(cell: tuple[int, int]) -> None:
+        wall_cells.discard(cell)
+        outer_wall_cells.discard(cell)
+
     for y, row in enumerate(blueprint):
         if len(row) != stage.grid_cols:
             raise ValueError(
@@ -98,6 +122,7 @@ def generate_level_from_blueprint(
                 continue
             if ch == "B":
                 draw_bottom_side = not _has_wall(x, y + 1)
+                wall_cell = (x, y)
                 wall = Wall(
                     cell_rect.x,
                     cell_rect.y,
@@ -108,6 +133,7 @@ def generate_level_from_blueprint(
                     palette_category="outer_wall",
                     bevel_depth=0,
                     draw_bottom_side=draw_bottom_side,
+                    on_destroy=(lambda _w, cell=wall_cell: remove_wall_cell(cell)),
                 )
                 wall_group.add(wall)
                 all_sprites.add(wall, layer=0)
@@ -142,6 +168,7 @@ def generate_level_from_blueprint(
                 )
                 if any(bevel_mask):
                     bevel_corners[(x, y)] = bevel_mask
+                wall_cell = (x, y)
                 wall = Wall(
                     cell_rect.x,
                     cell_rect.y,
@@ -152,9 +179,11 @@ def generate_level_from_blueprint(
                     palette_category="inner_wall",
                     bevel_mask=bevel_mask,
                     draw_bottom_side=draw_bottom_side,
-                    on_destroy=(lambda _w, b=beam: add_beam_to_groups(b))
-                    if beam
-                    else None,
+                    on_destroy=(
+                        (lambda _w, b=beam, cell=wall_cell: (remove_wall_cell(cell), add_beam_to_groups(b)))
+                        if beam
+                        else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
+                    ),
                 )
                 wall_group.add(wall)
                 all_sprites.add(wall, layer=0)
@@ -185,6 +214,11 @@ def generate_level_from_blueprint(
     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.fall_spawn_cells = _expand_zone_cells(
+        stage.fall_spawn_zones,
+        grid_cols=stage.grid_cols,
+        grid_rows=stage.grid_rows,
+    )
     game_data.layout.bevel_corners = bevel_corners
 
     return {

zombie_escape/gameplay/movement.py

@@ -10,20 +10,17 @@ from ..entities import (
     Player,
     Survivor,
     Wall,
-    WallIndex,
     Zombie,
-    apply_tile_edge_nudge,
-    walls_for_radius,
 )
 from ..entities_constants import (
-    CAR_SPEED,
     PLAYER_SPEED,
     ZOMBIE_SEPARATION_DISTANCE,
     ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
 )
 from ..models import GameData
+from ..world_grid import WallIndex, apply_tile_edge_nudge, walls_for_radius
 from .constants import MAX_ZOMBIES
-from .spawn import spawn_weighted_zombie
+from .spawn import spawn_weighted_zombie, update_falling_zombies
 from .survivors import update_survivors
 from .utils import rect_visible_on_screen
 
@@ -50,7 +47,7 @@ def process_player_input(
     player_dx, player_dy, car_dx, car_dy = 0, 0, 0, 0
 
     if player.in_car and car and car.alive():
-        target_speed = getattr(car, "speed", CAR_SPEED)
+        target_speed = car.speed
         move_len = math.hypot(dx_input, dy_input)
         if move_len > 0:
             car_dx, car_dy = (
@@ -156,11 +153,12 @@ def update_entities(
     camera.update(target_for_camera)
 
     update_survivors(game_data, wall_index=wall_index)
+    update_falling_zombies(game_data, config)
 
     # Spawn new zombies if needed
     current_time = pygame.time.get_ticks()
     spawn_interval = max(1, stage.spawn_interval_ms)
-    spawn_blocked = stage.survival_stage and game_data.state.dawn_ready
+    spawn_blocked = stage.endurance_stage and game_data.state.dawn_ready
     if (
         len(zombie_group) < MAX_ZOMBIES
         and not spawn_blocked

zombie_escape/gameplay/spawn.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Mapping, Sequence
+from typing import Any, Callable, Literal, Mapping, Sequence
 
 import pygame
 
@@ -16,13 +16,15 @@ from ..entities import (
 )
 from ..entities_constants import (
     FAST_ZOMBIE_BASE_SPEED,
+    FOV_RADIUS,
     PLAYER_SPEED,
     ZOMBIE_AGING_DURATION_FRAMES,
     ZOMBIE_SPEED,
 )
 from ..gameplay_constants import DEFAULT_FLASHLIGHT_SPAWN_COUNT
 from ..level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS, DEFAULT_TILE_SIZE
-from ..models import GameData, Stage
+from ..models import DustRing, FallingZombie, GameData, Stage
+from ..render_constants import FLASHLIGHT_FOG_SCALE_STEP, FOG_RADIUS_SCALE
 from ..rng import get_rng
 from .constants import (
     MAX_ZOMBIES,
@@ -38,6 +40,8 @@ from .utils import (
 
 RNG = get_rng()
 
+FallScheduleResult = Literal["scheduled", "no_position", "blocked", "no_player"]
+
 __all__ = [
     "place_new_car",
     "place_fuel_can",
@@ -49,13 +53,14 @@ __all__ = [
     "spawn_waiting_car",
     "maintain_waiting_car_supply",
     "nearest_waiting_car",
+    "update_falling_zombies",
     "spawn_exterior_zombie",
     "spawn_weighted_zombie",
 ]
 
 
 def _car_appearance_for_stage(stage: Stage | None) -> str:
-    return "disabled" if stage and stage.survival_stage else "default"
+    return "disabled" if stage and stage.endurance_stage else "default"
 
 
 def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
@@ -87,6 +92,140 @@ 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))
+    scale = FOG_RADIUS_SCALE + max(0.0, FLASHLIGHT_FOG_SCALE_STEP) * count
+    return FOV_RADIUS * scale
+
+
+def _is_spawn_position_clear(
+    game_data: GameData,
+    candidate: Zombie,
+    *,
+    allow_player_overlap: bool = False,
+) -> bool:
+    wall_group = game_data.groups.wall_group
+    if spritecollideany_walls(candidate, wall_group):
+        return False
+
+    spawn_rect = candidate.rect
+    player = game_data.player
+    if not allow_player_overlap and player and spawn_rect.colliderect(player.rect):
+        return False
+    car = game_data.car
+    if car and car.alive() and spawn_rect.colliderect(car.rect):
+        return False
+    for parked in game_data.waiting_cars:
+        if parked.alive() and spawn_rect.colliderect(parked.rect):
+            return False
+    for survivor in game_data.groups.survivor_group:
+        if survivor.alive() and spawn_rect.colliderect(survivor.rect):
+            return False
+    for zombie in game_data.groups.zombie_group:
+        if zombie.alive() and spawn_rect.colliderect(zombie.rect):
+            return False
+    return True
+
+
+def _pick_fall_spawn_position(
+    game_data: GameData,
+    *,
+    min_distance: float,
+    attempts: int = 10,
+    is_clear: Callable[[tuple[int, int]], bool] | None = None,
+) -> tuple[int, int] | None:
+    player = game_data.player
+    if not player:
+        return None
+    fall_spawn_cells = game_data.layout.fall_spawn_cells
+    if not fall_spawn_cells:
+        return None
+    car = game_data.car
+    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)
+    min_dist_sq = min_distance * min_distance
+    max_dist_sq = fov_radius * fov_radius
+    wall_cells = game_data.layout.wall_cells
+
+    candidates: list[tuple[int, int]] = []
+    for cell_x, cell_y in fall_spawn_cells:
+        if (cell_x, cell_y) in wall_cells:
+            continue
+        pos = (
+            int(cell_x * cell_size + cell_size // 2),
+            int(cell_y * cell_size + cell_size // 2),
+        )
+        dx = pos[0] - target_center[0]
+        dy = pos[1] - target_center[1]
+        dist_sq = dx * dx + dy * dy
+        if dist_sq < min_dist_sq or dist_sq > max_dist_sq:
+            continue
+        candidates.append(pos)
+
+    if not candidates:
+        return None
+
+    RNG.shuffle(candidates)
+    for pos in candidates[: max(1, min(attempts, len(candidates)))]:
+        if is_clear is not None and not is_clear(pos):
+            continue
+        return pos
+    return None
+
+
+def _schedule_falling_zombie(
+    game_data: GameData,
+    config: dict[str, Any],
+    *,
+    allow_carry: bool = True,
+) -> FallScheduleResult:
+    player = game_data.player
+    if not player:
+        return "no_player"
+    state = game_data.state
+    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
+    tracker, wall_follower = _pick_zombie_variant(game_data.stage)
+
+    def _candidate_clear(pos: tuple[int, int]) -> bool:
+        candidate = _create_zombie(
+            config,
+            start_pos=pos,
+            stage=game_data.stage,
+            tracker=tracker,
+            wall_follower=wall_follower,
+        )
+        return _is_spawn_position_clear(game_data, candidate)
+
+    spawn_pos = _pick_fall_spawn_position(
+        game_data,
+        min_distance=min_distance,
+        is_clear=_candidate_clear,
+    )
+    if spawn_pos is None:
+        if allow_carry:
+            state.falling_spawn_carry += 1
+        return "no_position"
+    start_offset = game_data.stage.tile_size * 0.7
+    start_pos = (int(spawn_pos[0]), int(spawn_pos[1] - start_offset))
+    fall = FallingZombie(
+        start_pos=start_pos,
+        target_pos=(int(spawn_pos[0]), int(spawn_pos[1])),
+        started_at_ms=pygame.time.get_ticks(),
+        pre_fx_ms=350,
+        fall_duration_ms=450,
+        dust_duration_ms=220,
+        tracker=tracker,
+        wall_follower=wall_follower,
+    )
+    state.falling_zombies.append(fall)
+    return "scheduled"
+
+
 def _create_zombie(
     config: dict[str, Any],
     *,
@@ -435,6 +574,34 @@ def spawn_initial_zombies(
     if not spawn_cells:
         return
 
+    if game_data.stage.id == "debug_tracker":
+        player_pos = player.rect.center
+        min_dist_sq = 100 * 100
+        max_dist_sq = 240 * 240
+        candidates = [
+            cell
+            for cell in spawn_cells
+            if min_dist_sq
+            <= (cell.centerx - player_pos[0]) ** 2 + (cell.centery - player_pos[1]) ** 2
+            <= max_dist_sq
+        ]
+        if not candidates:
+            candidates = spawn_cells
+        candidate = RNG.choice(candidates)
+        tentative = _create_zombie(
+            config,
+            start_pos=candidate.center,
+            stage=game_data.stage,
+            tracker=True,
+            wall_follower=False,
+        )
+        if not spritecollideany_walls(tentative, wall_group):
+            zombie_group.add(tentative)
+            all_sprites.add(tentative, layer=1)
+        interval = max(1, game_data.stage.spawn_interval_ms)
+        game_data.state.last_zombie_spawn_time = pygame.time.get_ticks() - interval
+        return
+
     spawn_rate = max(0.0, game_data.stage.initial_interior_spawn_rate)
     positions = find_interior_spawn_positions(
         spawn_cells,
@@ -557,6 +724,7 @@ def _spawn_nearby_zombie(
         game_data.layout.walkable_cells,
         player=player,
         camera=camera,
+        min_player_dist=ZOMBIE_SPAWN_PLAYER_BUFFER,
         attempts=50,
     )
     new_zombie = _create_zombie(
@@ -596,6 +764,43 @@ def spawn_exterior_zombie(
     return new_zombie
 
 
+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()
+    zombie_group = game_data.groups.zombie_group
+    all_sprites = game_data.groups.all_sprites
+    for fall in list(state.falling_zombies):
+        fall_start = fall.started_at_ms + fall.pre_fx_ms
+        impact_at = fall_start + fall.fall_duration_ms
+        spawn_at = impact_at + fall.dust_duration_ms
+        if now >= impact_at and not fall.dust_started:
+            state.dust_rings.append(
+                DustRing(
+                    pos=fall.target_pos,
+                    started_at_ms=impact_at,
+                    duration_ms=fall.dust_duration_ms,
+                )
+            )
+            fall.dust_started = True
+        if now < spawn_at:
+            continue
+        if len(zombie_group) >= MAX_ZOMBIES:
+            state.falling_zombies.remove(fall)
+            continue
+        candidate = _create_zombie(
+            config,
+            start_pos=fall.target_pos,
+            stage=game_data.stage,
+            tracker=fall.tracker,
+            wall_follower=fall.wall_follower,
+        )
+        zombie_group.add(candidate)
+        all_sprites.add(candidate, layer=1)
+        state.falling_zombies.remove(fall)
+
+
 def spawn_weighted_zombie(
     game_data: GameData,
     config: dict[str, Any],
@@ -603,23 +808,51 @@ def spawn_weighted_zombie(
     """Spawn a zombie according to the stage's interior/exterior mix."""
     stage = game_data.stage
 
-    def _spawn(choice: str) -> bool:
-        if choice == "interior":
-            return _spawn_nearby_zombie(game_data, config) is not None
+    def _spawn_interior() -> bool:
+        return _spawn_nearby_zombie(game_data, config) is not None
+
+    def _spawn_exterior() -> bool:
         return spawn_exterior_zombie(game_data, config) is not None
 
+    def _spawn_fall() -> FallScheduleResult:
+        result = _schedule_falling_zombie(game_data, config)
+        if result != "scheduled":
+            return result
+        state = game_data.state
+        if state.falling_spawn_carry > 0:
+            extra = _schedule_falling_zombie(
+                game_data,
+                config,
+                allow_carry=False,
+            )
+            if extra == "scheduled":
+                state.falling_spawn_carry = max(0, state.falling_spawn_carry - 1)
+        return "scheduled"
+
     interior_weight = max(0.0, stage.interior_spawn_weight)
     exterior_weight = max(0.0, stage.exterior_spawn_weight)
-    total_weight = interior_weight + exterior_weight
+    fall_weight = max(0.0, getattr(stage, "interior_fall_spawn_weight", 0.0))
+    total_weight = interior_weight + exterior_weight + fall_weight
     if total_weight <= 0:
         # Fall back to exterior spawns if weights are unset or invalid.
-        return _spawn("exterior")
+        return _spawn_exterior()
 
     pick = RNG.uniform(0, total_weight)
     if pick <= interior_weight:
-        if _spawn("interior"):
+        if _spawn_interior():
+            return True
+        fall_result = _spawn_fall()
+        if fall_result == "scheduled":
             return True
-        return _spawn("exterior")
-    if _spawn("exterior"):
+        return False
+    if pick <= interior_weight + fall_weight:
+        fall_result = _spawn_fall()
+        if fall_result == "scheduled":
+            return True
+        return False
+    if _spawn_exterior():
+        return True
+    fall_result = _spawn_fall()
+    if fall_result == "scheduled":
         return True
-    return _spawn("interior")
+    return False

zombie_escape/gameplay/state.py

@@ -14,7 +14,7 @@ from .ambient import _set_ambient_palette
 def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
     """Initialize and return the base game state objects."""
     starts_with_fuel = not stage.requires_fuel
-    if stage.survival_stage:
+    if stage.endurance_stage:
         starts_with_fuel = False
     starts_with_flashlight = False
     initial_flashlights = 1 if starts_with_flashlight else 0
@@ -42,14 +42,17 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         survivor_messages=[],
         survivor_capacity=SURVIVOR_MAX_SAFE_PASSENGERS,
         seed=None,
-        survival_elapsed_ms=0,
-        survival_goal_ms=max(0, stage.survival_goal_ms),
+        endurance_elapsed_ms=0,
+        endurance_goal_ms=max(0, stage.endurance_goal_ms),
         dawn_ready=False,
         dawn_prompt_at=None,
         time_accel_active=False,
         last_zombie_spawn_time=0,
         dawn_carbonized=False,
         debug_mode=False,
+        falling_zombies=[],
+        falling_spawn_carry=0,
+        dust_rings=[],
     )
 
     # Create sprite groups
@@ -84,6 +87,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
             walkable_cells=[],
             outer_wall_cells=set(),
             wall_cells=set(),
+            fall_spawn_cells=set(),
             bevel_corners={},
         ),
         fog={
@@ -108,29 +112,26 @@ def carbonize_outdoor_zombies(game_data: GameData) -> None:
     if not group:
         return
     for zombie in list(group):
-        alive = getattr(zombie, "alive", lambda: False)
-        if not alive():
+        if not zombie.alive():
             continue
         center = zombie.rect.center
         if any(rect_obj.collidepoint(center) for rect_obj in outside_rects):
-            carbonize = getattr(zombie, "carbonize", None)
-            if carbonize:
-                carbonize()
+            zombie.carbonize()
 
 
-def update_survival_timer(game_data: GameData, dt_ms: int) -> None:
-    """Advance the survival countdown and trigger dawn handoff."""
+def update_endurance_timer(game_data: GameData, dt_ms: int) -> None:
+    """Advance the endurance countdown and trigger dawn handoff."""
     stage = game_data.stage
     state = game_data.state
-    if not stage.survival_stage:
+    if not stage.endurance_stage:
         return
-    if state.survival_goal_ms <= 0 or dt_ms <= 0:
+    if state.endurance_goal_ms <= 0 or dt_ms <= 0:
         return
-    state.survival_elapsed_ms = min(
-        state.survival_goal_ms,
-        state.survival_elapsed_ms + dt_ms,
+    state.endurance_elapsed_ms = min(
+        state.endurance_goal_ms,
+        state.endurance_elapsed_ms + dt_ms,
     )
-    if not state.dawn_ready and state.survival_elapsed_ms >= state.survival_goal_ms:
+    if not state.dawn_ready and state.endurance_elapsed_ms >= state.endurance_goal_ms:
         state.dawn_ready = True
         state.dawn_prompt_at = pygame.time.get_ticks()
         _set_ambient_palette(game_data, DAWN_AMBIENT_PALETTE_KEY, force=True)