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

zombie_escape/gameplay/spawn.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Mapping, Sequence
+from typing import Any, Callable, Literal, Mapping, Sequence
 
 import pygame
 
@@ -16,13 +16,15 @@ from ..entities import (
 )
 from ..entities_constants import (
     FAST_ZOMBIE_BASE_SPEED,
+    FOV_RADIUS,
     PLAYER_SPEED,
     ZOMBIE_AGING_DURATION_FRAMES,
     ZOMBIE_SPEED,
 )
 from ..gameplay_constants import DEFAULT_FLASHLIGHT_SPAWN_COUNT
 from ..level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS, DEFAULT_TILE_SIZE
-from ..models import GameData, Stage
+from ..models import DustRing, FallingZombie, GameData, Stage
+from ..render_constants import FLASHLIGHT_FOG_SCALE_STEP, FOG_RADIUS_SCALE
 from ..rng import get_rng
 from .constants import (
     MAX_ZOMBIES,
@@ -38,6 +40,8 @@ from .utils import (
 
 RNG = get_rng()
 
+FallScheduleResult = Literal["scheduled", "no_position", "blocked", "no_player"]
+
 __all__ = [
     "place_new_car",
     "place_fuel_can",
@@ -49,13 +53,177 @@ __all__ = [
     "spawn_waiting_car",
     "maintain_waiting_car_supply",
     "nearest_waiting_car",
+    "update_falling_zombies",
     "spawn_exterior_zombie",
     "spawn_weighted_zombie",
 ]
 
 
 def _car_appearance_for_stage(stage: Stage | None) -> str:
-    return "disabled" if stage and stage.survival_stage else "default"
+    return "disabled" if stage and stage.endurance_stage else "default"
+
+
+def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
+    normal_ratio = 1.0
+    tracker_ratio = 0.0
+    wall_follower_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:
+            normal_ratio = 1.0
+            tracker_ratio = 0.0
+            wall_follower_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
+        ):
+            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_follower_ratio)
+    total_ratio = normal_ratio + tracker_ratio + wall_follower_ratio
+    if total_ratio <= 0:
+        return False, False
+    pick = RNG.random() * total_ratio
+    if pick < normal_ratio:
+        return False, False
+    if pick < normal_ratio + tracker_ratio:
+        return True, False
+    return False, True
+
+
+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
+    return FOV_RADIUS * scale
+
+
+def _is_spawn_position_clear(
+    game_data: GameData,
+    candidate: Zombie,
+    *,
+    allow_player_overlap: bool = False,
+) -> bool:
+    wall_group = game_data.groups.wall_group
+    if spritecollideany_walls(candidate, wall_group):
+        return False
+
+    spawn_rect = candidate.rect
+    player = game_data.player
+    if not allow_player_overlap and player and spawn_rect.colliderect(player.rect):
+        return False
+    car = game_data.car
+    if car and car.alive() and spawn_rect.colliderect(car.rect):
+        return False
+    for parked in game_data.waiting_cars:
+        if parked.alive() and spawn_rect.colliderect(parked.rect):
+            return False
+    for survivor in game_data.groups.survivor_group:
+        if survivor.alive() and spawn_rect.colliderect(survivor.rect):
+            return False
+    for zombie in game_data.groups.zombie_group:
+        if zombie.alive() and spawn_rect.colliderect(zombie.rect):
+            return False
+    return True
+
+
+def _pick_fall_spawn_position(
+    game_data: GameData,
+    *,
+    min_distance: float,
+    attempts: int = 10,
+    is_clear: Callable[[tuple[int, int]], bool] | None = None,
+) -> tuple[int, int] | None:
+    player = game_data.player
+    if not player:
+        return None
+    fall_spawn_cells = game_data.layout.fall_spawn_cells
+    if not fall_spawn_cells:
+        return None
+    car = game_data.car
+    target_sprite = car if player.in_car and car and car.alive() else player
+    target_center = target_sprite.rect.center
+    cell_size = game_data.cell_size
+    fov_radius = _fov_radius_for_flashlights(game_data.state.flashlight_count)
+    min_dist_sq = min_distance * min_distance
+    max_dist_sq = fov_radius * fov_radius
+    wall_cells = game_data.layout.wall_cells
+
+    candidates: list[tuple[int, int]] = []
+    for cell_x, cell_y in fall_spawn_cells:
+        if (cell_x, cell_y) in wall_cells:
+            continue
+        pos = (
+            int(cell_x * cell_size + cell_size // 2),
+            int(cell_y * cell_size + cell_size // 2),
+        )
+        dx = pos[0] - target_center[0]
+        dy = pos[1] - target_center[1]
+        dist_sq = dx * dx + dy * dy
+        if dist_sq < min_dist_sq or dist_sq > max_dist_sq:
+            continue
+        candidates.append(pos)
+
+    if not candidates:
+        return None
+
+    RNG.shuffle(candidates)
+    for pos in candidates[: max(1, min(attempts, len(candidates)))]:
+        if is_clear is not None and not is_clear(pos):
+            continue
+        return pos
+    return None
+
+
+def _schedule_falling_zombie(
+    game_data: GameData,
+    config: dict[str, Any],
+    *,
+    allow_carry: bool = True,
+) -> FallScheduleResult:
+    player = game_data.player
+    if not player:
+        return "no_player"
+    state = game_data.state
+    zombie_group = game_data.groups.zombie_group
+    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)
+
+    def _candidate_clear(pos: tuple[int, int]) -> bool:
+        candidate = _create_zombie(
+            config,
+            start_pos=pos,
+            stage=game_data.stage,
+            tracker=tracker,
+            wall_follower=wall_follower,
+        )
+        return _is_spawn_position_clear(game_data, candidate)
+
+    spawn_pos = _pick_fall_spawn_position(
+        game_data,
+        min_distance=min_distance,
+        is_clear=_candidate_clear,
+    )
+    if spawn_pos is None:
+        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))
+    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,
+        tracker=tracker,
+        wall_follower=wall_follower,
+    )
+    state.falling_zombies.append(fall)
+    return "scheduled"
 
 
 def _create_zombie(
@@ -75,44 +243,19 @@ def _create_zombie(
     else:
         base_speed = ZOMBIE_SPEED
     base_speed = min(base_speed, PLAYER_SPEED - 0.05)
-    normal_ratio = 1.0
-    tracker_ratio = 0.0
-    wall_follower_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:
-            normal_ratio = 1.0
-            tracker_ratio = 0.0
-            wall_follower_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
-        ):
-            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_follower_ratio)
         aging_duration_frames = max(
             1.0,
             float(stage.zombie_aging_duration_frames),
         )
     else:
         aging_duration_frames = ZOMBIE_AGING_DURATION_FRAMES
