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

zombie_escape/gameplay/layout.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pygame
+
+from ..colors import get_environment_palette
+from ..entities import SteelBeam, Wall
+from ..entities_constants import INTERNAL_WALL_HEALTH, STEEL_BEAM_HEALTH
+from .constants import OUTER_WALL_HEALTH
+from ..level_blueprints import choose_blueprint
+from ..models import GameData
+
+__all__ = ["generate_level_from_blueprint"]
+
+
+def _rect_for_cell(x_idx: int, y_idx: int, cell_size: int) -> pygame.Rect:
+    return pygame.Rect(
+        x_idx * cell_size,
+        y_idx * cell_size,
+        cell_size,
+        cell_size,
+    )
+
+
+def generate_level_from_blueprint(
+    game_data: GameData, config: dict[str, Any]
+) -> dict[str, list[pygame.Rect]]:
+    """Build walls/spawn candidates/outside area from a blueprint grid."""
+    wall_group = game_data.groups.wall_group
+    all_sprites = game_data.groups.all_sprites
+    stage = game_data.stage
+
+    steel_conf = config.get("steel_beams", {})
+    steel_enabled = steel_conf.get("enabled", False)
+
+    blueprint_data = choose_blueprint(
+        config,
+        cols=stage.grid_cols,
+        rows=stage.grid_rows,
+        wall_algo=stage.wall_algorithm,
+    )
+    if isinstance(blueprint_data, dict):
+        blueprint = blueprint_data.get("grid", [])
+        steel_cells_raw = blueprint_data.get("steel_cells", set())
+    else:
+        blueprint = blueprint_data
+        steel_cells_raw = set()
+
+    steel_cells = (
+        {(int(x), int(y)) for x, y in steel_cells_raw} if steel_enabled else set()
+    )
+    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"}
+    }
+
+    def _has_wall(nx: int, ny: int) -> bool:
+        if nx < 0 or ny < 0 or nx >= stage.grid_cols or ny >= stage.grid_rows:
+            return True
+        return (nx, ny) in wall_cells
+
+    outside_rects: list[pygame.Rect] = []
+    walkable_cells: list[pygame.Rect] = []
+    player_cells: list[pygame.Rect] = []
+    car_cells: list[pygame.Rect] = []
+    zombie_cells: list[pygame.Rect] = []
+    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):
+            return
+        wall_group.add(beam)
+        all_sprites.add(beam, layer=0)
+        beam._added_to_groups = True
+
+    for y, row in enumerate(blueprint):
+        if len(row) != stage.grid_cols:
+            raise ValueError(
+                "Blueprint width mismatch at row "
+                f"{y}: {len(row)} != {stage.grid_cols}"
+            )
+        for x, ch in enumerate(row):
+            cell_rect = _rect_for_cell(x, y, cell_size)
+            cell_has_beam = steel_enabled and (x, y) in steel_cells
+            if ch == "O":
+                outside_rects.append(cell_rect)
+                continue
+            if ch == "B":
+                draw_bottom_side = not _has_wall(x, y + 1)
+                wall = Wall(
+                    cell_rect.x,
+                    cell_rect.y,
+                    cell_rect.width,
+                    cell_rect.height,
+                    health=OUTER_WALL_HEALTH,
+                    palette=palette,
+                    palette_category="outer_wall",
+                    bevel_depth=0,
+                    draw_bottom_side=draw_bottom_side,
+                )
+                wall_group.add(wall)
+                all_sprites.add(wall, layer=0)
+                continue
+            if ch == "E":
+                if not cell_has_beam:
+                    walkable_cells.append(cell_rect)
+            elif ch == "1":
+                beam = None
+                if cell_has_beam:
+                    beam = SteelBeam(
+                        cell_rect.x,
+                        cell_rect.y,
+                        cell_rect.width,
+                        health=STEEL_BEAM_HEALTH,
+                        palette=palette,
+                    )
+                draw_bottom_side = not _has_wall(x, y + 1)
+                bevel_mask = (
+                    not _has_wall(x, y - 1)
+                    and not _has_wall(x - 1, y)
+                    and not _has_wall(x - 1, y - 1),
+                    not _has_wall(x, y - 1)
+                    and not _has_wall(x + 1, y)
+                    and not _has_wall(x + 1, y - 1),
+                    not _has_wall(x, y + 1)
+                    and not _has_wall(x + 1, y)
+                    and not _has_wall(x + 1, y + 1),
+                    not _has_wall(x, y + 1)
+                    and not _has_wall(x - 1, y)
+                    and not _has_wall(x - 1, y + 1),
+                )
+                wall = Wall(
+                    cell_rect.x,
+                    cell_rect.y,
+                    cell_rect.width,
+                    cell_rect.height,
+                    health=INTERNAL_WALL_HEALTH,
+                    palette=palette,
+                    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,
+                )
+                wall_group.add(wall)
+                all_sprites.add(wall, layer=0)
+            else:
+                if not cell_has_beam:
+                    walkable_cells.append(cell_rect)
+
+            if ch == "P":
+                player_cells.append(cell_rect)
+            if ch == "C":
+                car_cells.append(cell_rect)
+            if ch == "Z":
+                zombie_cells.append(cell_rect)
+
+            if cell_has_beam and ch != "1":
+                beam = SteelBeam(
+                    cell_rect.x,
+                    cell_rect.y,
+                    cell_rect.width,
+                    health=STEEL_BEAM_HEALTH,
+                    palette=palette,
+                )
+                add_beam_to_groups(beam)
+
+    game_data.layout.outer_rect = (0, 0, game_data.level_width, game_data.level_height)
+    game_data.layout.inner_rect = (0, 0, game_data.level_width, game_data.level_height)
+    game_data.layout.outside_rects = outside_rects
+    game_data.layout.walkable_cells = walkable_cells
+    game_data.layout.outer_wall_cells = outer_wall_cells
+
+    return {
+        "player_cells": player_cells,
+        "car_cells": car_cells,
+        "zombie_cells": zombie_cells,
+        "walkable_cells": walkable_cells,
+    }

zombie_escape/gameplay/movement.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import math
+from typing import Any, Sequence
+
+import pygame
+
+from ..entities import Car, Player, Survivor, Wall, WallIndex, Zombie, walls_for_radius
+from ..entities_constants import (
+    CAR_SPEED,
+    PLAYER_SPEED,
+    ZOMBIE_SEPARATION_DISTANCE,
+    ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
+)
+from ..models import GameData
+from .constants import MAX_ZOMBIES
+from .spawn import spawn_weighted_zombie
+from .survivors import update_survivors
+from .utils import rect_visible_on_screen
+
+
+def process_player_input(
+    keys: Sequence[bool], player: Player, car: Car | None
+) -> tuple[float, float, float, float]:
+    """Process keyboard input and return movement deltas."""
+    dx_input, dy_input = 0, 0
+    if keys[pygame.K_w] or keys[pygame.K_UP]:
+        dy_input -= 1
+    if keys[pygame.K_s] or keys[pygame.K_DOWN]:
+        dy_input += 1
+    if keys[pygame.K_a] or keys[pygame.K_LEFT]:
+        dx_input -= 1
+    if keys[pygame.K_d] or keys[pygame.K_RIGHT]:
+        dx_input += 1
+
+    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)
+        move_len = math.hypot(dx_input, dy_input)
+        if move_len > 0:
+            car_dx, car_dy = (
+                (dx_input / move_len) * target_speed,
+                (dy_input / move_len) * target_speed,
+            )
+    elif not player.in_car:
+        target_speed = PLAYER_SPEED
+        move_len = math.hypot(dx_input, dy_input)
+        if move_len > 0:
+            player_dx, player_dy = (
+                (dx_input / move_len) * target_speed,
+                (dy_input / move_len) * target_speed,
+            )
+
+    return player_dx, player_dy, car_dx, car_dy
+
+
+def update_entities(
+    game_data: GameData,
+    player_dx: float,
+    player_dy: float,
+    car_dx: float,
+    car_dy: float,
+    config: dict[str, Any],
+    wall_index: WallIndex | None = None,
+) -> None:
+    """Update positions and states of game entities."""
+    player = game_data.player
+    assert player is not None
+    car = game_data.car
+    wall_group = game_data.groups.wall_group
+    all_sprites = game_data.groups.all_sprites
+    zombie_group = game_data.groups.zombie_group
+    survivor_group = game_data.groups.survivor_group
+    camera = game_data.camera
+    stage = game_data.stage
+    active_car = car if car and car.alive() else None
+
+    all_walls = list(wall_group) if wall_index is None else None
+
+    def _walls_near(center: tuple[float, float], radius: float) -> list[Wall]:
+        if wall_index is None:
+            return all_walls or []
+        return walls_for_radius(
+            wall_index,
+            center,
+            radius,
+            cell_size=game_data.cell_size,
+            grid_cols=stage.grid_cols,
+            grid_rows=stage.grid_rows,
+        )
+
+    # Update player/car movement
+    if player.in_car and active_car:
+        car_walls = _walls_near((active_car.x, active_car.y), 150.0)
+        active_car.move(car_dx, car_dy, car_walls)
+        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.move(
+            player_dx,
+            player_dy,
+            wall_group,
+            wall_index=wall_index,
+            cell_size=game_data.cell_size,
+            level_width=game_data.level_width,
+            level_height=game_data.level_height,
+        )
+    else:
+        # Player flagged as in-car but car is gone; drop them back to foot control
+        player.in_car = False
+
+    # Update camera
+    target_for_camera = active_car if player.in_car and active_car else player
+    camera.update(target_for_camera)
+
+    update_survivors(game_data, wall_index=wall_index)
+
+    # 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
+    if (
+        len(zombie_group) < MAX_ZOMBIES
+        and not spawn_blocked
+        and current_time - game_data.state.last_zombie_spawn_time > spawn_interval
+    ):
+        if spawn_weighted_zombie(game_data, config):
+            game_data.state.last_zombie_spawn_time = current_time
+
+    # Update zombies
+    target_center = (
+        active_car.rect.center if player.in_car and active_car else player.rect.center
+    )
+    buddies = [
+        survivor
+        for survivor in survivor_group
+        if survivor.alive() and survivor.is_buddy and not survivor.rescued
+    ]
+    buddies_on_screen = [
+        buddy for buddy in buddies if rect_visible_on_screen(camera, buddy.rect)
+    ]
+
+    survivors_on_screen: list[Survivor] = []
+    if stage.rescue_stage:
+        for survivor in survivor_group:
+            if survivor.alive():
+                if rect_visible_on_screen(camera, survivor.rect):
+                    survivors_on_screen.append(survivor)
+
+    zombies_sorted: list[Zombie] = sorted(list(zombie_group), key=lambda z: z.x)
+
+    def _nearby_zombies(index: int) -> list[Zombie]:
+        center = zombies_sorted[index]
+        neighbors: list[Zombie] = []
+        search_radius = ZOMBIE_SEPARATION_DISTANCE + PLAYER_SPEED
+        for left in range(index - 1, -1, -1):
+            other = zombies_sorted[left]
+            if center.x - other.x > search_radius:
+                break
+            if other.alive():
+                neighbors.append(other)
+        for right in range(index + 1, len(zombies_sorted)):
+            other = zombies_sorted[right]
+            if other.x - center.x > search_radius:
+                break
+            if other.alive():
+                neighbors.append(other)
+        return neighbors
+
+    for idx, zombie in enumerate(zombies_sorted):
+        target = target_center
+        if buddies_on_screen:
+            dist_to_target_sq = (target_center[0] - zombie.x) ** 2 + (
+                target_center[1] - zombie.y
+            ) ** 2
+            nearest_buddy = min(
+                buddies_on_screen,
+                key=lambda buddy: (buddy.rect.centerx - zombie.x) ** 2
+                + (buddy.rect.centery - zombie.y) ** 2,
+            )
+            dist_to_buddy_sq = (nearest_buddy.rect.centerx - zombie.x) ** 2 + (
+                nearest_buddy.rect.centery - zombie.y
+            ) ** 2
+            if dist_to_buddy_sq < dist_to_target_sq:
+                target = nearest_buddy.rect.center
+
+        if stage.rescue_stage:
+            zombie_on_screen = rect_visible_on_screen(camera, zombie.rect)
+            if zombie_on_screen:
+                candidate_positions: list[tuple[int, int]] = []
+                for survivor in survivors_on_screen:
+                    candidate_positions.append(survivor.rect.center)
+                for buddy in buddies_on_screen:
+                    candidate_positions.append(buddy.rect.center)
+                candidate_positions.append(player.rect.center)
+                if candidate_positions:
+                    target = min(
+                        candidate_positions,
+                        key=lambda pos: (pos[0] - zombie.x) ** 2
+                        + (pos[1] - zombie.y) ** 2,
+                    )
+        nearby_candidates = _nearby_zombies(idx)
+        zombie_search_radius = ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE + zombie.radius + 120
+        nearby_walls = _walls_near((zombie.x, zombie.y), zombie_search_radius)
+        zombie.update(
+            target,
+            nearby_walls,
+            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,
+        )