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

zombie_escape/gameplay/state.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pygame
+
+from ..colors import DAWN_AMBIENT_PALETTE_KEY, ambient_palette_key_for_flashlights
+from ..entities_constants import SURVIVOR_MAX_SAFE_PASSENGERS
+from ..models import GameData, Groups, LevelLayout, ProgressState, Stage
+from ..entities import Camera
+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:
+        starts_with_fuel = False
+    starts_with_flashlight = False
+    initial_flashlights = 1 if starts_with_flashlight else 0
+    initial_palette_key = ambient_palette_key_for_flashlights(initial_flashlights)
+    game_state = ProgressState(
+        game_over=False,
+        game_won=False,
+        game_over_message=None,
+        game_over_at=None,
+        scaled_overview=None,
+        overview_created=False,
+        footprints=[],
+        last_footprint_pos=None,
+        elapsed_play_ms=0,
+        has_fuel=starts_with_fuel,
+        flashlight_count=initial_flashlights,
+        ambient_palette_key=initial_palette_key,
+        hint_expires_at=0,
+        hint_target_type=None,
+        fuel_message_until=0,
+        buddy_rescued=0,
+        buddy_onboard=0,
+        survivors_onboard=0,
+        survivors_rescued=0,
+        survivor_messages=[],
+        survivor_capacity=SURVIVOR_MAX_SAFE_PASSENGERS,
+        seed=None,
+        survival_elapsed_ms=0,
+        survival_goal_ms=max(0, stage.survival_goal_ms),
+        dawn_ready=False,
+        dawn_prompt_at=None,
+        time_accel_active=False,
+        last_zombie_spawn_time=0,
+        dawn_carbonized=False,
+        debug_mode=False,
+    )
+
+    # Create sprite groups
+    all_sprites = pygame.sprite.LayeredUpdates()
+    wall_group = pygame.sprite.Group()
+    zombie_group = pygame.sprite.Group()
+    survivor_group = pygame.sprite.Group()
+
+    # Create camera
+    cell_size = stage.tile_size
+    level_width = stage.grid_cols * cell_size
+    level_height = stage.grid_rows * cell_size
+    camera = Camera(level_width, level_height)
+
+    # Define level layout (will be filled by blueprint generation)
+    outer_rect = 0, 0, level_width, level_height
+    inner_rect = outer_rect
+
+    return GameData(
+        state=game_state,
+        groups=Groups(
+            all_sprites=all_sprites,
+            wall_group=wall_group,
+            zombie_group=zombie_group,
+            survivor_group=survivor_group,
+        ),
+        camera=camera,
+        layout=LevelLayout(
+            outer_rect=outer_rect,
+            inner_rect=inner_rect,
+            outside_rects=[],
+            walkable_cells=[],
+            outer_wall_cells=set(),
+        ),
+        fog={
+            "hatch_patterns": {},
+            "overlays": {},
+        },
+        stage=stage,
+        cell_size=cell_size,
+        level_width=level_width,
+        level_height=level_height,
+        fuel=None,
+        flashlights=[],
+    )
+
+
+def carbonize_outdoor_zombies(game_data: GameData) -> None:
+    """Petrify zombies that have already broken through to the exterior."""
+    outside_rects = game_data.layout.outside_rects or []
+    if not outside_rects:
+        return
+    group = game_data.groups.zombie_group
+    if not group:
+        return
+    for zombie in list(group):
+        alive = getattr(zombie, "alive", lambda: False)
+        if not 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()
+
+
+def update_survival_timer(game_data: GameData, dt_ms: int) -> None:
+    """Advance the survival countdown and trigger dawn handoff."""
+    stage = game_data.stage
+    state = game_data.state
+    if not stage.survival_stage:
+        return
+    if state.survival_goal_ms <= 0 or dt_ms <= 0:
+        return
+    state.survival_elapsed_ms = min(
+        state.survival_goal_ms,
+        state.survival_elapsed_ms + dt_ms,
+    )
+    if not state.dawn_ready and state.survival_elapsed_ms >= state.survival_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)
+    if state.dawn_ready:
+        carbonize_outdoor_zombies(game_data)
+        state.dawn_carbonized = True

zombie_escape/gameplay/survivors.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+from bisect import bisect_left
+from typing import Any
+
+import math
+
+import pygame
+
+from ..entities_constants import (
+    BUDDY_RADIUS,
+    CAR_SPEED,
+    PLAYER_RADIUS,
+    SURVIVOR_MAX_SAFE_PASSENGERS,
+    SURVIVOR_MIN_SPEED_FACTOR,
+    SURVIVOR_RADIUS,
+    ZOMBIE_RADIUS,
+)
+from .constants import (
+    SURVIVOR_CONVERSION_LINE_KEYS,
+    SURVIVOR_MESSAGE_DURATION_MS,
+    SURVIVOR_SPEED_PENALTY_PER_PASSENGER,
+)
+from ..localization import translate as tr
+from ..models import GameData, ProgressState
+from ..rng import get_rng
+from ..entities import Survivor, spritecollideany_walls, WallIndex
+from .spawn import _create_zombie
+from .utils import find_nearby_offscreen_spawn_position, rect_visible_on_screen
+
+RNG = get_rng()
+
+
+def update_survivors(
+    game_data: GameData, wall_index: WallIndex | None = None
+) -> None:
+    if not (game_data.stage.rescue_stage or game_data.stage.buddy_required_count > 0):
+        return
+    survivor_group = game_data.groups.survivor_group
+    wall_group = game_data.groups.wall_group
+    player = game_data.player
+    car = game_data.car
+    if not player:
+        return
+    target_rect = car.rect if player.in_car and car and car.alive() else player.rect
+    target_pos = target_rect.center
+    survivors = [s for s in survivor_group if s.alive()]
+    for survivor in survivors:
+        survivor.update_behavior(
+            target_pos,
+            wall_group,
+            wall_index=wall_index,
+            cell_size=game_data.cell_size,
+            level_width=game_data.level_width,
+            level_height=game_data.level_height,
+        )
+
+    # Gently prevent survivors from overlapping the player or each other
+    def _separate_from_point(
+        survivor: Survivor, point: tuple[float, float], min_dist: float
+    ) -> None:
+        dx = point[0] - survivor.x
+        dy = point[1] - survivor.y
+        dist = math.hypot(dx, dy)
+        if dist == 0:
+            angle = RNG.uniform(0, math.tau)
+            dx, dy = math.cos(angle), math.sin(angle)
+            dist = 1
+        if dist < min_dist:
+            push = min_dist - dist
+            survivor.x -= (dx / dist) * push
+            survivor.y -= (dy / dist) * push
+            survivor.rect.center = (int(survivor.x), int(survivor.y))
+
+    player_overlap = (SURVIVOR_RADIUS + PLAYER_RADIUS) * 1.05
+    survivor_overlap = (SURVIVOR_RADIUS * 2) * 1.05
+
+    player_point = (player.x, player.y)
+    for survivor in survivors:
+        _separate_from_point(survivor, player_point, player_overlap)
+
+    survivors_with_x = sorted(
+        ((survivor.x, survivor) for survivor in survivors), key=lambda item: item[0]
+    )
+    for i, (base_x, survivor) in enumerate(survivors_with_x):
+        for other_base_x, other in survivors_with_x[i + 1 :]:
+            if other_base_x - base_x > survivor_overlap:
+                break
+            dx = other.x - survivor.x
+            dy = other.y - survivor.y
+            dist = math.hypot(dx, dy)
+            if dist == 0:
+                angle = RNG.uniform(0, math.tau)
+                dx, dy = math.cos(angle), math.sin(angle)
+                dist = 1
+            if dist < survivor_overlap:
+                push = (survivor_overlap - dist) / 2
+                offset_x = (dx / dist) * push
+                offset_y = (dy / dist) * push
+                survivor.x -= offset_x
+                survivor.y -= offset_y
+                other.x += offset_x
+                other.y += offset_y
+                survivor.rect.center = (int(survivor.x), int(survivor.y))
+                other.rect.center = (int(other.x), int(other.y))
+
+
+def calculate_car_speed_for_passengers(
+    passengers: int, *, capacity: int = SURVIVOR_MAX_SAFE_PASSENGERS
+) -> float:
+    cap = max(1, capacity)
+    load_ratio = max(0.0, passengers / cap)
+    penalty = SURVIVOR_SPEED_PENALTY_PER_PASSENGER * load_ratio
+    penalty = min(0.95, max(0.0, penalty))
+    adjusted = CAR_SPEED * (1 - penalty)
+    if passengers <= cap:
+        return max(CAR_SPEED * SURVIVOR_MIN_SPEED_FACTOR, adjusted)
+
+    overload = passengers - cap
+    overload_factor = 1 / math.sqrt(overload + 1)
+    overloaded_speed = CAR_SPEED * overload_factor
+    return max(CAR_SPEED * SURVIVOR_MIN_SPEED_FACTOR, overloaded_speed)
+
+
+def apply_passenger_speed_penalty(game_data: GameData) -> None:
+    car = game_data.car
+    if not car:
+        return
+    if not game_data.stage.rescue_stage:
+        car.speed = CAR_SPEED
+        return
+    car.speed = calculate_car_speed_for_passengers(
+        game_data.state.survivors_onboard,
+        capacity=game_data.state.survivor_capacity,
+    )
+
+
+def increase_survivor_capacity(game_data: GameData, increments: int = 1) -> None:
+    if increments <= 0:
+        return
+    if not game_data.stage.rescue_stage:
+        return
+    state = game_data.state
+    state.survivor_capacity += increments * SURVIVOR_MAX_SAFE_PASSENGERS
+    apply_passenger_speed_penalty(game_data)
+
+
+def add_survivor_message(game_data: GameData, text: str) -> None:
+    expires = pygame.time.get_ticks() + SURVIVOR_MESSAGE_DURATION_MS
+    game_data.state.survivor_messages.append({"text": text, "expires_at": expires})
+
+
+def random_survivor_conversion_line() -> str:
+    if not SURVIVOR_CONVERSION_LINE_KEYS:
+        return ""
+    key = RNG.choice(SURVIVOR_CONVERSION_LINE_KEYS)
+    return tr(key)
+
+
+def cleanup_survivor_messages(state: ProgressState) -> None:
+    now = pygame.time.get_ticks()
+    state.survivor_messages = [
+        msg for msg in state.survivor_messages if msg.get("expires_at", 0) > now
+    ]
+
+
+def drop_survivors_from_car(game_data: GameData, origin: tuple[int, int]) -> None:
+    """Respawn boarded survivors back into the world after a crash."""
+    count = game_data.state.survivors_onboard
+    if count <= 0:
+        return
+    wall_group = game_data.groups.wall_group
+    survivor_group = game_data.groups.survivor_group
+    all_sprites = game_data.groups.all_sprites
+
+    for survivor_idx in range(count):
+        placed = False
+        for attempt in range(6):
+            angle = RNG.uniform(0, math.tau)
+            dist = RNG.uniform(16, 40)
+            pos = (
+                origin[0] + math.cos(angle) * dist,
+                origin[1] + math.sin(angle) * dist,
+            )
+            s = Survivor(*pos)
+            if not spritecollideany_walls(s, wall_group):
+                survivor_group.add(s)
+                all_sprites.add(s, layer=1)
+                placed = True
+                break
+        if not placed:
+            s = Survivor(*origin)
+            survivor_group.add(s)
+            all_sprites.add(s, layer=1)
+
+    game_data.state.survivors_onboard = 0
+    apply_passenger_speed_penalty(game_data)
+
+
+def handle_survivor_zombie_collisions(
+    game_data: GameData, config: dict[str, Any]
+) -> None:
+    if not game_data.stage.rescue_stage:
+        return
+    survivor_group = game_data.groups.survivor_group
+    if not survivor_group:
+        return
+    zombie_group = game_data.groups.zombie_group
+    zombies = [z for z in zombie_group if z.alive()]
+    if not zombies:
+        return
+    zombies.sort(key=lambda s: s.rect.centerx)
+    zombie_xs = [z.rect.centerx for z in zombies]
+    camera = game_data.camera
+    walkable_cells = game_data.layout.walkable_cells
+
+    for survivor in list(survivor_group):
+        if not survivor.alive():
+            continue
+        survivor_radius = survivor.radius
+        search_radius = survivor_radius + ZOMBIE_RADIUS
+        search_radius_sq = search_radius * search_radius
+
+        min_x = survivor.rect.centerx - search_radius
+        max_x = survivor.rect.centerx + search_radius
+        start_idx = bisect_left(zombie_xs, min_x)
+        collided = False
+        for idx in range(start_idx, len(zombies)):
+            zombie_x = zombie_xs[idx]
+            if zombie_x > max_x:
+                break
+            zombie = zombies[idx]
+            if not zombie.alive():
+                continue
+            dy = zombie.rect.centery - survivor.rect.centery
+            if abs(dy) > search_radius:
+                continue
+            dx = zombie_x - survivor.rect.centerx
+            if dx * dx + dy * dy <= search_radius_sq:
+                collided = True
+                break
+
+        if not collided:
+            continue
+        if not rect_visible_on_screen(camera, survivor.rect):
+            spawn_pos = find_nearby_offscreen_spawn_position(
+                walkable_cells,
+                camera=camera,
+            )
+            survivor.teleport(spawn_pos)
+            continue
+        survivor.kill()
+        line = random_survivor_conversion_line()
+        if line:
+            add_survivor_message(game_data, line)
+        new_zombie = _create_zombie(
+            config,
+            start_pos=survivor.rect.center,
+            stage=game_data.stage,
+        )
+        zombie_group.add(new_zombie)
+        game_data.groups.all_sprites.add(new_zombie, layer=1)
+        insert_idx = bisect_left(zombie_xs, new_zombie.rect.centerx)
+        zombie_xs.insert(insert_idx, new_zombie.rect.centerx)
+        zombies.insert(insert_idx, new_zombie)
+
+
+def respawn_buddies_near_player(game_data: GameData) -> None:
+    """Bring back onboard buddies near the player after losing the car."""
+    if game_data.stage.buddy_required_count <= 0:
+        return
+    count = game_data.state.buddy_onboard
+    if count <= 0:
+        return
+
+    player = game_data.player
+    assert player is not None
+    wall_group = game_data.groups.wall_group
+    camera = game_data.camera
+    walkable_cells = game_data.layout.walkable_cells
+    offsets = [
+        (BUDDY_RADIUS * 3, 0),
+        (-BUDDY_RADIUS * 3, 0),
+        (0, BUDDY_RADIUS * 3),
+        (0, -BUDDY_RADIUS * 3),
+        (0, 0),
+    ]
+    for _ in range(count):
+        if walkable_cells:
+            spawn_pos = find_nearby_offscreen_spawn_position(
+                walkable_cells,
+                camera=camera,
+            )
+        else:
+            spawn_pos = (int(player.x), int(player.y))
+        for dx, dy in offsets:
+            candidate = Survivor(player.x + dx, player.y + dy, is_buddy=True)
+            if not spritecollideany_walls(candidate, wall_group):
+                spawn_pos = (candidate.x, candidate.y)
+                break
+
+        buddy = Survivor(*spawn_pos, is_buddy=True)
+        buddy.following = True
+        game_data.groups.all_sprites.add(buddy, layer=2)
+        game_data.groups.survivor_group.add(buddy)
+    game_data.state.buddy_onboard = 0

