zombie-escape 1.5.4__py3-none-any.whl → 1.7.1__py3-none-any.whl

zombie_escape/entities_constants.py

@@ -0,0 +1,102 @@
+"""Entity-related constants and helpers."""
+
+from __future__ import annotations
+
+from .screen_constants import FPS
+
+# --- Player and buddy settings ---
+HUMANOID_RADIUS = 6
+PLAYER_RADIUS = HUMANOID_RADIUS
+PLAYER_SPEED = 1.4
+FOV_RADIUS = 124  # approximate legacy FOV (80) * 1.55 cap
+BUDDY_RADIUS = HUMANOID_RADIUS
+BUDDY_FOLLOW_SPEED = PLAYER_SPEED * 0.7
+
+# --- Survivor settings (Stage 4) ---
+SURVIVOR_RADIUS = HUMANOID_RADIUS
+SURVIVOR_APPROACH_RADIUS = 48
+SURVIVOR_APPROACH_SPEED = PLAYER_SPEED * 0.35
+SURVIVOR_MAX_SAFE_PASSENGERS = 5
+SURVIVOR_MIN_SPEED_FACTOR = 0.35
+
+# --- Flashlight settings ---
+FLASHLIGHT_WIDTH = 10
+FLASHLIGHT_HEIGHT = 8
+
+# --- Zombie settings ---
+ZOMBIE_RADIUS = HUMANOID_RADIUS
+ZOMBIE_SPEED = PLAYER_SPEED * 0.45
+ZOMBIE_WANDER_INTERVAL_MS = 5000
+ZOMBIE_SIGHT_RANGE = FOV_RADIUS * 1.2
+ZOMBIE_TRACKER_SIGHT_RANGE = ZOMBIE_SIGHT_RANGE * 0.2
+FAST_ZOMBIE_BASE_SPEED = PLAYER_SPEED * 0.77
+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_WANDER_INTERVAL_MS = 2500
+ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE = 24
+ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG = 45
+ZOMBIE_WALL_FOLLOW_PROBE_STEP = 2.0
+ZOMBIE_WALL_FOLLOW_TARGET_GAP = 4.0
+ZOMBIE_WALL_FOLLOW_LOST_WALL_MS = 2500
+
+# --- Car and fuel settings ---
+CAR_WIDTH = 15
+CAR_HEIGHT = 25
+CAR_SPEED = 2
+CAR_HEALTH = 20
+CAR_WALL_DAMAGE = 1
+FUEL_CAN_WIDTH = 11
+FUEL_CAN_HEIGHT = 15
+
+# --- Wall and beam settings ---
+INTERNAL_WALL_HEALTH = 40 * 100
+INTERNAL_WALL_BEVEL_DEPTH = 6
+STEEL_BEAM_HEALTH = int(INTERNAL_WALL_HEALTH * 1.5)
+PLAYER_WALL_DAMAGE = 100
+ZOMBIE_WALL_DAMAGE = 1
+
+__all__ = [
+    "HUMANOID_RADIUS",
+    "PLAYER_RADIUS",
+    "PLAYER_SPEED",
+    "FOV_RADIUS",
+    "BUDDY_RADIUS",
+    "BUDDY_FOLLOW_SPEED",
+    "SURVIVOR_RADIUS",
+    "SURVIVOR_APPROACH_RADIUS",
+    "SURVIVOR_APPROACH_SPEED",
+    "SURVIVOR_MAX_SAFE_PASSENGERS",
+    "SURVIVOR_MIN_SPEED_FACTOR",
+    "FLASHLIGHT_WIDTH",
+    "FLASHLIGHT_HEIGHT",
+    "ZOMBIE_RADIUS",
+    "ZOMBIE_SPEED",
+    "ZOMBIE_WANDER_INTERVAL_MS",
+    "ZOMBIE_SIGHT_RANGE",
+    "ZOMBIE_TRACKER_SIGHT_RANGE",
+    "FAST_ZOMBIE_BASE_SPEED",
+    "ZOMBIE_SEPARATION_DISTANCE",
+    "ZOMBIE_AGING_DURATION_FRAMES",
+    "ZOMBIE_AGING_MIN_SPEED_RATIO",
+    "ZOMBIE_TRACKER_SCENT_RADIUS",
+    "ZOMBIE_TRACKER_WANDER_INTERVAL_MS",
+    "ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE",
+    "ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG",
+    "ZOMBIE_WALL_FOLLOW_PROBE_STEP",
+    "ZOMBIE_WALL_FOLLOW_TARGET_GAP",
+    "ZOMBIE_WALL_FOLLOW_LOST_WALL_MS",
+    "CAR_WIDTH",
+    "CAR_HEIGHT",
+    "CAR_SPEED",
+    "CAR_HEALTH",
+    "CAR_WALL_DAMAGE",
+    "FUEL_CAN_WIDTH",
+    "FUEL_CAN_HEIGHT",
+    "INTERNAL_WALL_HEALTH",
+    "INTERNAL_WALL_BEVEL_DEPTH",
+    "STEEL_BEAM_HEALTH",
+    "PLAYER_WALL_DAMAGE",
+    "ZOMBIE_WALL_DAMAGE",
+]

zombie_escape/gameplay/__init__.py

@@ -1,7 +1,80 @@
 """Gameplay helpers and logic utilities."""
 
-from . import logic
+# ruff: noqa: F401
+
+from .ambient import sync_ambient_palette_with_flashlights
+from .footprints import get_shrunk_sprite, update_footprints
+from .interactions import check_interactions
+from .layout import generate_level_from_blueprint
+from .movement import process_player_input, update_entities
+from .spawn import (
+    maintain_waiting_car_supply,
+    nearest_waiting_car,
+    place_buddies,
+    place_flashlights,
+    place_fuel_can,
+    place_new_car,
+    setup_player_and_cars,
+    spawn_exterior_zombie,
+    spawn_initial_zombies,
+    spawn_survivors,
+    spawn_waiting_car,
+    spawn_weighted_zombie,
+)
+from .state import carbonize_outdoor_zombies, initialize_game_state, update_survival_timer
+from .survivors import (
+    add_survivor_message,
+    apply_passenger_speed_penalty,
+    calculate_car_speed_for_passengers,
+    cleanup_survivor_messages,
+    drop_survivors_from_car,
+    handle_survivor_zombie_collisions,
+    increase_survivor_capacity,
+    random_survivor_conversion_line,
+    respawn_buddies_near_player,
+    update_survivors,
+)
+from .utils import (
+    find_exterior_spawn_position,
+    find_interior_spawn_positions,
+    find_nearby_offscreen_spawn_position,
+    rect_visible_on_screen,
+)
 
 __all__ = [
-    "logic",
+    "generate_level_from_blueprint",
+    "place_new_car",
+    "place_fuel_can",
+    "place_flashlights",
+    "place_buddies",
+    "find_interior_spawn_positions",
+    "find_nearby_offscreen_spawn_position",
+    "find_exterior_spawn_position",
+    "spawn_survivors",
+    "spawn_exterior_zombie",
+    "spawn_weighted_zombie",
+    "update_survivors",
+    "nearest_waiting_car",
+    "calculate_car_speed_for_passengers",
+    "apply_passenger_speed_penalty",
+    "increase_survivor_capacity",
+    "spawn_waiting_car",
+    "maintain_waiting_car_supply",
+    "add_survivor_message",
+    "random_survivor_conversion_line",
+    "cleanup_survivor_messages",
+    "drop_survivors_from_car",
+    "handle_survivor_zombie_collisions",
+    "respawn_buddies_near_player",
+    "get_shrunk_sprite",
+    "update_footprints",
+    "initialize_game_state",
+    "setup_player_and_cars",
+    "spawn_initial_zombies",
+    "update_survival_timer",
+    "carbonize_outdoor_zombies",
+    "process_player_input",
+    "update_entities",
+    "check_interactions",
+    "sync_ambient_palette_with_flashlights",
 ]

zombie_escape/gameplay/ambient.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from ..colors import (
+    DAWN_AMBIENT_PALETTE_KEY,
+    ambient_palette_key_for_flashlights,
+    get_environment_palette,
+)
+from ..models import GameData
+
+
+def _set_ambient_palette(
+    game_data: GameData, key: str, *, force: bool = False
+) -> None:
+    """Apply a named ambient palette to all walls in the level."""
+
+    palette = get_environment_palette(key)
+    state = game_data.state
+    if not force and state.ambient_palette_key == key:
+        return
+
+    state.ambient_palette_key = key
+    _apply_palette_to_walls(game_data, palette, force=True)
+
+
+def sync_ambient_palette_with_flashlights(
+    game_data: GameData, *, force: bool = False
+) -> None:
+    """Sync the ambient palette with the player's flashlight inventory."""
+
+    state = game_data.state
+    if state.dawn_ready:
+        _set_ambient_palette(game_data, DAWN_AMBIENT_PALETTE_KEY, force=force)
+        return
+    key = ambient_palette_key_for_flashlights(state.flashlight_count)
+    _set_ambient_palette(game_data, key, force=force)
+
+
+def _apply_palette_to_walls(
+    game_data: GameData,
+    palette,
+    *,
+    force: bool = False,
+) -> None:
+    if not hasattr(game_data, "groups") or not hasattr(game_data.groups, "wall_group"):
+        return
+    wall_group = game_data.groups.wall_group
+    for wall in wall_group:
+        if not hasattr(wall, "set_palette"):
+            continue
+        wall.set_palette(palette, force=force)

zombie_escape/gameplay/constants.py

@@ -0,0 +1,46 @@
+"""Gameplay-only constants."""
+
+from __future__ import annotations
+
+from ..entities_constants import ZOMBIE_AGING_DURATION_FRAMES
+
+# --- Survivor settings ---
+SURVIVOR_SPEED_PENALTY_PER_PASSENGER = 0.08
+SURVIVOR_OVERLOAD_DAMAGE_RATIO = 0.2
+SURVIVOR_MESSAGE_DURATION_MS = 2000
+SURVIVOR_CONVERSION_LINE_KEYS = [
+    "stages.stage4.conversion_lines.line1",
+    "stages.stage4.conversion_lines.line2",
+    "stages.stage4.conversion_lines.line3",
+]
+
+# --- Footprint settings (gameplay) ---
+FOOTPRINT_STEP_DISTANCE = 40
+FOOTPRINT_MAX = 320
+
+# --- Zombie settings ---
+MAX_ZOMBIES = 400
+ZOMBIE_SPAWN_PLAYER_BUFFER = 140
+ZOMBIE_TRACKER_AGING_DURATION_FRAMES = ZOMBIE_AGING_DURATION_FRAMES
+
+# --- Car and fuel settings ---
+CAR_ZOMBIE_DAMAGE = 1
+FUEL_HINT_DURATION_MS = 1600
+
+# --- Wall settings ---
+OUTER_WALL_HEALTH = 999999
+
+__all__ = [
+    "SURVIVOR_SPEED_PENALTY_PER_PASSENGER",
+    "SURVIVOR_OVERLOAD_DAMAGE_RATIO",
+    "SURVIVOR_MESSAGE_DURATION_MS",
+    "SURVIVOR_CONVERSION_LINE_KEYS",
+    "FOOTPRINT_STEP_DISTANCE",
+    "FOOTPRINT_MAX",
+    "MAX_ZOMBIES",
+    "ZOMBIE_SPAWN_PLAYER_BUFFER",
+    "ZOMBIE_TRACKER_AGING_DURATION_FRAMES",
+    "CAR_ZOMBIE_DAMAGE",
+    "FUEL_HINT_DURATION_MS",
+    "OUTER_WALL_HEALTH",
+]

zombie_escape/gameplay/footprints.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pygame
+
+from .constants import FOOTPRINT_MAX, FOOTPRINT_STEP_DISTANCE
+from ..models import GameData
+
+
+def get_shrunk_sprite(
+    sprite_obj: pygame.sprite.Sprite, scale_x: float, *, scale_y: float | None = None
+) -> pygame.sprite.Sprite:
+    if scale_y is None:
+        scale_y = scale_x
+
+    original_rect = sprite_obj.rect
+    shrunk_width = int(original_rect.width * scale_x)
+    shrunk_height = int(original_rect.height * scale_y)
+
+    shrunk_width = max(1, shrunk_width)
+    shrunk_height = max(1, shrunk_height)
+
+    rect = pygame.Rect(0, 0, shrunk_width, shrunk_height)
+    rect.center = original_rect.center
+
+    new_sprite = pygame.sprite.Sprite()
+    new_sprite.rect = rect
+
+    return new_sprite
+
+
+def update_footprints(game_data: GameData, config: dict[str, Any]) -> None:
+    """Record player steps and clean up old footprints."""
+    _ = config  # Footprints are always tracked; config only affects rendering.
+    state = game_data.state
+    player = game_data.player
+    assert player is not None
+
+    now = pygame.time.get_ticks()
+
+    footprints = state.footprints
+    if not player.in_car:
+        last_pos = state.last_footprint_pos
+        dist_sq = (
+            (player.x - last_pos[0]) ** 2 + (player.y - last_pos[1]) ** 2
+            if last_pos
+            else None
+        )
+        if last_pos is None or (
+            dist_sq is not None
+            and dist_sq >= FOOTPRINT_STEP_DISTANCE * FOOTPRINT_STEP_DISTANCE
+        ):
+            footprints.append({"pos": (player.x, player.y), "time": now})
+            state.last_footprint_pos = (player.x, player.y)
+
+    if len(footprints) > FOOTPRINT_MAX:
+        footprints = footprints[-FOOTPRINT_MAX:]
+
+    state.footprints = footprints

zombie_escape/gameplay/interactions.py

@@ -0,0 +1,354 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pygame
+
+from ..entities_constants import (
+    CAR_HEIGHT,
+    CAR_WIDTH,
+    FLASHLIGHT_HEIGHT,
+    FLASHLIGHT_WIDTH,
+    FUEL_CAN_HEIGHT,
+    FUEL_CAN_WIDTH,
+    HUMANOID_RADIUS,
+    SURVIVOR_APPROACH_RADIUS,
+    SURVIVOR_MAX_SAFE_PASSENGERS,
+)
+from .constants import (
+    CAR_ZOMBIE_DAMAGE,
+    FUEL_HINT_DURATION_MS,
+    SURVIVOR_OVERLOAD_DAMAGE_RATIO,
+)
+from ..localization import translate as tr
+from ..models import GameData
+from ..rng import get_rng
+from ..entities import Car
+from .footprints import get_shrunk_sprite
+from .spawn import maintain_waiting_car_supply
+from .survivors import (
+    add_survivor_message,
+    apply_passenger_speed_penalty,
+    drop_survivors_from_car,
+    handle_survivor_zombie_collisions,
+    increase_survivor_capacity,
+    respawn_buddies_near_player,
+)
+from .utils import rect_visible_on_screen
+from .ambient import sync_ambient_palette_with_flashlights
+
+
+def _interaction_radius(width: float, height: float) -> float:
+    """Approximate interaction reach for a humanoid and an object."""
+    return HUMANOID_RADIUS + (width + height) / 4
+
+RNG = get_rng()
+
+
+def check_interactions(
+    game_data: GameData, config: dict[str, Any]
+) -> pygame.sprite.Sprite | None:
+    """Check and handle interactions between entities."""
+    player = game_data.player
+    assert player is not None
+    car = game_data.car
+    zombie_group = game_data.groups.zombie_group
+    all_sprites = game_data.groups.all_sprites
+    survivor_group = game_data.groups.survivor_group
+    state = game_data.state
+    walkable_cells = game_data.layout.walkable_cells
+    outside_rects = game_data.layout.outside_rects
+    fuel = game_data.fuel
+    flashlights = game_data.flashlights or []
+    camera = game_data.camera
+    stage = game_data.stage
+    maintain_waiting_car_supply(game_data)
+    active_car = car if car and car.alive() else None
+    waiting_cars = game_data.waiting_cars
+    shrunk_car = get_shrunk_sprite(active_car, 0.8) if active_car else None
+
+    car_interaction_radius = _interaction_radius(CAR_WIDTH, CAR_HEIGHT)
+    fuel_interaction_radius = _interaction_radius(FUEL_CAN_WIDTH, FUEL_CAN_HEIGHT)
+    flashlight_interaction_radius = _interaction_radius(
+        FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT
+    )
+
+    def _player_near_point(point: tuple[float, float], radius: float) -> bool:
+        dx = point[0] - player.x
+        dy = point[1] - player.y
+        return dx * dx + dy * dy <= radius * radius
+
+    def _player_near_sprite(
+        sprite_obj: pygame.sprite.Sprite | None, radius: float
+    ) -> bool:
+        return bool(
+            sprite_obj
+            and sprite_obj.alive()
+            and _player_near_point(sprite_obj.rect.center, radius)
+        )
+
+    def _player_near_car(car_obj: Car | None) -> bool:
+        return _player_near_sprite(car_obj, car_interaction_radius)
+
+    # Fuel pickup
+    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
+            state.hint_expires_at = 0
+            state.hint_target_type = None
+            fuel.kill()
+            game_data.fuel = None
+            print("Fuel acquired!")
+
+    # Flashlight pickup
+    if not player.in_car:
+        for flashlight in list(flashlights):
+            if not flashlight.alive():
+                continue
+            if _player_near_point(
+                flashlight.rect.center, flashlight_interaction_radius
+            ):
+                state.flashlight_count += 1
+                state.hint_expires_at = 0
+                state.hint_target_type = None
+                flashlight.kill()
+                try:
+                    flashlights.remove(flashlight)
+                except ValueError:
+                    pass
+                print("Flashlight acquired!")
+                break
+
+    sync_ambient_palette_with_flashlights(game_data)
+
+    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):
+            if not buddy.alive():
+                continue
+            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
+                ):
+                    buddy.set_following()
+            elif player.in_car and active_car and shrunk_car:
+                g = pygame.sprite.Group()
+                g.add(buddy)
+                if pygame.sprite.spritecollide(
+                    shrunk_car, g, False, pygame.sprite.collide_circle
+                ):
+                    prospective_passengers = state.survivors_onboard + 1
+                    capacity_limit = state.survivor_capacity
+                    if prospective_passengers > capacity_limit:
+                        overload_damage = max(
+                            1,
+                            int(active_car.max_health * SURVIVOR_OVERLOAD_DAMAGE_RATIO),
+                        )
+                        add_survivor_message(game_data, tr("survivors.too_many_aboard"))
+                        active_car._take_damage(overload_damage)
+                    state.buddy_onboard += 1
+                    buddy.kill()
+                    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")
+                    state.game_over = True
+                    state.game_over_at = state.game_over_at or pygame.time.get_ticks()
+                else:
+                    if walkable_cells:
+                        new_cell = RNG.choice(walkable_cells)
+                        buddy.teleport(new_cell.center)
+                    else:
+                        buddy.teleport(
+                            (game_data.level_width // 2, game_data.level_height // 2)
+                        )
+                    buddy.following = False
+
+    # 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:
+            player.in_car = True
+            all_sprites.remove(player)
+            state.hint_expires_at = 0
+            state.hint_target_type = None
+            print("Player entered car!")
+        else:
+            if not stage.survival_stage:
+                now_ms = state.elapsed_play_ms
+                state.fuel_message_until = now_ms + FUEL_HINT_DURATION_MS
+                state.hint_target_type = "fuel"
+
+    # Claim a waiting/parked car when the player finally reaches it
+    if not player.in_car and not active_car and waiting_cars:
+        claimed_car: Car | None = None
+        for parked_car in waiting_cars:
+            if _player_near_car(parked_car):
+                claimed_car = parked_car
+                break
+        if claimed_car:
+            if state.has_fuel:
+                try:
+                    game_data.waiting_cars.remove(claimed_car)
+                except ValueError:
+                    pass
+                game_data.car = claimed_car
+                active_car = claimed_car
+                player.in_car = True
+                all_sprites.remove(player)
+                state.hint_expires_at = 0
+                state.hint_target_type = None
+                apply_passenger_speed_penalty(game_data)
+                maintain_waiting_car_supply(game_data)
+                print("Player claimed a waiting car!")
+            else:
+                if not stage.survival_stage:
+                    now_ms = state.elapsed_play_ms
+                    state.fuel_message_until = now_ms + FUEL_HINT_DURATION_MS
+                    state.hint_target_type = "fuel"
+
+    # Bonus: collide a parked car while driving to repair/extend capabilities
+    if player.in_car and active_car and shrunk_car and waiting_cars:
+        waiting_group = pygame.sprite.Group(waiting_cars)
+        collided_waiters = pygame.sprite.spritecollide(
+            shrunk_car, waiting_group, False, pygame.sprite.collide_rect
+        )
+        if collided_waiters:
+            removed_any = False
+            capacity_increments = 0
+            for parked in collided_waiters:
+                if not parked.alive():
+                    continue
+                parked.kill()
+                try:
+                    game_data.waiting_cars.remove(parked)
+                except ValueError:
+                    pass
+                active_car.health = active_car.max_health
+                active_car._update_color()
+                removed_any = True
+                if stage.rescue_stage:
+                    capacity_increments += 1
+            if removed_any:
+                if capacity_increments:
+                    increase_survivor_capacity(game_data, capacity_increments)
+                maintain_waiting_car_supply(game_data)
+
+    # Car hitting zombies
+    if player.in_car and active_car and active_car.health > 0 and shrunk_car:
+        zombies_hit = pygame.sprite.spritecollide(shrunk_car, zombie_group, True)
+        if zombies_hit:
+            active_car._take_damage(CAR_ZOMBIE_DAMAGE * len(zombies_hit))
+
+    if (
+        stage.rescue_stage
+        and player.in_car
+        and active_car
+        and shrunk_car
+        and survivor_group
+    ):
+        boarded = pygame.sprite.spritecollide(
+            shrunk_car, survivor_group, True, pygame.sprite.collide_circle
+        )
+        if boarded:
+            state.survivors_onboard += len(boarded)
+            apply_passenger_speed_penalty(game_data)
+            capacity_limit = state.survivor_capacity
+            if state.survivors_onboard > capacity_limit:
+                overload_damage = max(
+                    1,
+                    int(active_car.max_health * SURVIVOR_OVERLOAD_DAMAGE_RATIO),
+                )
+                add_survivor_message(game_data, tr("survivors.too_many_aboard"))
+                active_car._take_damage(overload_damage)
+
+    if stage.rescue_stage:
+        handle_survivor_zombie_collisions(game_data, config)
+
+    # Handle car destruction
+    if car and car.alive() and car.health <= 0:
+        car_destroyed_pos = car.rect.center
+        car.kill()
+        if stage.rescue_stage:
+            drop_survivors_from_car(game_data, car_destroyed_pos)
+        if player.in_car:
+            player.in_car = False
+            player.x, player.y = car_destroyed_pos[0], car_destroyed_pos[1]
+            player.rect.center = (int(player.x), int(player.y))
+            if player not in all_sprites:
+                all_sprites.add(player, layer=2)
+            print("Car destroyed! Player ejected.")
+
+        # Clear active car and let the player hunt for another waiting car.
+        game_data.car = None
+        state.survivor_capacity = SURVIVOR_MAX_SAFE_PASSENGERS
+        apply_passenger_speed_penalty(game_data)
+
+        # Bring back the buddies near the player after losing the car
+        respawn_buddies_near_player(game_data)
+        maintain_waiting_car_supply(game_data)
+
+    # Player getting caught by zombies
+    if not player.in_car and player in all_sprites:
+        shrunk_player = get_shrunk_sprite(player, 0.8)
+        collisions = pygame.sprite.spritecollide(
+            shrunk_player, zombie_group, False, pygame.sprite.collide_circle
+        )
+        if any(not zombie.carbonized for zombie in collisions):
+            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")
+
+    # Player escaping on foot after dawn (Stage 5)
+    if (
+        stage.survival_stage
+        and state.dawn_ready
+        and not player.in_car
+        and outside_rects
+        and any(outside.collidepoint(player.rect.center) for outside in outside_rects)
+    ):
+        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
+        if buddy_ready and any(
+            outside.collidepoint(car.rect.center) for outside in outside_rects
+        ):
+            if stage.buddy_required_count > 0:
+                state.buddy_rescued = min(
+                    stage.buddy_required_count, state.buddy_onboard
+                )
+            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