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

zombie_escape/gameplay/spawn.py

@@ -9,6 +9,7 @@ from ..entities import (
     Flashlight,
     FuelCan,
     Player,
+    Shoes,
     Survivor,
     Zombie,
     random_position_outside_building,
@@ -21,10 +22,17 @@ from ..entities_constants import (
     ZOMBIE_AGING_DURATION_FRAMES,
     ZOMBIE_SPEED,
 )
-from ..gameplay_constants import DEFAULT_FLASHLIGHT_SPAWN_COUNT
+from ..gameplay_constants import (
+    DEFAULT_FLASHLIGHT_SPAWN_COUNT,
+    DEFAULT_SHOES_SPAWN_COUNT,
+)
 from ..level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS, DEFAULT_TILE_SIZE
 from ..models import DustRing, FallingZombie, GameData, Stage
-from ..render_constants import FLASHLIGHT_FOG_SCALE_STEP, FOG_RADIUS_SCALE
+from ..render_constants import (
+    FLASHLIGHT_FOG_SCALE_ONE,
+    FLASHLIGHT_FOG_SCALE_TWO,
+    FOG_RADIUS_SCALE,
+)
 from ..rng import get_rng
 from .constants import (
     MAX_ZOMBIES,
@@ -46,6 +54,7 @@ __all__ = [
     "place_new_car",
     "place_fuel_can",
     "place_flashlights",
+    "place_shoes",
     "place_buddies",
     "spawn_survivors",
     "setup_player_and_cars",
@@ -59,6 +68,13 @@ __all__ = [
 ]
 
 
+def _cell_center(cell: tuple[int, int], cell_size: int) -> tuple[int, int]:
+    return (
+        int((cell[0] * cell_size) + (cell_size / 2)),
+        int((cell[1] * cell_size) + (cell_size / 2)),
+    )
+
+
 def _car_appearance_for_stage(stage: Stage | None) -> str:
     return "disabled" if stage and stage.endurance_stage else "default"
 
@@ -94,7 +110,12 @@ def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
 
 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
+    if count <= 0:
+        scale = FOG_RADIUS_SCALE
+    elif count == 1:
+        scale = FLASHLIGHT_FOG_SCALE_ONE
+    else:
+        scale = FLASHLIGHT_FOG_SCALE_TWO
     return FOV_RADIUS * scale
 
 
@@ -297,10 +318,12 @@ def _create_zombie(
 
 
 def place_fuel_can(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
     count: int = 1,
 ) -> FuelCan | None:
     """Pick a spawn spot for the fuel can away from the player (and car if given)."""
@@ -314,31 +337,37 @@ def place_fuel_can(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
-        dx = cell.centerx - player.x
-        dy = cell.centery - player.y
+        center = _cell_center(cell, cell_size)
+        if reserved_centers and center in reserved_centers:
+            continue
+        dx = center[0] - player.x
+        dy = center[1] - player.y
         if dx * dx + dy * dy < min_player_dist_sq:
             continue
         if cars:
             too_close = False
             for parked_car in cars:
-                dx = cell.centerx - parked_car.rect.centerx
-                dy = cell.centery - parked_car.rect.centery
+                dx = center[0] - parked_car.rect.centerx
+                dy = center[1] - parked_car.rect.centery
                 if dx * dx + dy * dy < min_car_dist_sq:
                     too_close = True
                     break
             if too_close:
                 continue
-        return FuelCan(cell.centerx, cell.centery)
+        return FuelCan(center[0], center[1])
 
     cell = RNG.choice(walkable_cells)
-    return FuelCan(cell.centerx, cell.centery)
+    center = _cell_center(cell, cell_size)
+    return FuelCan(center[0], center[1])
 
 
 def _place_flashlight(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
 ) -> Flashlight | None:
     """Pick a spawn spot for the flashlight away from the player (and car if given)."""
     if not walkable_cells:
@@ -351,29 +380,35 @@ def _place_flashlight(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
-        dx = cell.centerx - player.x
-        dy = cell.centery - player.y
+        center = _cell_center(cell, cell_size)
+        if reserved_centers and center in reserved_centers:
+            continue
+        dx = center[0] - player.x
+        dy = center[1] - player.y
         if dx * dx + dy * dy < min_player_dist_sq:
             continue
         if cars:
             if any(
-                (cell.centerx - parked.rect.centerx) ** 2
-                + (cell.centery - parked.rect.centery) ** 2
+                (center[0] - parked.rect.centerx) ** 2
+                + (center[1] - parked.rect.centery) ** 2
                 < min_car_dist_sq
                 for parked in cars
             ):
                 continue
-        return Flashlight(cell.centerx, cell.centery)
+        return Flashlight(center[0], center[1])
 
     cell = RNG.choice(walkable_cells)
-    return Flashlight(cell.centerx, cell.centery)
+    center = _cell_center(cell, cell_size)
+    return Flashlight(center[0], center[1])
 
 
 def place_flashlights(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
     count: int = DEFAULT_FLASHLIGHT_SPAWN_COUNT,
 ) -> list[Flashlight]:
     """Spawn multiple flashlights using the single-place helper to spread them out."""
@@ -382,7 +417,13 @@ def place_flashlights(
     max_attempts = max(200, count * 80)
     while len(placed) < count and attempts < max_attempts:
         attempts += 1
-        fl = _place_flashlight(walkable_cells, player, cars=cars)
+        fl = _place_flashlight(
+            walkable_cells,
+            cell_size,
+            player,
+            cars=cars,
+            reserved_centers=reserved_centers,
+        )
         if not fl:
             break
         # Avoid clustering too tightly
@@ -397,8 +438,85 @@ def place_flashlights(
     return placed
 
 
+def _place_shoes(
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
+    player: Player,
+    *,
+    cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
+) -> Shoes | None:
+    """Pick a spawn spot for the shoes away from the player (and car if given)."""
+    if not walkable_cells:
+        return None
+
+    min_player_dist = 240
+    min_car_dist = 200
+    min_player_dist_sq = min_player_dist * min_player_dist
+    min_car_dist_sq = min_car_dist * min_car_dist
+
+    for _ in range(200):
+        cell = RNG.choice(walkable_cells)
+        center = _cell_center(cell, cell_size)
+        if reserved_centers and center in reserved_centers:
+            continue
+        dx = center[0] - player.x
+        dy = center[1] - player.y
+        if dx * dx + dy * dy < min_player_dist_sq:
+            continue
+        if cars:
+            if any(
+                (center[0] - parked.rect.centerx) ** 2
+                + (center[1] - parked.rect.centery) ** 2
+                < min_car_dist_sq
+                for parked in cars
+            ):
+                continue
+        return Shoes(center[0], center[1])
+
+    cell = RNG.choice(walkable_cells)
+    center = _cell_center(cell, cell_size)
+    return Shoes(center[0], center[1])
+
+
+def place_shoes(
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
+    player: Player,
+    *,
+    cars: Sequence[Car] | None = None,
+    reserved_centers: set[tuple[int, int]] | None = None,
+    count: int = DEFAULT_SHOES_SPAWN_COUNT,
+) -> list[Shoes]:
+    """Spawn multiple shoes using the single-place helper to spread them out."""
+    placed: list[Shoes] = []
+    attempts = 0
+    max_attempts = max(200, count * 80)
+    while len(placed) < count and attempts < max_attempts:
+        attempts += 1
+        shoes = _place_shoes(
+            walkable_cells,
+            cell_size,
+            player,
+            cars=cars,
+            reserved_centers=reserved_centers,
+        )
+        if not shoes:
+            break
+        if any(
+            (other.rect.centerx - shoes.rect.centerx) ** 2
+            + (other.rect.centery - shoes.rect.centery) ** 2
+            < 120 * 120
+            for other in placed
+        ):
+            continue
+        placed.append(shoes)
+    return placed
+
+
 def place_buddies(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
@@ -410,6 +528,7 @@ def place_buddies(
     min_player_dist = 240
     positions = find_interior_spawn_positions(
         walkable_cells,
+        cell_size,
         1.0,
         player=player,
         min_player_dist=min_player_dist,
@@ -419,7 +538,10 @@ def place_buddies(
         placed.append(Survivor(pos[0], pos[1], is_buddy=True))
     remaining = count - len(placed)
     for _ in range(max(0, remaining)):
-        spawn_pos = find_nearby_offscreen_spawn_position(walkable_cells)
+        spawn_pos = find_nearby_offscreen_spawn_position(
+            walkable_cells,
+            cell_size,
+        )
         placed.append(Survivor(spawn_pos[0], spawn_pos[1], is_buddy=True))
     return placed
 
@@ -427,7 +549,8 @@ def place_buddies(
 def place_new_car(
     wall_group: pygame.sprite.Group,
     player: Player,
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     *,
     existing_cars: Sequence[Car] | None = None,
     appearance: str = "default",
@@ -438,7 +561,7 @@ def place_new_car(
     max_attempts = 150
     for _ in range(max_attempts):
         cell = RNG.choice(walkable_cells)
-        c_x, c_y = cell.center
+        c_x, c_y = _cell_center(cell, cell_size)
         temp_car = Car(c_x, c_y, appearance=appearance)
         temp_rect = temp_car.rect.inflate(30, 30)
         nearby_walls = pygame.sprite.Group()
@@ -464,7 +587,7 @@ def place_new_car(
 
 
 def spawn_survivors(
-    game_data: GameData, layout_data: Mapping[str, list[pygame.Rect]]
+    game_data: GameData, layout_data: Mapping[str, list[tuple[int, int]]]
 ) -> list[Survivor]:
     """Populate rescue-stage survivors and buddy-stage buddies."""
     survivors: list[Survivor] = []
@@ -475,10 +598,12 @@ def spawn_survivors(
     wall_group = game_data.groups.wall_group
     survivor_group = game_data.groups.survivor_group
     all_sprites = game_data.groups.all_sprites
+    cell_size = game_data.cell_size
 
     if game_data.stage.rescue_stage:
         positions = find_interior_spawn_positions(
             walkable,
+            cell_size,
             game_data.stage.survivor_spawn_rate,
         )
         for pos in positions:
@@ -495,6 +620,7 @@ def spawn_survivors(
         if game_data.player:
             buddies = place_buddies(
                 walkable,
+                cell_size,
                 game_data.player,
                 cars=game_data.waiting_cars,
                 count=buddy_count,
@@ -511,17 +637,18 @@ def spawn_survivors(
 
 def setup_player_and_cars(
     game_data: GameData,
-    layout_data: Mapping[str, list[pygame.Rect]],
+    layout_data: Mapping[str, list[tuple[int, int]]],
     *,
     car_count: int = 1,
 ) -> tuple[Player, list[Car]]:
     """Create the player plus one or more parked cars using blueprint candidates."""
     all_sprites = game_data.groups.all_sprites
-    walkable_cells: list[pygame.Rect] = layout_data["walkable_cells"]
+    walkable_cells: list[tuple[int, int]] = layout_data["walkable_cells"]
+    cell_size = game_data.cell_size
 
-    def _pick_center(cells: list[pygame.Rect]) -> tuple[int, int]:
+    def _pick_center(cells: list[tuple[int, int]]) -> tuple[int, int]:
         return (
-            RNG.choice(cells).center
+            _cell_center(RNG.choice(cells), cell_size)
             if cells
             else (game_data.level_width // 2, game_data.level_height // 2)
         )
@@ -539,13 +666,14 @@ def setup_player_and_cars(
             return (player_pos[0] + 200, player_pos[1])
         RNG.shuffle(car_candidates)
         for candidate in car_candidates:
-            if (candidate.centerx - player_pos[0]) ** 2 + (
-                candidate.centery - player_pos[1]
+            center = _cell_center(candidate, cell_size)
+            if (center[0] - player_pos[0]) ** 2 + (
+                center[1] - player_pos[1]
             ) ** 2 >= 400 * 400:
                 car_candidates.remove(candidate)
-                return candidate.center
+                return center
         choice = car_candidates.pop()
-        return choice.center
+        return _cell_center(choice, cell_size)
 
     for _ in range(max(1, car_count)):
         car_pos = _pick_car_position()
@@ -562,7 +690,7 @@ def setup_player_and_cars(
 def spawn_initial_zombies(
     game_data: GameData,
     player: Player,
-    layout_data: Mapping[str, list[pygame.Rect]],
+    layout_data: Mapping[str, list[tuple[int, int]]],
     config: dict[str, Any],
 ) -> None:
     """Spawn initial zombies using blueprint candidate cells."""
@@ -573,24 +701,25 @@ def spawn_initial_zombies(
     spawn_cells = layout_data["walkable_cells"]
     if not spawn_cells:
         return
+    cell_size = game_data.cell_size
 
     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
-        ]
+        candidates = []
+        for cell in spawn_cells:
+            center = _cell_center(cell, cell_size)
+            dist_sq = (center[0] - player_pos[0]) ** 2 + (center[1] - player_pos[1]) ** 2
+            if min_dist_sq <= dist_sq <= max_dist_sq:
+                candidates.append(cell)
         if not candidates:
             candidates = spawn_cells
         candidate = RNG.choice(candidates)
+        candidate_center = _cell_center(candidate, cell_size)
         tentative = _create_zombie(
             config,
-            start_pos=candidate.center,
+            start_pos=candidate_center,
             stage=game_data.stage,
             tracker=True,
             wall_follower=False,
@@ -605,6 +734,7 @@ def spawn_initial_zombies(
     spawn_rate = max(0.0, game_data.stage.initial_interior_spawn_rate)
     positions = find_interior_spawn_positions(
         spawn_cells,
+        cell_size,
         spawn_rate,
         player=player,
         min_player_dist=ZOMBIE_SPAWN_PLAYER_BUFFER,
@@ -638,6 +768,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
         return None
     wall_group = game_data.groups.wall_group
     all_sprites = game_data.groups.all_sprites
+    cell_size = game_data.cell_size
     active_car = game_data.car if game_data.car and game_data.car.alive() else None
     waiting = _alive_waiting_cars(game_data)
     obstacles: list[Car] = list(waiting)
@@ -651,6 +782,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
             wall_group,
             player,
             walkable_cells,
+            cell_size,
             existing_cars=obstacles,
             appearance=appearance,
         )
@@ -722,6 +854,7 @@ def _spawn_nearby_zombie(
     all_sprites = game_data.groups.all_sprites
     spawn_pos = find_nearby_offscreen_spawn_position(
         game_data.layout.walkable_cells,
+        game_data.cell_size,
         player=player,
         camera=camera,
         min_player_dist=ZOMBIE_SPAWN_PLAYER_BUFFER,

zombie_escape/gameplay/state.py

@@ -31,6 +31,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         elapsed_play_ms=0,
         has_fuel=starts_with_fuel,
         flashlight_count=initial_flashlights,
+        shoes_count=0,
         ambient_palette_key=initial_palette_key,
         hint_expires_at=0,
         hint_target_type=None,
@@ -53,6 +54,8 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         falling_zombies=[],
         falling_spawn_carry=0,
         dust_rings=[],
+        player_wall_target_cell=None,
+        player_wall_target_ttl=0,
     )
 
     # Create sprite groups
@@ -68,8 +71,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
     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
+    field_rect = pygame.Rect(0, 0, level_width, level_height)
 
     return GameData(
         state=game_state,
@@ -81,9 +83,8 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         ),
         camera=camera,
         layout=LevelLayout(
-            outer_rect=outer_rect,
-            inner_rect=inner_rect,
-            outside_rects=[],
+            field_rect=field_rect,
+            outside_cells=set(),
             walkable_cells=[],
             outer_wall_cells=set(),
             wall_cells=set(),
@@ -100,13 +101,17 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         level_height=level_height,
         fuel=None,
         flashlights=[],
+        shoes=[],
     )
 
 
 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:
+    outside_cells = game_data.layout.outside_cells
+    if not outside_cells:
+        return
+    cell_size = game_data.cell_size
+    if cell_size <= 0:
         return
     group = game_data.groups.zombie_group
     if not group:
@@ -114,8 +119,11 @@ def carbonize_outdoor_zombies(game_data: GameData) -> None:
     for zombie in list(group):
         if not zombie.alive():
             continue
-        center = zombie.rect.center
-        if any(rect_obj.collidepoint(center) for rect_obj in outside_rects):
+        cell = (
+            int(zombie.rect.centerx // cell_size),
+            int(zombie.rect.centery // cell_size),
+        )
+        if cell in outside_cells:
             zombie.carbonize()
 
 

zombie_escape/gameplay/survivors.py

@@ -29,7 +29,9 @@ RNG = get_rng()
 
 
 def update_survivors(
-    game_data: GameData, wall_index: WallIndex | None = None
+    game_data: GameData,
+    wall_index: WallIndex | None = None,
+    wall_target_cell: tuple[int, int] | None = None,
 ) -> None:
     if not (game_data.stage.rescue_stage or game_data.stage.buddy_required_count > 0):
         return
@@ -54,6 +56,7 @@ def update_survivors(
             grid_rows=game_data.stage.grid_rows,
             level_width=game_data.level_width,
             level_height=game_data.level_height,
+            wall_target_cell=wall_target_cell,
         )
 
     # Gently prevent survivors from overlapping the player or each other
@@ -106,6 +109,7 @@ def update_survivors(
                 other.rect.center = (int(other.x), int(other.y))
 
 
+
 def calculate_car_speed_for_passengers(
     passengers: int, *, capacity: int = SURVIVOR_MAX_SAFE_PASSENGERS
 ) -> float:
@@ -243,6 +247,7 @@ def handle_survivor_zombie_collisions(
     zombie_xs = [z.rect.centerx for z in zombies]
     camera = game_data.camera
     walkable_cells = game_data.layout.walkable_cells
+    cell_size = game_data.cell_size
 
     for survivor in list(survivor_group):
         if not survivor.alive():
@@ -275,6 +280,7 @@ def handle_survivor_zombie_collisions(
         if not rect_visible_on_screen(camera, survivor.rect):
             spawn_pos = find_nearby_offscreen_spawn_position(
                 walkable_cells,
+                cell_size,
                 camera=camera,
             )
             survivor.teleport(spawn_pos)
@@ -310,6 +316,7 @@ def respawn_buddies_near_player(game_data: GameData) -> None:
     wall_group = game_data.groups.wall_group
     camera = game_data.camera
     walkable_cells = game_data.layout.walkable_cells
+    cell_size = game_data.cell_size
     offsets = [
         (BUDDY_RADIUS * 3, 0),
         (-BUDDY_RADIUS * 3, 0),
@@ -321,6 +328,7 @@ def respawn_buddies_near_player(game_data: GameData) -> None:
         if walkable_cells:
             spawn_pos = find_nearby_offscreen_spawn_position(
                 walkable_cells,
+                cell_size,
                 camera=camera,
             )
         else: