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

zombie_escape/models.py

@@ -26,19 +26,20 @@ 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]]
+    pitfall_cells: set[tuple[int, int]]
+    car_walkable_cells: set[tuple[int, int]]
     fall_spawn_cells: set[tuple[int, int]]
     bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]]
 
 
 @dataclass
 class FallingZombie:
-    """Represents a zombie falling toward a target position."""
+    """Represents a zombie falling toward a target position or into a pit."""
 
     start_pos: tuple[int, int]
     target_pos: tuple[int, int]
@@ -47,8 +48,9 @@ class FallingZombie:
     fall_duration_ms: int
     dust_duration_ms: int
     tracker: bool
-    wall_follower: bool
+    wall_hugging: bool
     dust_started: bool = False
+    mode: str = "spawn"  # "spawn" (falling in) or "pitfall" (falling out)
 
 
 @dataclass
@@ -103,9 +105,12 @@ class ProgressState:
     last_zombie_spawn_time: int
     dawn_carbonized: bool
     debug_mode: bool
+    show_fps: bool
     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
@@ -165,12 +170,14 @@ class Stage:
     interior_fall_spawn_weight: float = 0.0
     fall_spawn_zones: list[tuple[int, int, int, int]] = field(default_factory=list)
     fall_spawn_floor_ratio: float = 0.0
+    pitfall_density: float = 0.0
     zombie_tracker_ratio: float = 0.0
-    zombie_wall_follower_ratio: float = 0.0
+    zombie_wall_hugging_ratio: float = 0.0
     zombie_normal_ratio: float = 1.0
     zombie_aging_duration_frames: int = ZOMBIE_AGING_DURATION_FRAMES
     waiting_car_target_count: int = 1
     wall_algorithm: str = "default"
+    wall_rubble_ratio: float = 0.0
 
     @property
     def name(self) -> str:

zombie_escape/render.py

@@ -34,6 +34,8 @@ from .entities_constants import (
     FLASHLIGHT_WIDTH,
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
+    INTERNAL_WALL_BEVEL_DEPTH,
+    JUMP_SHADOW_OFFSET,
     SHOES_HEIGHT,
     SHOES_WIDTH,
     ZOMBIE_RADIUS,
@@ -63,6 +65,11 @@ from .render_constants import (
     FALLING_ZOMBIE_COLOR,
     FLASHLIGHT_FOG_SCALE_ONE,
     FLASHLIGHT_FOG_SCALE_TWO,
+    PITFALL_ABYSS_COLOR,
+    PITFALL_EDGE_DEPTH_OFFSET,
+    PITFALL_EDGE_METAL_COLOR,
+    PITFALL_EDGE_STRIPE_COLOR,
+    PITFALL_EDGE_STRIPE_SPACING,
     PLAYER_SHADOW_ALPHA_MULT,
     PLAYER_SHADOW_RADIUS_MULT,
     SHADOW_MIN_RATIO,
@@ -314,9 +321,7 @@ def draw_level_overview(
     if flashlights:
         for flashlight in flashlights:
             if flashlight.alive():
-                pygame.draw.rect(
-                    surface, YELLOW, flashlight.rect, border_radius=2
-                )
+                pygame.draw.rect(surface, YELLOW, flashlight.rect, border_radius=2)
                 pygame.draw.rect(
                     surface, BLACK, flashlight.rect, width=2, border_radius=2
                 )
@@ -587,6 +592,8 @@ def _draw_fall_whirlwind(
     camera: Camera,
     center: tuple[int, int],
     progress: float,
+    *,
+    scale: float = 1.0,
 ) -> None:
     base_alpha = FALLING_WHIRLWIND_COLOR[3]
     alpha = int(max(0, min(255, base_alpha * (1.0 - progress))))
@@ -598,8 +605,9 @@ def _draw_fall_whirlwind(
         FALLING_WHIRLWIND_COLOR[2],
         alpha,
     )
-    swirl_radius = max(2, int(ZOMBIE_RADIUS * 1.1))
-    offset = max(1, int(ZOMBIE_RADIUS * 0.6))
+    safe_scale = max(0.4, scale)
+    swirl_radius = max(2, int(ZOMBIE_RADIUS * 1.1 * safe_scale))
+    offset = max(1, int(ZOMBIE_RADIUS * 0.6 * safe_scale))
     size = swirl_radius * 4
     swirl = pygame.Surface((size, size), pygame.SRCALPHA)
     cx = cy = size // 2
@@ -632,22 +640,42 @@ def _draw_falling_fx(
         if now < fall_start:
             if flashlight_count > 0 and pre_fx_ms > 0:
                 fx_progress = max(0.0, min(1.0, (now - fall.started_at_ms) / pre_fx_ms))
-                _draw_fall_whirlwind(screen, camera, fall.target_pos, fx_progress)
+                # Make the premonition grow with the impending drop scale.
+                pre_scale = 1.0 + (0.9 * fx_progress)
+                _draw_fall_whirlwind(
+                    screen,
+                    camera,
+                    fall.start_pos,
+                    fx_progress,
+                    scale=pre_scale,
+                )
             continue
         if now >= impact_at:
             continue
         fall_progress = max(0.0, min(1.0, (now - fall_start) / fall_duration_ms))
-        eased = 1.0 - (1.0 - fall_progress) * (1.0 - fall_progress)
-        x = fall.target_pos[0]
-        y = int(fall.start_pos[1] + (fall.target_pos[1] - fall.start_pos[1]) * eased)
-        world_rect = pygame.Rect(0, 0, ZOMBIE_RADIUS * 2, ZOMBIE_RADIUS * 2)
-        world_rect.center = (x, y)
+
+        if getattr(fall, "mode", "spawn") == "pitfall":
+            scale = 1.0 - fall_progress
+            scale = scale * scale
+            y_offset = 0.0
+        else:
+            eased = 1.0 - (1.0 - fall_progress) * (1.0 - fall_progress)
+            scale = 2.0 - (1.0 * eased)
+            # Add an extra vertical drop from above (1.5x wall depth)
+            y_offset = -INTERNAL_WALL_BEVEL_DEPTH * 1.5 * (1.0 - eased)
+
+        radius = ZOMBIE_RADIUS * scale
+        cx = fall.target_pos[0]
+        cy = fall.target_pos[1] + ZOMBIE_RADIUS - radius + y_offset
+
+        world_rect = pygame.Rect(0, 0, radius * 2, radius * 2)
+        world_rect.center = (int(cx), int(cy))
         screen_rect = camera.apply_rect(world_rect)
         pygame.draw.circle(
             screen,
             FALLING_ZOMBIE_COLOR,
             screen_rect.center,
-            ZOMBIE_RADIUS,
+            max(1, int(screen_rect.width / 2)),
         )
 
     for ring in list(dust_rings):
@@ -725,6 +753,7 @@ def _draw_status_bar(
     debug_mode: bool = False,
     zombie_group: sprite.Group | None = None,
     falling_spawn_carry: int | None = None,
+    show_fps: bool = False,
     fps: float | None = None,
 ) -> None:
     """Render a compact status bar with current config flags and stage info."""
@@ -766,14 +795,12 @@ def _draw_status_bar(
             zombies = [z for z in zombie_group if z.alive()]
             total = len(zombies)
             tracker = sum(1 for z in zombies if z.tracker)
-            wall = sum(1 for z in zombies if z.wall_follower)
+            wall = sum(1 for z in zombies if z.wall_hugging)
             normal = max(0, total - tracker - wall)
-            parts.append(f"Z:{total} N:{normal} T:{tracker} W:{wall}")
+            debug_counts = f"Z:{total} N:{normal} T:{tracker} W:{wall}"
             if falling_spawn_carry is not None:
-                parts.append(f"C:{max(0, falling_spawn_carry)}")
-        if fps is not None:
-            parts.append(f"FPS:{fps:.1f}")
-
+                debug_counts = f"{debug_counts} C:{max(0, falling_spawn_carry)}"
+            parts.append(debug_counts)
     status_text = " | ".join(parts)
     color = LIGHT_GRAY
 
@@ -790,7 +817,7 @@ def _draw_status_bar(
                 right=bar_rect.right - 12, centery=bar_rect.centery
             )
             screen.blit(seed_surface, seed_rect)
-        if debug_mode and fps is not None:
+        if show_fps and fps is not None:
             fps_text = f"FPS:{fps:.1f}"
             fps_surface = font.render(fps_text, False, LIGHT_GRAY)
             fps_rect = fps_surface.get_rect(
@@ -807,11 +834,17 @@ 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]],
+    pitfall_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 +859,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,7 +879,57 @@ 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
+
+            if (x, y) in pitfall_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 not sr.colliderect(screen.get_rect()):
+                    continue
+                pygame.draw.rect(screen, PITFALL_ABYSS_COLOR, sr)
+
+                if (x, y - 1) not in pitfall_cells:
+                    edge_h = max(
+                        1, INTERNAL_WALL_BEVEL_DEPTH - PITFALL_EDGE_DEPTH_OFFSET
+                    )
+                    pygame.draw.rect(
+                        screen, PITFALL_EDGE_METAL_COLOR, (sr.x, sr.y, sr.w, edge_h)
+                    )
+                    for sx in range(
+                        sr.x - edge_h, sr.right, PITFALL_EDGE_STRIPE_SPACING
+                    ):
+                        pygame.draw.line(
+                            screen,
+                            PITFALL_EDGE_STRIPE_COLOR,
+                            (max(sr.x, sx), sr.y),
+                            (min(sr.right - 1, sx + edge_h), sr.y + edge_h - 1),
+                            width=2,
+                        )
+
                 continue
+
             use_secondary = ((x // 2) + (y // 2)) % 2 == 0
             if (x, y) in fall_spawn_cells:
                 color = (
@@ -966,11 +1040,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 +1068,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
@@ -1001,8 +1086,13 @@ def _draw_entity_shadows(
         else:
             offset_x = 0.0
             offset_y = 0.0
+
+        jump_dy = 0.0
+        if getattr(entity, "is_jumping", False):
+            jump_dy = JUMP_SHADOW_OFFSET
+
         shadow_rect = shadow_surface.get_rect(
-            center=(int(cx + offset_x), int(cy + offset_y))
+            center=(int(cx + offset_x), int(cy + offset_y + jump_dy))
         )
         shadow_screen_rect = camera.apply_rect(shadow_rect)
         if not shadow_screen_rect.colliderect(screen_rect):
@@ -1022,6 +1112,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 +1125,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,
@@ -1052,8 +1151,13 @@ def _draw_single_entity_shadow(
     else:
         offset_x = 0.0
         offset_y = 0.0
+
+    jump_dy = 0.0
+    if getattr(entity, "is_jumping", False):
+        jump_dy = JUMP_SHADOW_OFFSET
+
     shadow_rect = shadow_surface.get_rect(
-        center=(int(cx + offset_x), int(cy + offset_y))
+        center=(int(cx + offset_x), int(cy + offset_y + jump_dy))
     )
     shadow_screen_rect = camera.apply_rect(shadow_rect)
     if not shadow_screen_rect.colliderect(screen_rect):
@@ -1464,8 +1568,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,9 +1597,10 @@ def draw(
         camera,
         assets,
         palette,
-        outer_rect,
-        outside_rects,
+        field_rect,
+        outside_cells,
         game_data.layout.fall_spawn_cells,
+        game_data.layout.pitfall_cells,
     )
     shadow_layer = _get_shadow_layer(screen.get_size())
     shadow_layer.fill((0, 0, 0, 0))
@@ -1520,6 +1625,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 +1636,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 +1647,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,
         )
@@ -1625,6 +1736,7 @@ def draw(
         debug_mode=state.debug_mode,
         zombie_group=zombie_group,
         falling_spawn_carry=state.falling_spawn_carry,
+        show_fps=state.show_fps,
         fps=fps,
     )
     if do_flip: