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

zombie_escape/gameplay/utils.py

@@ -25,7 +25,8 @@ def rect_visible_on_screen(camera: Camera | None, rect: pygame.Rect) -> bool:
 
 
 def _scatter_positions_on_walkable(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     spawn_rate: float,
     *,
     jitter_ratio: float = 0.35,
@@ -35,17 +36,21 @@ def _scatter_positions_on_walkable(
         return positions
 
     clamped_rate = max(0.0, min(1.0, spawn_rate))
-    for cell in walkable_cells:
+    for cell_x, cell_y in walkable_cells:
         if RNG.random() >= clamped_rate:
             continue
-        jitter_x = RNG.uniform(-cell.width * jitter_ratio, cell.width * jitter_ratio)
-        jitter_y = RNG.uniform(-cell.height * jitter_ratio, cell.height * jitter_ratio)
-        positions.append((int(cell.centerx + jitter_x), int(cell.centery + jitter_y)))
+        jitter_extent = cell_size * jitter_ratio
+        jitter_x = RNG.uniform(-jitter_extent, jitter_extent)
+        jitter_y = RNG.uniform(-jitter_extent, jitter_extent)
+        base_x = (cell_x * cell_size) + (cell_size / 2)
+        base_y = (cell_y * cell_size) + (cell_size / 2)
+        positions.append((int(base_x + jitter_x), int(base_y + jitter_y)))
     return positions
 
 
 def find_interior_spawn_positions(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     spawn_rate: float,
     *,
     player: Player | None = None,
@@ -53,12 +58,14 @@ def find_interior_spawn_positions(
 ) -> list[tuple[int, int]]:
     positions = _scatter_positions_on_walkable(
         walkable_cells,
+        cell_size,
         spawn_rate,
         jitter_ratio=0.35,
     )
     if not positions and spawn_rate > 0:
         positions = _scatter_positions_on_walkable(
             walkable_cells,
+            cell_size,
             spawn_rate * 1.5,
             jitter_ratio=0.35,
         )
@@ -78,7 +85,8 @@ def find_interior_spawn_positions(
 
 
 def find_nearby_offscreen_spawn_position(
-    walkable_cells: list[pygame.Rect],
+    walkable_cells: list[tuple[int, int]],
+    cell_size: int,
     *,
     player: Player | None = None,
     camera: Camera | None = None,
@@ -104,10 +112,14 @@ def find_nearby_offscreen_spawn_position(
         None if max_player_dist is None else max_player_dist * max_player_dist
     )
     for _ in range(max(1, attempts)):
-        cell = RNG.choice(walkable_cells)
-        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))
+        cell_x, cell_y = RNG.choice(walkable_cells)
+        jitter_extent = cell_size * 0.35
+        jitter_x = RNG.uniform(-jitter_extent, jitter_extent)
+        jitter_y = RNG.uniform(-jitter_extent, jitter_extent)
+        candidate = (
+            int((cell_x * cell_size) + (cell_size / 2) + jitter_x),
+            int((cell_y * cell_size) + (cell_size / 2) + jitter_y),
+        )
         if player is not None and (
             min_distance_sq is not None or max_distance_sq is not None
         ):
@@ -123,8 +135,11 @@ def find_nearby_offscreen_spawn_position(
         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)
+            cell_x, cell_y = RNG.choice(walkable_cells)
+            center = (
+                (cell_x * cell_size) + (cell_size / 2),
+                (cell_y * cell_size) + (cell_size / 2),
+            )
             if view_rect is not None and view_rect.collidepoint(center):
                 continue
             dx = center[0] - player.x
@@ -134,15 +149,19 @@ def find_nearby_offscreen_spawn_position(
                 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)
+            fallback_extent = cell_size * 0.2
+            fallback_x = RNG.uniform(-fallback_extent, fallback_extent)
+            fallback_y = RNG.uniform(-fallback_extent, fallback_extent)
+            return (int(center[0] + fallback_x), int(center[1] + fallback_y))
+    fallback_cell_x, fallback_cell_y = RNG.choice(walkable_cells)
+    fallback_center_x = (fallback_cell_x * cell_size) + (cell_size / 2)
+    fallback_center_y = (fallback_cell_y * cell_size) + (cell_size / 2)
+    fallback_extent = cell_size * 0.35
+    fallback_x = RNG.uniform(-fallback_extent, fallback_extent)
+    fallback_y = RNG.uniform(-fallback_extent, fallback_extent)
     return (
-        int(fallback_cell.centerx + fallback_x),
-        int(fallback_cell.centery + fallback_y),
+        int(fallback_center_x + fallback_x),
+        int(fallback_center_y + fallback_y),
     )
 
 

zombie_escape/level_blueprints.py

@@ -218,9 +218,10 @@ def _place_walls_grid_wire(
                 grid[y][x] = "1"
 
 
-def _place_walls_sparse(
+def _place_walls_sparse_moore(
     grid: list[list[str]],
     *,
+    density: float = SPARSE_WALL_DENSITY,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
     """Place isolated wall tiles at a low density, avoiding adjacency."""
@@ -234,7 +235,7 @@ def _place_walls_sparse(
                 continue
             if grid[y][x] != ".":
                 continue
-            if RNG.random() >= SPARSE_WALL_DENSITY:
+            if RNG.random() >= density:
                 continue
             if (
                 grid[y - 1][x] == "1"
@@ -250,11 +251,40 @@ def _place_walls_sparse(
             grid[y][x] = "1"
 
 
+def _place_walls_sparse_ortho(
+    grid: list[list[str]],
+    *,
+    density: float = SPARSE_WALL_DENSITY,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
+    """Place isolated wall tiles at a low density, avoiding orthogonal adjacency."""
+    cols, rows = len(grid[0]), len(grid)
+    forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
+    for y in range(2, rows - 2):
+        for x in range(2, cols - 2):
+            if (x, y) in forbidden:
+                continue
+            if grid[y][x] != ".":
+                continue
+            if RNG.random() >= density:
+                continue
+            if (
+                grid[y - 1][x] == "1"
+                or grid[y + 1][x] == "1"
+                or grid[y][x - 1] == "1"
+                or grid[y][x + 1] == "1"
+            ):
+                continue
+            grid[y][x] = "1"
+
 WALL_ALGORITHMS = {
     "default": _place_walls_default,
     "empty": _place_walls_empty,
     "grid_wire": _place_walls_grid_wire,
-    "sparse": _place_walls_sparse,
+    "sparse_moore": _place_walls_sparse_moore,
+    "sparse_ortho": _place_walls_sparse_ortho,
 }
 
 
@@ -321,6 +351,56 @@ def _generate_random_blueprint(
         reserved_cells.add((zx, zy))
 
     # Select and run the wall placement algorithm (after reserving spawns)
+    sparse_density = SPARSE_WALL_DENSITY
+    original_wall_algo = wall_algo
+    if wall_algo == "sparse":
+        print(
+            "WARNING: 'sparse' is deprecated. Use 'sparse_moore' instead."
+        )
+        wall_algo = "sparse_moore"
+    elif wall_algo.startswith("sparse."):
+        print(
+            "WARNING: 'sparse.<int>%' is deprecated. Use "
+            "'sparse_moore.<int>%' instead."
+        )
+        suffix = wall_algo[len("sparse.") :]
+        wall_algo = "sparse_moore"
+        if suffix.endswith("%") and suffix[:-1].isdigit():
+            percent = int(suffix[:-1])
+            if 0 <= percent <= 100:
+                sparse_density = percent / 100.0
+            else:
+                print(
+                    "WARNING: Sparse wall density must be 0-100%. "
+                    f"Got '{suffix}'. Falling back to default sparse density."
+                )
+        else:
+            print(
+                "WARNING: Invalid sparse wall format. Use "
+                "'sparse_moore.<int>%' or 'sparse_ortho.<int>%'. "
+                f"Got '{original_wall_algo}'. Falling back to default sparse density."
+            )
+    if wall_algo.startswith("sparse_moore.") or wall_algo.startswith("sparse_ortho."):
+        base, suffix = wall_algo.split(".", 1)
+        if suffix.endswith("%") and suffix[:-1].isdigit():
+            percent = int(suffix[:-1])
+            if 0 <= percent <= 100:
+                sparse_density = percent / 100.0
+                wall_algo = base
+            else:
+                print(
+                    "WARNING: Sparse wall density must be 0-100%. "
+                    f"Got '{suffix}'. Falling back to default sparse density."
+                )
+                wall_algo = base
+        else:
+            print(
+                "WARNING: Invalid sparse wall format. Use "
+                "'sparse_moore.<int>%' or 'sparse_ortho.<int>%'. "
+                f"Got '{wall_algo}'. Falling back to default sparse density."
+            )
+            wall_algo = base
+
     if wall_algo not in WALL_ALGORITHMS:
         print(
             f"WARNING: Unknown wall algorithm '{wall_algo}'. Falling back to 'default'."
@@ -328,7 +408,10 @@ def _generate_random_blueprint(
         wall_algo = "default"
 
     algo_func = WALL_ALGORITHMS[wall_algo]
-    algo_func(grid, forbidden_cells=reserved_cells)
+    if wall_algo in {"sparse_moore", "sparse_ortho"}:
+        algo_func(grid, density=sparse_density, forbidden_cells=reserved_cells)
+    else:
+        algo_func(grid, forbidden_cells=reserved_cells)
 
     steel_beams = _place_steel_beams(
         grid, chance=steel_chance, forbidden_cells=reserved_cells

zombie_escape/models.py

@@ -26,10 +26,9 @@ if TYPE_CHECKING:  # pragma: no cover - typing-only imports
 class LevelLayout:
     """Container for level layout rectangles and cell sets."""
 
-    outer_rect: tuple[int, int, int, int]
-    inner_rect: tuple[int, int, int, int]
-    outside_rects: list[pygame.Rect]
-    walkable_cells: list[pygame.Rect]
+    field_rect: pygame.Rect
+    outside_cells: set[tuple[int, int]]
+    walkable_cells: list[tuple[int, int]]
     outer_wall_cells: set[tuple[int, int]]
     wall_cells: set[tuple[int, int]]
     fall_spawn_cells: set[tuple[int, int]]
@@ -106,6 +105,8 @@ class ProgressState:
     falling_zombies: list[FallingZombie]
     falling_spawn_carry: int
     dust_rings: list[DustRing]
+    player_wall_target_cell: tuple[int, int] | None
+    player_wall_target_ttl: int
 
 
 @dataclass

zombie_escape/render.py

@@ -807,11 +807,16 @@ def _draw_play_area(
     camera: Camera,
     assets: RenderAssets,
     palette: Any,
-    outer_rect: tuple[int, int, int, int],
-    outside_rects: list[pygame.Rect],
+    field_rect: pygame.Rect,
+    outside_cells: set[tuple[int, int]],
     fall_spawn_cells: set[tuple[int, int]],
 ) -> tuple[int, int, int, int, set[tuple[int, int]]]:
-    xs, ys, xe, ye = outer_rect
+    xs, ys, xe, ye = (
+        field_rect.left,
+        field_rect.top,
+        field_rect.right,
+        field_rect.bottom,
+    )
     xs //= assets.internal_wall_grid_snap
     ys //= assets.internal_wall_grid_snap
     xe //= assets.internal_wall_grid_snap
@@ -826,15 +831,6 @@ def _draw_play_area(
     play_area_screen_rect = camera.apply_rect(play_area_rect)
     pygame.draw.rect(screen, palette.floor_primary, play_area_screen_rect)
 
-    outside_cells = {
-        (r.x // assets.internal_wall_grid_snap, r.y // assets.internal_wall_grid_snap)
-        for r in outside_rects
-    }
-    for rect_obj in outside_rects:
-        sr = camera.apply_rect(rect_obj)
-        if sr.colliderect(screen.get_rect()):
-            pygame.draw.rect(screen, palette.outside, sr)
-
     view_world = pygame.Rect(
         -camera.camera.x,
         -camera.camera.y,
@@ -855,6 +851,19 @@ def _draw_play_area(
     for y in range(start_y, end_y):
         for x in range(start_x, end_x):
             if (x, y) in outside_cells:
+                lx, ly = (
+                    x * assets.internal_wall_grid_snap,
+                    y * assets.internal_wall_grid_snap,
+                )
+                r = pygame.Rect(
+                    lx,
+                    ly,
+                    assets.internal_wall_grid_snap,
+                    assets.internal_wall_grid_snap,
+                )
+                sr = camera.apply_rect(r)
+                if sr.colliderect(screen.get_rect()):
+                    pygame.draw.rect(screen, palette.outside, sr)
                 continue
             use_secondary = ((x // 2) + (y // 2)) % 2 == 0
             if (x, y) in fall_spawn_cells:
@@ -966,11 +975,15 @@ def _draw_entity_shadows(
     *,
     light_source_pos: tuple[int, int] | None,
     exclude_car: Car | None,
+    outside_cells: set[tuple[int, int]] | None,
+    cell_size: int,
     shadow_radius: int = int(ZOMBIE_RADIUS * ENTITY_SHADOW_RADIUS_MULT),
     alpha: int = ENTITY_SHADOW_ALPHA,
 ) -> bool:
     if light_source_pos is None or shadow_radius <= 0:
         return False
+    if cell_size <= 0:
+        outside_cells = None
     shadow_surface = _get_shadow_circle_surface(
         shadow_radius,
         alpha,
@@ -990,6 +1003,13 @@ def _draw_entity_shadows(
                 continue
         if not isinstance(entity, (Zombie, Survivor, Car)):
             continue
+        if outside_cells:
+            cell = (
+                int(entity.rect.centerx // cell_size),
+                int(entity.rect.centery // cell_size),
+            )
+            if cell in outside_cells:
+                continue
         cx, cy = entity.rect.center
         dx = cx - px
         dy = cy - py
@@ -1022,6 +1042,8 @@ def _draw_single_entity_shadow(
     *,
     entity: pygame.sprite.Sprite | None,
     light_source_pos: tuple[int, int] | None,
+    outside_cells: set[tuple[int, int]] | None,
+    cell_size: int,
     shadow_radius: int,
     alpha: int,
     edge_softness: float = ENTITY_SHADOW_EDGE_SOFTNESS,
@@ -1033,6 +1055,13 @@ def _draw_single_entity_shadow(
         or shadow_radius <= 0
     ):
         return False
+    if outside_cells and cell_size > 0:
+        cell = (
+            int(entity.rect.centerx // cell_size),
+            int(entity.rect.centery // cell_size),
+        )
+        if cell in outside_cells:
+            return False
     shadow_surface = _get_shadow_circle_surface(
         shadow_radius,
         alpha,
@@ -1464,8 +1493,8 @@ def draw(
 
     camera = game_data.camera
     stage = game_data.stage
-    outer_rect = game_data.layout.outer_rect
-    outside_rects = game_data.layout.outside_rects or []
+    field_rect = game_data.layout.field_rect
+    outside_cells = game_data.layout.outside_cells
     all_sprites = game_data.groups.all_sprites
     fog_surfaces = game_data.fog
     footprints = state.footprints
@@ -1493,8 +1522,8 @@ def draw(
         camera,
         assets,
         palette,
-        outer_rect,
-        outside_rects,
+        field_rect,
+        outside_cells,
         game_data.layout.fall_spawn_cells,
     )
     shadow_layer = _get_shadow_layer(screen.get_size())
@@ -1520,6 +1549,8 @@ def draw(
         all_sprites,
         light_source_pos=fov_target.rect.center if fov_target else None,
         exclude_car=active_car if player.in_car else None,
+        outside_cells=outside_cells,
+        cell_size=game_data.cell_size,
     )
     player_shadow_alpha = max(1, int(ENTITY_SHADOW_ALPHA * PLAYER_SHADOW_ALPHA_MULT))
     player_shadow_radius = int(ZOMBIE_RADIUS * PLAYER_SHADOW_RADIUS_MULT)
@@ -1529,6 +1560,8 @@ def draw(
             camera,
             entity=active_car,
             light_source_pos=fov_target.rect.center if fov_target else None,
+            outside_cells=outside_cells,
+            cell_size=game_data.cell_size,
             shadow_radius=player_shadow_radius,
             alpha=player_shadow_alpha,
         )
@@ -1538,6 +1571,8 @@ def draw(
             camera,
             entity=player,
             light_source_pos=fov_target.rect.center if fov_target else None,
+            outside_cells=outside_cells,
+            cell_size=game_data.cell_size,
             shadow_radius=player_shadow_radius,
             alpha=player_shadow_alpha,
         )