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

zombie_escape/entities_constants.py

@@ -11,6 +11,14 @@ PLAYER_SPEED = 1.4
 FOV_RADIUS = 124  # approximate legacy FOV (80) * 1.55 cap
 BUDDY_RADIUS = HUMANOID_RADIUS
 BUDDY_FOLLOW_SPEED = PLAYER_SPEED * 0.7
+HUMANOID_WALL_BUMP_FRAMES = 7
+
+# --- Jump settings ---
+PLAYER_JUMP_RANGE = 15  # px (enough to clear one 50px tile)
+SURVIVOR_JUMP_RANGE = int(PLAYER_JUMP_RANGE * 0.7)  # px
+JUMP_DURATION_MS = 200
+JUMP_SCALE_MAX = 0.15
+JUMP_SHADOW_OFFSET = 5
 
 # --- Survivor settings (Stage 4) ---
 SURVIVOR_RADIUS = HUMANOID_RADIUS
@@ -38,19 +46,24 @@ ZOMBIE_SEPARATION_DISTANCE = ZOMBIE_RADIUS * 2.2
 ZOMBIE_AGING_DURATION_FRAMES = FPS * 60 * 6  # ~6 minutes at target framerate
 ZOMBIE_AGING_MIN_SPEED_RATIO = 0.3
 ZOMBIE_TRACKER_SCENT_RADIUS = 70
-ZOMBIE_TRACKER_SCAN_RADIUS_MULTIPLIER = 2
+ZOMBIE_TRACKER_FAR_SCENT_RADIUS = 140
+ZOMBIE_TRACKER_NEWER_FOOTPRINT_MS = 5000
 ZOMBIE_TRACKER_SCENT_TOP_K = 3
 ZOMBIE_TRACKER_SCAN_INTERVAL_MS = int(1000 * 30 / FPS)
 ZOMBIE_TRACKER_WANDER_INTERVAL_MS = 2500
-ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE = 24
-ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG = 45
-ZOMBIE_WALL_FOLLOW_PROBE_STEP = 2.0
-ZOMBIE_WALL_FOLLOW_TARGET_GAP = 4.0
-ZOMBIE_WALL_FOLLOW_LOST_WALL_MS = 2500
+ZOMBIE_TRACKER_CROWD_BAND_WIDTH = 50
+ZOMBIE_TRACKER_CROWD_BAND_LENGTH = 50
+ZOMBIE_TRACKER_CROWD_COUNT = 5
+ZOMBIE_TRACKER_RELOCK_DELAY_MS = 3000
+ZOMBIE_WALL_HUG_SENSOR_DISTANCE = 24
+ZOMBIE_WALL_HUG_PROBE_ANGLE_DEG = 45
+ZOMBIE_WALL_HUG_PROBE_STEP = 2.0
+ZOMBIE_WALL_HUG_TARGET_GAP = 4.0
+ZOMBIE_WALL_HUG_LOST_WALL_MS = 2500
 
 # --- Car and fuel settings ---
-CAR_WIDTH = 15
-CAR_HEIGHT = 25
+CAR_WIDTH = 16
+CAR_HEIGHT = 24
 CAR_SPEED = 2
 CAR_HEALTH = 20
 CAR_WALL_DAMAGE = 1
@@ -62,6 +75,7 @@ INTERNAL_WALL_HEALTH = 40 * 100
 INTERNAL_WALL_BEVEL_DEPTH = 6
 STEEL_BEAM_HEALTH = int(INTERNAL_WALL_HEALTH * 1.5)
 PLAYER_WALL_DAMAGE = 100
+BUDDY_WALL_DAMAGE = int(PLAYER_WALL_DAMAGE * 0.7)
 ZOMBIE_WALL_DAMAGE = 1
 
 __all__ = [
@@ -71,6 +85,7 @@ __all__ = [
     "FOV_RADIUS",
     "BUDDY_RADIUS",
     "BUDDY_FOLLOW_SPEED",
+    "HUMANOID_WALL_BUMP_FRAMES",
     "SURVIVOR_RADIUS",
     "SURVIVOR_APPROACH_RADIUS",
     "SURVIVOR_APPROACH_SPEED",
@@ -90,15 +105,20 @@ __all__ = [
     "ZOMBIE_AGING_DURATION_FRAMES",
     "ZOMBIE_AGING_MIN_SPEED_RATIO",
     "ZOMBIE_TRACKER_SCENT_RADIUS",
-    "ZOMBIE_TRACKER_SCAN_RADIUS_MULTIPLIER",
+    "ZOMBIE_TRACKER_FAR_SCENT_RADIUS",
+    "ZOMBIE_TRACKER_NEWER_FOOTPRINT_MS",
     "ZOMBIE_TRACKER_SCENT_TOP_K",
     "ZOMBIE_TRACKER_SCAN_INTERVAL_MS",
     "ZOMBIE_TRACKER_WANDER_INTERVAL_MS",
-    "ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE",
-    "ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG",
-    "ZOMBIE_WALL_FOLLOW_PROBE_STEP",
-    "ZOMBIE_WALL_FOLLOW_TARGET_GAP",
-    "ZOMBIE_WALL_FOLLOW_LOST_WALL_MS",
+    "ZOMBIE_TRACKER_CROWD_BAND_WIDTH",
+    "ZOMBIE_TRACKER_CROWD_BAND_LENGTH",
+    "ZOMBIE_TRACKER_CROWD_COUNT",
+    "ZOMBIE_TRACKER_RELOCK_DELAY_MS",
+    "ZOMBIE_WALL_HUG_SENSOR_DISTANCE",
+    "ZOMBIE_WALL_HUG_PROBE_ANGLE_DEG",
+    "ZOMBIE_WALL_HUG_PROBE_STEP",
+    "ZOMBIE_WALL_HUG_TARGET_GAP",
+    "ZOMBIE_WALL_HUG_LOST_WALL_MS",
     "CAR_WIDTH",
     "CAR_HEIGHT",
     "CAR_SPEED",
@@ -110,5 +130,6 @@ __all__ = [
     "INTERNAL_WALL_BEVEL_DEPTH",
     "STEEL_BEAM_HEALTH",
     "PLAYER_WALL_DAMAGE",
+    "BUDDY_WALL_DAMAGE",
     "ZOMBIE_WALL_DAMAGE",
 ]

zombie_escape/export_images.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+import pygame
+
+from .entities import SteelBeam
+from .entities_constants import (
+    BUDDY_RADIUS,
+    CAR_HEIGHT,
+    CAR_WIDTH,
+    FLASHLIGHT_HEIGHT,
+    FLASHLIGHT_WIDTH,
+    FUEL_CAN_HEIGHT,
+    FUEL_CAN_WIDTH,
+    INTERNAL_WALL_BEVEL_DEPTH,
+    PLAYER_RADIUS,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
+    STEEL_BEAM_HEALTH,
+    SURVIVOR_RADIUS,
+    ZOMBIE_RADIUS,
+)
+from .level_constants import DEFAULT_TILE_SIZE
+from .render_assets import (
+    build_car_directional_surfaces,
+    build_car_surface,
+    build_flashlight_surface,
+    build_fuel_can_surface,
+    build_player_directional_surfaces,
+    build_rubble_wall_surface,
+    build_shoes_surface,
+    build_survivor_directional_surfaces,
+    build_zombie_directional_surfaces,
+    draw_humanoid_hand,
+    draw_humanoid_nose,
+    paint_car_surface,
+    paint_wall_surface,
+    resolve_car_color,
+    resolve_wall_colors,
+    RUBBLE_ROTATION_DEG,
+)
+from .colors import FALL_ZONE_FLOOR_PRIMARY
+from .render_constants import (
+    FALLING_ZOMBIE_COLOR,
+    PITFALL_ABYSS_COLOR,
+    PITFALL_EDGE_DEPTH_OFFSET,
+    PITFALL_EDGE_METAL_COLOR,
+    PITFALL_EDGE_STRIPE_COLOR,
+    PITFALL_EDGE_STRIPE_SPACING,
+    PITFALL_SHADOW_RIM_COLOR,
+    PITFALL_SHADOW_WIDTH,
+    ZOMBIE_NOSE_COLOR,
+)
+
+__all__ = ["export_images"]
+
+
+def _ensure_pygame_ready() -> None:
+    if not pygame.get_init():
+        pygame.init()
+    if not pygame.display.get_init():
+        pygame.display.init()
+    if pygame.display.get_surface() is None:
+        flags = pygame.HIDDEN if hasattr(pygame, "HIDDEN") else 0
+        pygame.display.set_mode((1, 1), flags=flags)
+
+
+def _save_surface(surface: pygame.Surface, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    pygame.image.save(surface, str(path))
+
+
+def _pick_directional_surface(
+    surfaces: list[pygame.Surface], *, bin_index: int = 0
+) -> pygame.Surface:
+    if not surfaces:
+        return pygame.Surface((1, 1), pygame.SRCALPHA)
+    return surfaces[bin_index % len(surfaces)]
+
+
+def _build_pitfall_tile(cell_size: int) -> pygame.Surface:
+    surface = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    rect = surface.get_rect()
+    pygame.draw.rect(surface, PITFALL_ABYSS_COLOR, rect)
+
+    for i in range(PITFALL_SHADOW_WIDTH):
+        t = i / (PITFALL_SHADOW_WIDTH - 1.0)
+        color = tuple(
+            int(PITFALL_SHADOW_RIM_COLOR[j] * (1.0 - t) + PITFALL_ABYSS_COLOR[j] * t)
+            for j in range(3)
+        )
+        pygame.draw.line(
+            surface,
+            color,
+            (rect.x + i, rect.y),
+            (rect.x + i, rect.bottom - 1),
+        )
+        pygame.draw.line(
+            surface,
+            color,
+            (rect.right - 1 - i, rect.y),
+            (rect.right - 1 - i, rect.bottom - 1),
+        )
+
+    edge_height = max(1, INTERNAL_WALL_BEVEL_DEPTH - PITFALL_EDGE_DEPTH_OFFSET)
+    pygame.draw.rect(surface, PITFALL_EDGE_METAL_COLOR, (rect.x, rect.y, rect.w, edge_height))
+    for sx in range(rect.x - edge_height, rect.right, PITFALL_EDGE_STRIPE_SPACING):
+        pygame.draw.line(
+            surface,
+            PITFALL_EDGE_STRIPE_COLOR,
+            (max(rect.x, sx), rect.y),
+            (min(rect.right - 1, sx + edge_height), rect.y + edge_height - 1),
+            width=2,
+        )
+
+    return surface
+
+
+def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE) -> list[Path]:
+    _ensure_pygame_ready()
+
+    saved: list[Path] = []
+    out = Path(output_dir)
+
+    player = _pick_directional_surface(
+        build_player_directional_surfaces(radius=PLAYER_RADIUS),
+        bin_index=0,
+    )
+    player_path = out / "player.png"
+    _save_surface(player, player_path)
+    saved.append(player_path)
+
+    zombie_base = _pick_directional_surface(
+        build_zombie_directional_surfaces(radius=ZOMBIE_RADIUS, draw_hands=False),
+        bin_index=0,
+    )
+    zombie_normal_path = out / "zombie-normal.png"
+    _save_surface(zombie_base, zombie_normal_path)
+    saved.append(zombie_normal_path)
+
+    tracker = zombie_base.copy()
+    draw_humanoid_nose(
+        tracker,
+        radius=ZOMBIE_RADIUS,
+        angle_rad=0.0,
+        color=ZOMBIE_NOSE_COLOR,
+    )
+    tracker_path = out / "zombie-tracker.png"
+    _save_surface(tracker, tracker_path)
+    saved.append(tracker_path)
+
+    wall_hugging = zombie_base.copy()
+    draw_humanoid_hand(
+        wall_hugging,
+        radius=ZOMBIE_RADIUS,
+        angle_rad=math.pi / 2.0,
+        color=ZOMBIE_NOSE_COLOR,
+    )
+    wall_path = out / "zombie-wall.png"
+    _save_surface(wall_hugging, wall_path)
+    saved.append(wall_path)
+
+    buddy = _pick_directional_surface(
+        build_survivor_directional_surfaces(
+            radius=BUDDY_RADIUS,
+            is_buddy=True,
+            draw_hands=True,
+        ),
+        bin_index=0,
+    )
+    buddy_path = out / "buddy.png"
+    _save_surface(buddy, buddy_path)
+    saved.append(buddy_path)
+
+    survivor = _pick_directional_surface(
+        build_survivor_directional_surfaces(
+            radius=SURVIVOR_RADIUS,
+            is_buddy=False,
+            draw_hands=False,
+        ),
+        bin_index=0,
+    )
+    survivor_path = out / "survivor.png"
+    _save_surface(survivor, survivor_path)
+    saved.append(survivor_path)
+
+    car_surface = build_car_surface(CAR_WIDTH, CAR_HEIGHT)
+    car_color = resolve_car_color(health_ratio=1.0, appearance="default")
+    paint_car_surface(
+        car_surface,
+        width=CAR_WIDTH,
+        height=CAR_HEIGHT,
+        color=car_color,
+    )
+    car = _pick_directional_surface(build_car_directional_surfaces(car_surface), bin_index=0)
+    car_path = out / "car.png"
+    _save_surface(car, car_path)
+    saved.append(car_path)
+
+    fuel = build_fuel_can_surface(FUEL_CAN_WIDTH, FUEL_CAN_HEIGHT)
+    fuel_path = out / "fuel.png"
+    _save_surface(fuel, fuel_path)
+    saved.append(fuel_path)
+
+    flashlight = build_flashlight_surface(FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT)
+    flashlight_path = out / "flashlight.png"
+    _save_surface(flashlight, flashlight_path)
+    saved.append(flashlight_path)
+
+    shoes = build_shoes_surface(SHOES_WIDTH, SHOES_HEIGHT)
+    shoes_path = out / "shoes.png"
+    _save_surface(shoes, shoes_path)
+    saved.append(shoes_path)
+
+    beam = SteelBeam(0, 0, cell_size, health=STEEL_BEAM_HEALTH, palette=None)
+    beam_path = out / "steel-beam.png"
+    _save_surface(beam.image, beam_path)
+    saved.append(beam_path)
+
+    inner_wall = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    inner_fill, inner_border = resolve_wall_colors(
+        health_ratio=1.0,
+        palette_category="inner_wall",
+        palette=None,
+    )
+    paint_wall_surface(
+        inner_wall,
+        fill_color=inner_fill,
+        border_color=inner_border,
+        bevel_depth=INTERNAL_WALL_BEVEL_DEPTH,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+    inner_wall_path = out / "wall-inner.png"
+    _save_surface(inner_wall, inner_wall_path)
+    saved.append(inner_wall_path)
+
+    rubble_wall = build_rubble_wall_surface(
+        cell_size,
+        fill_color=inner_fill,
+        border_color=inner_border,
+        angle_deg=RUBBLE_ROTATION_DEG,
+    )
+    rubble_wall_path = out / "wall-rubble.png"
+    _save_surface(rubble_wall, rubble_wall_path)
+    saved.append(rubble_wall_path)
+
+    outer_wall = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    outer_fill, outer_border = resolve_wall_colors(
+        health_ratio=1.0,
+        palette_category="outer_wall",
+        palette=None,
+    )
+    paint_wall_surface(
+        outer_wall,
+        fill_color=outer_fill,
+        border_color=outer_border,
+        bevel_depth=0,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+    outer_wall_path = out / "wall-outer.png"
+    _save_surface(outer_wall, outer_wall_path)
+    saved.append(outer_wall_path)
+
+    pitfall = _build_pitfall_tile(cell_size)
+    pitfall_path = out / "pitfall.png"
+    _save_surface(pitfall, pitfall_path)
+    saved.append(pitfall_path)
+
+    fall_radius = max(1, int(ZOMBIE_RADIUS))
+    fall_size = fall_radius * 2
+    falling = pygame.Surface((fall_size, fall_size), pygame.SRCALPHA)
+    pygame.draw.circle(
+        falling,
+        FALLING_ZOMBIE_COLOR,
+        (fall_radius, fall_radius),
+        fall_radius,
+    )
+    falling_path = out / "falling-zombie.png"
+    _save_surface(falling, falling_path)
+    saved.append(falling_path)
+
+    fall_zone = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
+    fall_zone.fill(FALL_ZONE_FLOOR_PRIMARY)
+    fall_zone_path = out / "fall-zone.png"
+    _save_surface(fall_zone, fall_zone_path)
+    saved.append(fall_zone_path)
+
+    return saved

zombie_escape/gameplay/__init__.py

@@ -5,7 +5,7 @@
 from .ambient import sync_ambient_palette_with_flashlights
 from .footprints import get_shrunk_sprite, update_footprints
 from .interactions import check_interactions
-from .layout import generate_level_from_blueprint
+from .layout import MapGenerationError, generate_level_from_blueprint
 from .movement import process_player_input, update_entities
 from .spawn import (
     maintain_waiting_car_supply,
@@ -43,6 +43,7 @@ from .utils import (
 )
 
 __all__ = [
+    "MapGenerationError",
     "generate_level_from_blueprint",
     "place_new_car",
     "place_fuel_can",

zombie_escape/gameplay/constants.py

@@ -17,6 +17,9 @@ FOOTPRINT_MAX = 320
 MAX_ZOMBIES = 400
 ZOMBIE_SPAWN_PLAYER_BUFFER = 230
 ZOMBIE_TRACKER_AGING_DURATION_FRAMES = ZOMBIE_AGING_DURATION_FRAMES
+FALLING_ZOMBIE_PRE_FX_MS = 600
+FALLING_ZOMBIE_DURATION_MS = 450
+FALLING_ZOMBIE_DUST_DURATION_MS = 220
 
 # --- Car and fuel settings ---
 CAR_ZOMBIE_DAMAGE = 1
@@ -34,6 +37,9 @@ __all__ = [
     "MAX_ZOMBIES",
     "ZOMBIE_SPAWN_PLAYER_BUFFER",
     "ZOMBIE_TRACKER_AGING_DURATION_FRAMES",
+    "FALLING_ZOMBIE_PRE_FX_MS",
+    "FALLING_ZOMBIE_DURATION_MS",
+    "FALLING_ZOMBIE_DUST_DURATION_MS",
     "CAR_ZOMBIE_DAMAGE",
     "FUEL_HINT_DURATION_MS",
     "OUTER_WALL_HEALTH",

zombie_escape/gameplay/footprints.py

@@ -26,6 +26,10 @@ def get_shrunk_sprite(
 
     new_sprite = pygame.sprite.Sprite()
     new_sprite.rect = rect
+    if hasattr(sprite_obj, "radius"):
+        base_radius = getattr(sprite_obj, "radius", None)
+        if base_radius is not None:
+            new_sprite.radius = base_radius * min(scale_x, scale_y)
 
     return new_sprite
 

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