zombie_escape/gameplay/utils.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import pygame
+
+from ..entities import Camera, Player, random_position_outside_building
+from ..rng import get_rng
+from ..screen_constants import SCREEN_HEIGHT, SCREEN_WIDTH
+
+LOGICAL_SCREEN_RECT = pygame.Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)
+RNG = get_rng()
+
+__all__ = [
+    "LOGICAL_SCREEN_RECT",
+    "rect_visible_on_screen",
+    "find_interior_spawn_positions",
+    "find_nearby_offscreen_spawn_position",
+    "find_exterior_spawn_position",
+]
+
+
+def rect_visible_on_screen(camera: Camera | None, rect: pygame.Rect) -> bool:
+    if camera is None:
+        return False
+    return camera.apply_rect(rect).colliderect(LOGICAL_SCREEN_RECT)
+
+
+def _scatter_positions_on_walkable(
+    walkable_cells: list[pygame.Rect],
+    spawn_rate: float,
+    *,
+    jitter_ratio: float = 0.35,
+) -> list[tuple[int, int]]:
+    positions: list[tuple[int, int]] = []
+    if not walkable_cells or spawn_rate <= 0:
+        return positions
+
+    clamped_rate = max(0.0, min(1.0, spawn_rate))
+    for cell in walkable_cells:
+        if RNG.random() >= clamped_rate:
+            continue
+        jitter_x = RNG.uniform(-cell.width * jitter_ratio, cell.width * jitter_ratio)
+        jitter_y = RNG.uniform(-cell.height * jitter_ratio, cell.height * jitter_ratio)
+        positions.append((int(cell.centerx + jitter_x), int(cell.centery + jitter_y)))
+    return positions
+
+
+def find_interior_spawn_positions(
+    walkable_cells: list[pygame.Rect],
+    spawn_rate: float,
+    *,
+    player: Player | None = None,
+    min_player_dist: float | None = None,
+) -> list[tuple[int, int]]:
+    positions = _scatter_positions_on_walkable(
+        walkable_cells,
+        spawn_rate,
+        jitter_ratio=0.35,
+    )
+    if not positions and spawn_rate > 0:
+        positions = _scatter_positions_on_walkable(
+            walkable_cells,
+            spawn_rate * 1.5,
+            jitter_ratio=0.35,
+        )
+    if not positions:
+        return []
+    if player is None or min_player_dist is None or min_player_dist <= 0:
+        return positions
+    min_player_dist_sq = min_player_dist * min_player_dist
+    filtered: list[tuple[int, int]] = []
+    for pos in positions:
+        dx = pos[0] - player.x
+        dy = pos[1] - player.y
+        if dx * dx + dy * dy < min_player_dist_sq:
+            continue
+        filtered.append(pos)
+    return filtered
+
+
+def find_nearby_offscreen_spawn_position(
+    walkable_cells: list[pygame.Rect],
+    *,
+    player: Player | None = None,
+    camera: Camera | None = None,
+    min_player_dist: float | None = None,
+    max_player_dist: float | None = None,
+    attempts: int = 18,
+) -> tuple[int, int]:
+    if not walkable_cells:
+        raise ValueError("walkable_cells must not be empty")
+    view_rect = None
+    if camera is not None:
+        view_rect = pygame.Rect(
+            -camera.camera.x,
+            -camera.camera.y,
+            SCREEN_WIDTH,
+            SCREEN_HEIGHT,
+        )
+        view_rect.inflate_ip(SCREEN_WIDTH, SCREEN_HEIGHT)
+    min_distance_sq = (
+        None if min_player_dist is None else min_player_dist * min_player_dist
+    )
+    max_distance_sq = (
+        None if max_player_dist is None else max_player_dist * max_player_dist
+    )
+    for _ in range(max(1, attempts)):
+        cell = RNG.choice(walkable_cells)
+        jitter_x = RNG.uniform(-cell.width * 0.35, cell.width * 0.35)
+        jitter_y = RNG.uniform(-cell.height * 0.35, cell.height * 0.35)
+        candidate = (int(cell.centerx + jitter_x), int(cell.centery + jitter_y))
+        if player is not None and (min_distance_sq is not None or max_distance_sq is not None):
+            dx = candidate[0] - player.x
+            dy = candidate[1] - player.y
+            dist_sq = dx * dx + dy * dy
+            if min_distance_sq is not None and dist_sq < min_distance_sq:
+                continue
+            if max_distance_sq is not None and dist_sq > max_distance_sq:
+                continue
+        if view_rect is not None and view_rect.collidepoint(candidate):
+            continue
+        return candidate
+    fallback_cell = RNG.choice(walkable_cells)
+    fallback_x = RNG.uniform(-fallback_cell.width * 0.35, fallback_cell.width * 0.35)
+    fallback_y = RNG.uniform(-fallback_cell.height * 0.35, fallback_cell.height * 0.35)
+    return (
+        int(fallback_cell.centerx + fallback_x),
+        int(fallback_cell.centery + fallback_y),
+    )
+
+
+def find_exterior_spawn_position(
+    level_width: int,
+    level_height: int,
+    *,
+    hint_pos: tuple[float, float] | None = None,
+    attempts: int = 5,
+) -> tuple[int, int]:
+    if hint_pos is None:
+        return random_position_outside_building(level_width, level_height)
+    points = [
+        random_position_outside_building(level_width, level_height)
+        for _ in range(max(1, attempts))
+    ]
+    return min(
+        points,
+        key=lambda pos: (pos[0] - hint_pos[0]) ** 2 + (pos[1] - hint_pos[1]) ** 2,
+    )