-    picked_tracker = False
-    picked_wall_follower = False
-    total_ratio = normal_ratio + tracker_ratio + wall_follower_ratio
-    if total_ratio > 0:
-        pick = RNG.random() * total_ratio
-        if pick < normal_ratio:
-            pass
-        elif pick < normal_ratio + tracker_ratio:
-            picked_tracker = True
-        else:
-            picked_wall_follower = True
-    if tracker is None:
-        tracker = picked_tracker
-    if wall_follower is None:
-        wall_follower = picked_wall_follower
+    if tracker is None or wall_follower is None:
+        picked_tracker, picked_wall_follower = _pick_zombie_variant(stage)
+        if tracker is None:
+            tracker = picked_tracker
+        if wall_follower is None:
+            wall_follower = picked_wall_follower
     if tracker:
         wall_follower = False
     if tracker:
@@ -431,6 +574,34 @@ def spawn_initial_zombies(
     if not spawn_cells:
         return
 
+    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
+        ]
+        if not candidates:
+            candidates = spawn_cells
+        candidate = RNG.choice(candidates)
+        tentative = _create_zombie(
+            config,
+            start_pos=candidate.center,
+            stage=game_data.stage,
+            tracker=True,
+            wall_follower=False,
+        )
+        if not spritecollideany_walls(tentative, wall_group):
+            zombie_group.add(tentative)
+            all_sprites.add(tentative, layer=1)
+        interval = max(1, game_data.stage.spawn_interval_ms)
+        game_data.state.last_zombie_spawn_time = pygame.time.get_ticks() - interval
+        return
+
     spawn_rate = max(0.0, game_data.stage.initial_interior_spawn_rate)
     positions = find_interior_spawn_positions(
         spawn_cells,
@@ -440,10 +611,13 @@ def spawn_initial_zombies(
     )
 
     for pos in positions:
+        tracker, wall_follower = _pick_zombie_variant(game_data.stage)
         tentative = _create_zombie(
             config,
             start_pos=pos,
             stage=game_data.stage,
+            tracker=tracker,
+            wall_follower=wall_follower,
         )
         if spritecollideany_walls(tentative, wall_group):
             continue
@@ -550,6 +724,7 @@ def _spawn_nearby_zombie(
         game_data.layout.walkable_cells,
         player=player,
         camera=camera,
+        min_player_dist=ZOMBIE_SPAWN_PLAYER_BUFFER,
         attempts=50,
     )
     new_zombie = _create_zombie(
@@ -589,6 +764,43 @@ def spawn_exterior_zombie(
     return new_zombie
 
 
+def update_falling_zombies(game_data: GameData, config: dict[str, Any]) -> None:
+    state = game_data.state
+    if not state.falling_zombies:
+        return
+    now = pygame.time.get_ticks()
+    zombie_group = game_data.groups.zombie_group
+    all_sprites = game_data.groups.all_sprites
+    for fall in list(state.falling_zombies):
+        fall_start = fall.started_at_ms + fall.pre_fx_ms
+        impact_at = fall_start + fall.fall_duration_ms
+        spawn_at = impact_at + fall.dust_duration_ms
+        if now >= impact_at and not fall.dust_started:
+            state.dust_rings.append(
+                DustRing(
+                    pos=fall.target_pos,
+                    started_at_ms=impact_at,
+                    duration_ms=fall.dust_duration_ms,
+                )
+            )
+            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)
+        state.falling_zombies.remove(fall)
+
+
 def spawn_weighted_zombie(
     game_data: GameData,
     config: dict[str, Any],
@@ -596,23 +808,51 @@ def spawn_weighted_zombie(
     """Spawn a zombie according to the stage's interior/exterior mix."""
     stage = game_data.stage
 
-    def _spawn(choice: str) -> bool:
-        if choice == "interior":
-            return _spawn_nearby_zombie(game_data, config) is not None
+    def _spawn_interior() -> bool:
+        return _spawn_nearby_zombie(game_data, config) is not None
+
+    def _spawn_exterior() -> bool:
         return spawn_exterior_zombie(game_data, config) is not None
 
+    def _spawn_fall() -> FallScheduleResult:
+        result = _schedule_falling_zombie(game_data, config)
+        if result != "scheduled":
+            return result
+        state = game_data.state
+        if state.falling_spawn_carry > 0:
+            extra = _schedule_falling_zombie(
+                game_data,
+                config,
+                allow_carry=False,
+            )
+            if extra == "scheduled":
+                state.falling_spawn_carry = max(0, state.falling_spawn_carry - 1)
+        return "scheduled"
+
     interior_weight = max(0.0, stage.interior_spawn_weight)
     exterior_weight = max(0.0, stage.exterior_spawn_weight)
-    total_weight = interior_weight + exterior_weight
+    fall_weight = max(0.0, getattr(stage, "interior_fall_spawn_weight", 0.0))
+    total_weight = interior_weight + exterior_weight + fall_weight
     if total_weight <= 0:
         # Fall back to exterior spawns if weights are unset or invalid.
-        return _spawn("exterior")
+        return _spawn_exterior()
 
     pick = RNG.uniform(0, total_weight)
     if pick <= interior_weight:
-        if _spawn("interior"):
+        if _spawn_interior():
             return True
-        return _spawn("exterior")
-    if _spawn("exterior"):
+        fall_result = _spawn_fall()
+        if fall_result == "scheduled":
+            return True
+        return False
+    if pick <= interior_weight + fall_weight:
+        fall_result = _spawn_fall()
+        if fall_result == "scheduled":
+            return True
+        return False
+    if _spawn_exterior():
+        return True
+    fall_result = _spawn_fall()
+    if fall_result == "scheduled":
         return True
-    return _spawn("interior")
+    return False

zombie_escape/gameplay/state.py

@@ -14,7 +14,7 @@ from .ambient import _set_ambient_palette
 def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
     """Initialize and return the base game state objects."""
     starts_with_fuel = not stage.requires_fuel
-    if stage.survival_stage:
+    if stage.endurance_stage:
         starts_with_fuel = False
     starts_with_flashlight = False
     initial_flashlights = 1 if starts_with_flashlight else 0
@@ -42,14 +42,17 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         survivor_messages=[],
         survivor_capacity=SURVIVOR_MAX_SAFE_PASSENGERS,
         seed=None,
-        survival_elapsed_ms=0,
-        survival_goal_ms=max(0, stage.survival_goal_ms),
+        endurance_elapsed_ms=0,
+        endurance_goal_ms=max(0, stage.endurance_goal_ms),
         dawn_ready=False,
         dawn_prompt_at=None,
         time_accel_active=False,
         last_zombie_spawn_time=0,
         dawn_carbonized=False,
         debug_mode=False,
+        falling_zombies=[],
+        falling_spawn_carry=0,
+        dust_rings=[],
     )
 
     # Create sprite groups
@@ -83,6 +86,9 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
             outside_rects=[],
             walkable_cells=[],
             outer_wall_cells=set(),
+            wall_cells=set(),
+            fall_spawn_cells=set(),
+            bevel_corners={},
         ),
         fog={
             "hatch_patterns": {},
@@ -106,29 +112,26 @@ def carbonize_outdoor_zombies(game_data: GameData) -> None:
     if not group:
         return
     for zombie in list(group):
-        alive = getattr(zombie, "alive", lambda: False)
-        if not alive():
+        if not zombie.alive():
             continue
         center = zombie.rect.center
         if any(rect_obj.collidepoint(center) for rect_obj in outside_rects):
-            carbonize = getattr(zombie, "carbonize", None)
-            if carbonize:
-                carbonize()
+            zombie.carbonize()
 
 
-def update_survival_timer(game_data: GameData, dt_ms: int) -> None:
-    """Advance the survival countdown and trigger dawn handoff."""
+def update_endurance_timer(game_data: GameData, dt_ms: int) -> None:
+    """Advance the endurance countdown and trigger dawn handoff."""
     stage = game_data.stage
     state = game_data.state
-    if not stage.survival_stage:
+    if not stage.endurance_stage:
         return
-    if state.survival_goal_ms <= 0 or dt_ms <= 0:
+    if state.endurance_goal_ms <= 0 or dt_ms <= 0:
         return
-    state.survival_elapsed_ms = min(
-        state.survival_goal_ms,
-        state.survival_elapsed_ms + dt_ms,
+    state.endurance_elapsed_ms = min(
+        state.endurance_goal_ms,
+        state.endurance_elapsed_ms + dt_ms,
     )
-    if not state.dawn_ready and state.survival_elapsed_ms >= state.survival_goal_ms:
+    if not state.dawn_ready and state.endurance_elapsed_ms >= state.endurance_goal_ms:
         state.dawn_ready = True
         state.dawn_prompt_at = pygame.time.get_ticks()
         _set_ambient_palette(game_data, DAWN_AMBIENT_PALETTE_KEY, force=True)

zombie_escape/gameplay/survivors.py

@@ -16,15 +16,12 @@ from ..entities_constants import (
     SURVIVOR_RADIUS,
     ZOMBIE_RADIUS,
 )
-from .constants import (
-    SURVIVOR_CONVERSION_LINE_KEYS,
-    SURVIVOR_MESSAGE_DURATION_MS,
-    SURVIVOR_SPEED_PENALTY_PER_PASSENGER,
-)
-from ..localization import translate as tr
+from .constants import SURVIVOR_MESSAGE_DURATION_MS, SURVIVOR_SPEED_PENALTY_PER_PASSENGER
+from ..localization import translate_dict, translate_list
 from ..models import GameData, ProgressState
 from ..rng import get_rng
-from ..entities import Survivor, spritecollideany_walls, WallIndex
+from ..entities import Survivor, Zombie, spritecollideany_walls
+from ..world_grid import WallIndex
 from .spawn import _create_zombie
 from .utils import find_nearby_offscreen_spawn_position, rect_visible_on_screen
 
@@ -51,6 +48,10 @@ def update_survivors(
             wall_group,
             wall_index=wall_index,
             cell_size=game_data.cell_size,
+            wall_cells=game_data.layout.wall_cells,
+            bevel_corners=game_data.layout.bevel_corners,
+            grid_cols=game_data.stage.grid_cols,
+            grid_rows=game_data.stage.grid_rows,
             level_width=game_data.level_width,
             level_height=game_data.level_height,
         )
@@ -150,11 +151,40 @@ def add_survivor_message(game_data: GameData, text: str) -> None:
     game_data.state.survivor_messages.append({"text": text, "expires_at": expires})
 
 
-def random_survivor_conversion_line() -> str:
-    if not SURVIVOR_CONVERSION_LINE_KEYS:
+def _normalize_legacy_conversion_lines(data: dict[str, Any]) -> list[str]:
+    numbered: list[tuple[int, str]] = []
+    others: list[tuple[str, str]] = []
+    for key, value in data.items():
+        if not value:
+            continue
+        text = str(value)
+        if isinstance(key, str) and key.startswith("line"):
+            suffix = key[4:]
+            if suffix.isdigit():
+                numbered.append((int(suffix), text))
+                continue
+        others.append((str(key), text))
+    numbered.sort(key=lambda item: item[0])
+    others.sort(key=lambda item: item[0])
+    return [text for _, text in numbered] + [text for _, text in others]
+
+
+def _get_survivor_conversion_messages(stage_id: str) -> list[str]:
+    key = f"stages.{stage_id}.survivor_conversion_messages"
+    raw = translate_list(key)
+    if raw:
+        return [str(item) for item in raw if item]
+    legacy = translate_dict(f"stages.{stage_id}.conversion_lines")
+    if legacy:
+        return _normalize_legacy_conversion_lines(legacy)
+    return []
+
+
+def random_survivor_conversion_line(stage_id: str) -> str:
+    lines = _get_survivor_conversion_messages(stage_id)
+    if not lines:
         return ""
-    key = RNG.choice(SURVIVOR_CONVERSION_LINE_KEYS)
-    return tr(key)
+    return RNG.choice(lines)
 
 
 def cleanup_survivor_messages(state: ProgressState) -> None:
@@ -224,7 +254,7 @@ def handle_survivor_zombie_collisions(
         min_x = survivor.rect.centerx - search_radius
         max_x = survivor.rect.centerx + search_radius
         start_idx = bisect_left(zombie_xs, min_x)
-        collided = False
+        collided_zombie: Zombie | None = None
         for idx in range(start_idx, len(zombies)):
             zombie_x = zombie_xs[idx]
             if zombie_x > max_x:
@@ -237,10 +267,10 @@ def handle_survivor_zombie_collisions(
                 continue
             dx = zombie_x - survivor.rect.centerx
             if dx * dx + dy * dy <= search_radius_sq:
-                collided = True
+                collided_zombie = zombie
                 break
 
-        if not collided:
+        if collided_zombie is None:
             continue
         if not rect_visible_on_screen(camera, survivor.rect):
             spawn_pos = find_nearby_offscreen_spawn_position(
@@ -250,13 +280,15 @@ def handle_survivor_zombie_collisions(
             survivor.teleport(spawn_pos)
             continue
         survivor.kill()
-        line = random_survivor_conversion_line()
+        line = random_survivor_conversion_line(game_data.stage.id)
         if line:
             add_survivor_message(game_data, line)
         new_zombie = _create_zombie(
             config,
             start_pos=survivor.rect.center,
             stage=game_data.stage,
+            tracker=collided_zombie.tracker,
+            wall_follower=collided_zombie.wall_follower,
         )
         zombie_group.add(new_zombie)
         game_data.groups.all_sprites.add(new_zombie, layer=1)

zombie_escape/gameplay/utils.py

@@ -108,7 +108,9 @@ def find_nearby_offscreen_spawn_position(
         jitter_x = RNG.uniform(-cell.width * 0.35, cell.width * 0.35)
         jitter_y = RNG.uniform(-cell.height * 0.35, cell.height * 0.35)
         candidate = (int(cell.centerx + jitter_x), int(cell.centery + jitter_y))
-        if player is not None and (min_distance_sq is not None or max_distance_sq is not None):
+        if player is not None and (
+            min_distance_sq is not None or max_distance_sq is not None
+        ):
             dx = candidate[0] - player.x
             dy = candidate[1] - player.y
             dist_sq = dx * dx + dy * dy
@@ -119,6 +121,22 @@ def find_nearby_offscreen_spawn_position(
         if view_rect is not None and view_rect.collidepoint(candidate):
             continue
         return candidate
+    if player is not None and (min_distance_sq is not None or max_distance_sq is not None):
+        for _ in range(20):
+            cell = RNG.choice(walkable_cells)
+            center = (cell.centerx, cell.centery)
+            if view_rect is not None and view_rect.collidepoint(center):
+                continue
+            dx = center[0] - player.x
+            dy = center[1] - player.y
+            dist_sq = dx * dx + dy * dy
+            if min_distance_sq is not None and dist_sq < min_distance_sq:
+                continue
+            if max_distance_sq is not None and dist_sq > max_distance_sq:
+                continue
+            fallback_x = RNG.uniform(-cell.width * 0.2, cell.width * 0.2)
+            fallback_y = RNG.uniform(-cell.height * 0.2, cell.height * 0.2)
+            return (int(cell.centerx + fallback_x), int(cell.centery + fallback_y))
     fallback_cell = RNG.choice(walkable_cells)
     fallback_x = RNG.uniform(-fallback_cell.width * 0.35, fallback_cell.width * 0.35)
     fallback_y = RNG.uniform(-fallback_cell.height * 0.35, fallback_cell.height * 0.35)