zombie-escape 1.12.0__py3-none-any.whl → 1.13.1__py3-none-any.whl

zombie_escape/gameplay/spawn.py

@@ -35,6 +35,9 @@ from ..render_constants import (
 )
 from ..rng import get_rng
 from .constants import (
+    FALLING_ZOMBIE_DUST_DURATION_MS,
+    FALLING_ZOMBIE_DURATION_MS,
+    FALLING_ZOMBIE_PRE_FX_MS,
     MAX_ZOMBIES,
     ZOMBIE_SPAWN_PLAYER_BUFFER,
     ZOMBIE_TRACKER_AGING_DURATION_FRAMES,
@@ -68,6 +71,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"
 
@@ -75,22 +85,22 @@ def _car_appearance_for_stage(stage: Stage | None) -> str:
 def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
     normal_ratio = 1.0
     tracker_ratio = 0.0
-    wall_follower_ratio = 0.0
+    wall_hugging_ratio = 0.0
     if stage is not None:
         normal_ratio = max(0.0, min(1.0, stage.zombie_normal_ratio))
         tracker_ratio = max(0.0, min(1.0, stage.zombie_tracker_ratio))
-        wall_follower_ratio = max(0.0, min(1.0, stage.zombie_wall_follower_ratio))
-        if normal_ratio + tracker_ratio + wall_follower_ratio <= 0:
+        wall_hugging_ratio = max(0.0, min(1.0, stage.zombie_wall_hugging_ratio))
+        if normal_ratio + tracker_ratio + wall_hugging_ratio <= 0:
             normal_ratio = 1.0
             tracker_ratio = 0.0
-            wall_follower_ratio = 0.0
+            wall_hugging_ratio = 0.0
         if (
             normal_ratio == 1.0
-            and (tracker_ratio > 0.0 or wall_follower_ratio > 0.0)
-            and tracker_ratio + wall_follower_ratio <= 1.0
+            and (tracker_ratio > 0.0 or wall_hugging_ratio > 0.0)
+            and tracker_ratio + wall_hugging_ratio <= 1.0
         ):
-            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_follower_ratio)
-    total_ratio = normal_ratio + tracker_ratio + wall_follower_ratio
+            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_hugging_ratio)
+    total_ratio = normal_ratio + tracker_ratio + wall_hugging_ratio
     if total_ratio <= 0:
         return False, False
     pick = RNG.random() * total_ratio
@@ -203,7 +213,7 @@ def _schedule_falling_zombie(
     if len(zombie_group) + len(state.falling_zombies) >= MAX_ZOMBIES:
         return "blocked"
     min_distance = game_data.stage.tile_size * 0.5
-    tracker, wall_follower = _pick_zombie_variant(game_data.stage)
+    tracker, wall_hugging = _pick_zombie_variant(game_data.stage)
 
     def _candidate_clear(pos: tuple[int, int]) -> bool:
         candidate = _create_zombie(
@@ -211,7 +221,7 @@ def _schedule_falling_zombie(
             start_pos=pos,
             stage=game_data.stage,
             tracker=tracker,
-            wall_follower=wall_follower,
+            wall_hugging=wall_hugging,
         )
         return _is_spawn_position_clear(game_data, candidate)
 
@@ -224,17 +234,17 @@ def _schedule_falling_zombie(
         if allow_carry:
             state.falling_spawn_carry += 1
         return "no_position"
-    start_offset = game_data.stage.tile_size * 0.7
-    start_pos = (int(spawn_pos[0]), int(spawn_pos[1] - start_offset))
+    # start_offset removed; animation handles "falling" via scaling now.
+    start_pos = (int(spawn_pos[0]), int(spawn_pos[1]))
     fall = FallingZombie(
         start_pos=start_pos,
         target_pos=(int(spawn_pos[0]), int(spawn_pos[1])),
         started_at_ms=pygame.time.get_ticks(),
-        pre_fx_ms=350,
-        fall_duration_ms=450,
-        dust_duration_ms=220,
+        pre_fx_ms=FALLING_ZOMBIE_PRE_FX_MS,
+        fall_duration_ms=FALLING_ZOMBIE_DURATION_MS,
+        dust_duration_ms=FALLING_ZOMBIE_DUST_DURATION_MS,
         tracker=tracker,
-        wall_follower=wall_follower,
+        wall_hugging=wall_hugging,
     )
     state.falling_zombies.append(fall)
     return "scheduled"
@@ -247,7 +257,7 @@ def _create_zombie(
     hint_pos: tuple[float, float] | None = None,
     stage: Stage | None = None,
     tracker: bool | None = None,
-    wall_follower: bool | None = None,
+    wall_hugging: bool | None = None,
 ) -> Zombie:
     """Factory to create zombies with optional fast variants."""
     fast_conf = config.get("fast_zombies", {})
@@ -264,14 +274,14 @@ def _create_zombie(
         )
     else:
         aging_duration_frames = ZOMBIE_AGING_DURATION_FRAMES
-    if tracker is None or wall_follower is None:
-        picked_tracker, picked_wall_follower = _pick_zombie_variant(stage)
+    if tracker is None or wall_hugging is None:
+        picked_tracker, picked_wall_hugging = _pick_zombie_variant(stage)
         if tracker is None:
             tracker = picked_tracker
-        if wall_follower is None:
-            wall_follower = picked_wall_follower
+        if wall_hugging is None:
+            wall_hugging = picked_wall_hugging
     if tracker:
-        wall_follower = False
+        wall_hugging = False
     if tracker:
         ratio = (
             ZOMBIE_TRACKER_AGING_DURATION_FRAMES / ZOMBIE_AGING_DURATION_FRAMES
@@ -305,13 +315,14 @@ def _create_zombie(
         y=float(start_pos[1]),
         speed=base_speed,
         tracker=tracker,
-        wall_follower=wall_follower,
+        wall_hugging=wall_hugging,
         aging_duration_frames=aging_duration_frames,
     )
 
 
 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,
@@ -329,30 +340,33 @@ def place_fuel_can(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
-        if reserved_centers and cell.center in reserved_centers:
+        center = _cell_center(cell, cell_size)
+        if reserved_centers and center in reserved_centers:
             continue
-        dx = cell.centerx - player.x
-        dy = cell.centery - player.y
+        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,
@@ -369,28 +383,31 @@ def _place_flashlight(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
-        if reserved_centers and cell.center in reserved_centers:
+        center = _cell_center(cell, cell_size)
+        if reserved_centers and center in reserved_centers:
             continue
-        dx = cell.centerx - player.x
-        dy = cell.centery - player.y
+        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,
@@ -404,7 +421,11 @@ def place_flashlights(
     while len(placed) < count and attempts < max_attempts:
         attempts += 1
         fl = _place_flashlight(
-            walkable_cells, player, cars=cars, reserved_centers=reserved_centers
+            walkable_cells,
+            cell_size,
+            player,
+            cars=cars,
+            reserved_centers=reserved_centers,
         )
         if not fl:
             break
@@ -421,7 +442,8 @@ def place_flashlights(
 
 
 def _place_shoes(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
@@ -438,28 +460,31 @@ def _place_shoes(
 
     for _ in range(200):
         cell = RNG.choice(walkable_cells)
-        if reserved_centers and cell.center in reserved_centers:
+        center = _cell_center(cell, cell_size)
+        if reserved_centers and center in reserved_centers:
             continue
-        dx = cell.centerx - player.x
-        dy = cell.centery - player.y
+        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 Shoes(cell.centerx, cell.centery)
+        return Shoes(center[0], center[1])
 
     cell = RNG.choice(walkable_cells)
-    return Shoes(cell.centerx, cell.centery)
+    center = _cell_center(cell, cell_size)
+    return Shoes(center[0], center[1])
 
 
 def place_shoes(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
@@ -473,7 +498,11 @@ def place_shoes(
     while len(placed) < count and attempts < max_attempts:
         attempts += 1
         shoes = _place_shoes(
-            walkable_cells, player, cars=cars, reserved_centers=reserved_centers
+            walkable_cells,
+            cell_size,
+            player,
+            cars=cars,
+            reserved_centers=reserved_centers,
         )
         if not shoes:
             break
@@ -489,7 +518,8 @@ def place_shoes(
 
 
 def place_buddies(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     player: Player,
     *,
     cars: Sequence[Car] | None = None,
@@ -501,6 +531,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,
@@ -510,7 +541,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
 
@@ -518,7 +552,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",
@@ -529,7 +564,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()
@@ -555,7 +590,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] = []
@@ -566,10 +601,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:
@@ -586,6 +623,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,
@@ -602,17 +640,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)
         )
@@ -620,7 +659,8 @@ def setup_player_and_cars(
     player_pos = _pick_center(layout_data["player_cells"] or walkable_cells)
     player = Player(*player_pos)
 
-    car_candidates = list(layout_data["car_cells"] or walkable_cells)
+    car_walkable = layout_data.get("car_walkable_cells") or walkable_cells
+    car_candidates = list(layout_data["car_cells"] or car_walkable)
     waiting_cars: list[Car] = []
     car_appearance = _car_appearance_for_stage(game_data.stage)
 
@@ -630,13 +670,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()
@@ -653,7 +694,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."""
@@ -664,27 +705,28 @@ 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,
+            wall_hugging=False,
         )
         if not spritecollideany_walls(tentative, wall_group):
             zombie_group.add(tentative)
@@ -696,19 +738,20 @@ 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,
     )
 
     for pos in positions:
-        tracker, wall_follower = _pick_zombie_variant(game_data.stage)
+        tracker, wall_hugging = _pick_zombie_variant(game_data.stage)
         tentative = _create_zombie(
             config,
             start_pos=pos,
             stage=game_data.stage,
             tracker=tracker,
-            wall_follower=wall_follower,
+            wall_hugging=wall_hugging,
         )
         if spritecollideany_walls(tentative, wall_group):
             continue
@@ -724,11 +767,14 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
     player = game_data.player
     if not player:
         return None
-    walkable_cells = game_data.layout.walkable_cells
+    # Use cells that are 4-way reachable by car
+    car_walkable = list(game_data.layout.car_walkable_cells)
+    walkable_cells = car_walkable if car_walkable else game_data.layout.walkable_cells
     if not walkable_cells:
         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)
@@ -742,6 +788,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
             wall_group,
             player,
             walkable_cells,
+            cell_size,
             existing_cars=obstacles,
             appearance=appearance,
         )
@@ -813,6 +860,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,
@@ -877,18 +925,19 @@ def update_falling_zombies(game_data: GameData, config: dict[str, Any]) -> None:
             fall.dust_started = True
         if now < spawn_at:
             continue
-        if len(zombie_group) >= MAX_ZOMBIES:
-            state.falling_zombies.remove(fall)
-            continue
-        candidate = _create_zombie(
-            config,
-            start_pos=fall.target_pos,
-            stage=game_data.stage,
-            tracker=fall.tracker,
-            wall_follower=fall.wall_follower,
-        )
-        zombie_group.add(candidate)
-        all_sprites.add(candidate, layer=1)
+
+        if getattr(fall, "mode", "spawn") == "spawn":
+            if len(zombie_group) < MAX_ZOMBIES:
+                candidate = _create_zombie(
+                    config,
+                    start_pos=fall.target_pos,
+                    stage=game_data.stage,
+                    tracker=fall.tracker,
+                    wall_hugging=fall.wall_hugging,
+                )
+                zombie_group.add(candidate)
+                all_sprites.add(candidate, layer=1)
+
         state.falling_zombies.remove(fall)
 
 

zombie_escape/gameplay/state.py

@@ -51,9 +51,12 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         last_zombie_spawn_time=0,
         dawn_carbonized=False,
         debug_mode=False,
+        show_fps=False,
         falling_zombies=[],
         falling_spawn_carry=0,
         dust_rings=[],
+        player_wall_target_cell=None,
+        player_wall_target_ttl=0,
     )
 
     # Create sprite groups
@@ -69,8 +72,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,
@@ -82,12 +84,13 @@ 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(),
+            pitfall_cells=set(),
+            car_walkable_cells=set(),
             fall_spawn_cells=set(),
             bevel_corners={},
         ),
@@ -107,8 +110,11 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
 
 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:
@@ -116,8 +122,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()