zombie-escape 1.7.1__py3-none-any.whl → 1.10.0__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

@@ -8,11 +8,6 @@ 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
-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
@@ -20,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 ---
@@ -34,7 +29,6 @@ __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_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]]:
@@ -74,15 +94,20 @@ def generate_level_from_blueprint(
     player_cells: list[pygame.Rect] = []
     car_cells: list[pygame.Rect] = []
     zombie_cells: list[pygame.Rect] = []
+    bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] = {}
     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(
@@ -97,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,
@@ -107,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)
@@ -139,6 +166,9 @@ def generate_level_from_blueprint(
                     and not _has_wall(x - 1, y)
                     and not _has_wall(x - 1, y + 1),
                 )
+                if any(bevel_mask):
+                    bevel_corners[(x, y)] = bevel_mask
+                wall_cell = (x, y)
                 wall = Wall(
                     cell_rect.x,
                     cell_rect.y,
@@ -149,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)
@@ -181,6 +213,13 @@ def generate_level_from_blueprint(
     game_data.layout.outside_rects = outside_rects
     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 {
         "player_cells": player_cells,

zombie_escape/gameplay/movement.py

@@ -5,22 +5,31 @@ from typing import Any, Sequence
 
 import pygame
 
-from ..entities import Car, Player, Survivor, Wall, WallIndex, Zombie, walls_for_radius
+from ..entities import (
+    Car,
+    Player,
+    Survivor,
+    Wall,
+    Zombie,
+)
 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
 
 
 def process_player_input(
-    keys: Sequence[bool], player: Player, car: Car | None
+    keys: Sequence[bool],
+    player: Player,
+    car: Car | None,
+    pad_input: tuple[float, float] = (0.0, 0.0),
 ) -> tuple[float, float, float, float]:
     """Process keyboard input and return movement deltas."""
     dx_input, dy_input = 0, 0
@@ -32,11 +41,13 @@ def process_player_input(
         dx_input -= 1
     if keys[pygame.K_d] or keys[pygame.K_RIGHT]:
         dx_input += 1
+    dx_input += pad_input[0]
+    dy_input += pad_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)
+        target_speed = car.speed
         move_len = math.hypot(dx_input, dy_input)
         if move_len > 0:
             car_dx, car_dy = (
@@ -75,6 +86,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
+    bevel_corners = game_data.layout.bevel_corners
 
     all_walls = list(wall_group) if wall_index is None else None
 
@@ -92,14 +105,36 @@ def update_entities(
 
     # Update player/car movement
     if player.in_car and active_car:
+        car_dx, car_dy = apply_tile_edge_nudge(
+            active_car.x,
+            active_car.y,
+            car_dx,
+            car_dy,
+            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(car_dx, car_dy, car_walls)
+        active_car.move(car_dx, car_dy, car_walls, walls_nearby=wall_index is not None)
         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.x,
+            player.y,
+            player_dx,
+            player_dy,
+            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,
             player_dy,
@@ -118,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
@@ -217,4 +253,6 @@ def update_entities(
             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,
+            bevel_corners=game_data.layout.bevel_corners,
         )