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

zombie_escape/gameplay/interactions.py

@@ -57,12 +57,13 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     survivor_group = game_data.groups.survivor_group
     state = game_data.state
     walkable_cells = game_data.layout.walkable_cells
-    outside_rects = game_data.layout.outside_rects
+    outside_cells = game_data.layout.outside_cells
     fuel = game_data.fuel
     flashlights = game_data.flashlights or []
     shoes_list = game_data.shoes or []
     camera = game_data.camera
     stage = game_data.stage
+    cell_size = game_data.cell_size
     maintain_waiting_car_supply(game_data)
     active_car = car if car and car.alive() else None
     waiting_cars = game_data.waiting_cars
@@ -75,6 +76,17 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     )
     shoes_interaction_radius = _interaction_radius(SHOES_WIDTH, SHOES_HEIGHT)
 
+    def _rect_center_cell(rect: pygame.Rect) -> tuple[int, int] | None:
+        if cell_size <= 0:
+            return None
+        return (int(rect.centerx // cell_size), int(rect.centery // cell_size))
+
+    def _cell_center(cell: tuple[int, int]) -> tuple[int, int]:
+        return (
+            int((cell[0] * cell_size) + (cell_size / 2)),
+            int((cell[1] * cell_size) + (cell_size / 2)),
+        )
+
     def _player_near_point(point: tuple[float, float], radius: float) -> bool:
         dx = point[0] - player.x
         dy = point[1] - player.y
@@ -189,7 +201,7 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                 else:
                     if walkable_cells:
                         new_cell = RNG.choice(walkable_cells)
-                        buddy.teleport(new_cell.center)
+                        buddy.teleport(_cell_center(new_cell))
                     else:
                         buddy.teleport(
                             (game_data.level_width // 2, game_data.level_height // 2)
@@ -341,8 +353,9 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         stage.endurance_stage
         and state.dawn_ready
         and not player.in_car
-        and outside_rects
-        and any(outside.collidepoint(player.rect.center) for outside in outside_rects)
+        and outside_cells
+        and (player_cell := _rect_center_cell(player.rect)) is not None
+        and player_cell in outside_cells
     ):
         state.game_won = True
 
@@ -351,9 +364,8 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
         buddy_ready = True
         if stage.buddy_required_count > 0:
             buddy_ready = state.buddy_onboard >= stage.buddy_required_count
-        if buddy_ready and any(
-            outside.collidepoint(car.rect.center) for outside in outside_rects
-        ):
+        car_cell = _rect_center_cell(car.rect)
+        if buddy_ready and car_cell is not None and car_cell in outside_cells:
             if stage.buddy_required_count > 0:
                 state.buddy_rescued = min(
                     stage.buddy_required_count, state.buddy_onboard

zombie_escape/gameplay/layout.py

@@ -92,11 +92,11 @@ def generate_level_from_blueprint(
             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] = []
+    outside_cells: set[tuple[int, int]] = set()
+    walkable_cells: list[tuple[int, int]] = []
+    player_cells: list[tuple[int, int]] = []
+    car_cells: list[tuple[int, int]] = []
+    zombie_cells: list[tuple[int, int]] = []
     interior_min_x = 2
     interior_max_x = stage.grid_cols - 3
     interior_min_y = 2
@@ -125,7 +125,7 @@ def generate_level_from_blueprint(
             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)
+                outside_cells.add((x, y))
                 continue
             if ch == "B":
                 draw_bottom_side = not _has_wall(x, y + 1)
@@ -147,7 +147,7 @@ def generate_level_from_blueprint(
                 continue
             if ch == "E":
                 if not cell_has_beam:
-                    walkable_cells.append(cell_rect)
+                    walkable_cells.append((x, y))
             elif ch == "1":
                 beam = None
                 if cell_has_beam:
@@ -196,14 +196,14 @@ def generate_level_from_blueprint(
                 all_sprites.add(wall, layer=0)
             else:
                 if not cell_has_beam:
-                    walkable_cells.append(cell_rect)
+                    walkable_cells.append((x, y))
 
             if ch == "P":
-                player_cells.append(cell_rect)
+                player_cells.append((x, y))
             if ch == "C":
-                car_cells.append(cell_rect)
+                car_cells.append((x, y))
             if ch == "Z":
-                zombie_cells.append(cell_rect)
+                zombie_cells.append((x, y))
 
             if cell_has_beam and ch != "1":
                 beam = SteelBeam(
@@ -215,9 +215,13 @@ def generate_level_from_blueprint(
                 )
                 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.field_rect = pygame.Rect(
+        0,
+        0,
+        game_data.level_width,
+        game_data.level_height,
+    )
+    game_data.layout.outside_cells = outside_cells
     game_data.layout.walkable_cells = walkable_cells
     game_data.layout.outer_wall_cells = outer_wall_cells
     game_data.layout.wall_cells = wall_cells

zombie_escape/gameplay/movement.py

@@ -13,6 +13,7 @@ from ..entities import (
     Zombie,
 )
 from ..entities_constants import (
+    HUMANOID_WALL_BUMP_FRAMES,
     PLAYER_SPEED,
     ZOMBIE_SEPARATION_DISTANCE,
     ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
@@ -49,9 +50,12 @@ def process_player_input(
     dx_input += pad_input[0]
     dy_input += pad_input[1]
 
+    player.update_facing_from_input(dx_input, dy_input)
+
     player_dx, player_dy, car_dx, car_dy = 0, 0, 0, 0
 
     if player.in_car and car and car.alive():
+        car.update_facing_from_input(dx_input, dy_input)
         target_speed = car.speed
         move_len = math.hypot(dx_input, dy_input)
         if move_len > 0:
@@ -166,7 +170,25 @@ def update_entities(
     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)
+    if player.inner_wall_hit and player.inner_wall_cell is not None:
+        game_data.state.player_wall_target_cell = player.inner_wall_cell
+        game_data.state.player_wall_target_ttl = HUMANOID_WALL_BUMP_FRAMES
+    elif game_data.state.player_wall_target_ttl > 0:
+        game_data.state.player_wall_target_ttl -= 1
+        if game_data.state.player_wall_target_ttl <= 0:
+            game_data.state.player_wall_target_cell = None
+
+    wall_target_cell = (
+        game_data.state.player_wall_target_cell
+        if game_data.state.player_wall_target_ttl > 0
+        else None
+    )
+
+    update_survivors(
+        game_data,
+        wall_index=wall_index,
+        wall_target_cell=wall_target_cell,
+    )
     update_falling_zombies(game_data, config)
 
     # Spawn new zombies if needed

zombie_escape/gameplay/spawn.py

@@ -68,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"
 
@@ -311,7 +318,8 @@ 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,
@@ -329,30 +337,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 +380,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 +418,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 +439,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 +457,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 +495,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 +515,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 +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,
@@ -510,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
 
@@ -518,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",
@@ -529,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()
@@ -555,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] = []
@@ -566,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:
@@ -586,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,
@@ -602,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)
         )
@@ -630,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()
@@ -653,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."""
@@ -664,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,
@@ -696,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,
@@ -729,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)
@@ -742,6 +782,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
             wall_group,
             player,
             walkable_cells,
+            cell_size,
             existing_cars=obstacles,
             appearance=appearance,
         )
@@ -813,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

@@ -54,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
@@ -69,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,
@@ -82,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(),
@@ -107,8 +107,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 +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: