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

zombie_escape/gameplay/layout.py

@@ -1,22 +1,29 @@
 from __future__ import annotations
 
+import random
 from typing import Any
 
 import pygame
 
 from ..colors import get_environment_palette
-from ..entities import SteelBeam, Wall
-from ..entities_constants import INTERNAL_WALL_HEALTH, STEEL_BEAM_HEALTH
+from ..entities import RubbleWall, SteelBeam, Wall
+from ..entities_constants import (
+    INTERNAL_WALL_BEVEL_DEPTH,
+    INTERNAL_WALL_HEALTH,
+    STEEL_BEAM_HEALTH,
+)
+from ..render_assets import RUBBLE_ROTATION_DEG
 from .constants import OUTER_WALL_HEALTH
-from ..level_blueprints import choose_blueprint
+from ..level_blueprints import MapGenerationError, choose_blueprint
 from ..models import GameData
 from ..rng import get_rng
 
-__all__ = ["generate_level_from_blueprint"]
+__all__ = ["generate_level_from_blueprint", "MapGenerationError"]
 
 RNG = get_rng()
 
 
+
 def _rect_for_cell(x_idx: int, y_idx: int, cell_size: int) -> pygame.Rect:
     return pygame.Rect(
         x_idx * cell_size,
@@ -62,17 +69,22 @@ def generate_level_from_blueprint(
         cols=stage.grid_cols,
         rows=stage.grid_rows,
         wall_algo=stage.wall_algorithm,
+        pitfall_density=getattr(stage, "pitfall_density", 0.0),
+        base_seed=game_data.state.seed,
     )
     if isinstance(blueprint_data, dict):
         blueprint = blueprint_data.get("grid", [])
         steel_cells_raw = blueprint_data.get("steel_cells", set())
+        car_reachable_cells = blueprint_data.get("car_reachable_cells", set())
     else:
         blueprint = blueprint_data
         steel_cells_raw = set()
+        car_reachable_cells = set()
 
     steel_cells = (
         {(int(x), int(y)) for x, y in steel_cells_raw} if steel_enabled else set()
     )
+    game_data.layout.car_walkable_cells = car_reachable_cells
     cell_size = game_data.cell_size
     outer_wall_cells = {
         (x, y)
@@ -92,17 +104,22 @@ 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]] = []
+    pitfall_cells: set[tuple[int, int]] = set()
+    player_cells: list[tuple[int, int]] = []
+    car_cells: list[tuple[int, int]] = []
+    zombie_cells: list[tuple[int, int]] = []
+    fuel_cells: list[tuple[int, int]] = []
+    flashlight_cells: list[tuple[int, int]] = []
+    shoes_cells: list[tuple[int, int]] = []
     interior_min_x = 2
     interior_max_x = stage.grid_cols - 3
     interior_min_y = 2
     interior_max_y = stage.grid_rows - 3
     bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] = {}
     palette = get_environment_palette(game_data.state.ambient_palette_key)
+    rubble_ratio = max(0.0, min(1.0, getattr(stage, "wall_rubble_ratio", 0.0)))
 
     def add_beam_to_groups(beam: SteelBeam) -> None:
         if beam._added_to_groups:
@@ -125,7 +142,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)
@@ -145,9 +162,12 @@ def generate_level_from_blueprint(
                 wall_group.add(wall)
                 all_sprites.add(wall, layer=0)
                 continue
+            if ch == "x":
+                pitfall_cells.add((x, y))
+                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:
@@ -176,34 +196,74 @@ def generate_level_from_blueprint(
                 if any(bevel_mask):
                     bevel_corners[(x, y)] = bevel_mask
                 wall_cell = (x, y)
-                wall = Wall(
-                    cell_rect.x,
-                    cell_rect.y,
-                    cell_rect.width,
-                    cell_rect.height,
-                    health=INTERNAL_WALL_HEALTH,
-                    palette=palette,
-                    palette_category="inner_wall",
-                    bevel_mask=bevel_mask,
-                    draw_bottom_side=draw_bottom_side,
-                    on_destroy=(
-                        (lambda _w, b=beam, cell=wall_cell: (remove_wall_cell(cell), add_beam_to_groups(b)))
-                        if beam
-                        else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
-                    ),
-                )
+                use_rubble = rubble_ratio > 0 and random.random() < rubble_ratio
+                if use_rubble:
+                    rotation_deg = (
+                        RUBBLE_ROTATION_DEG
+                        if random.random() < 0.5
+                        else -RUBBLE_ROTATION_DEG
+                    )
+                    wall = RubbleWall(
+                        cell_rect.x,
+                        cell_rect.y,
+                        cell_rect.width,
+                        cell_rect.height,
+                        health=INTERNAL_WALL_HEALTH,
+                        palette=palette,
+                        palette_category="inner_wall",
+                        bevel_depth=INTERNAL_WALL_BEVEL_DEPTH,
+                        rubble_rotation_deg=rotation_deg,
+                        on_destroy=(
+                            (
+                                lambda _w, b=beam, cell=wall_cell: (
+                                    remove_wall_cell(cell),
+                                    add_beam_to_groups(b),
+                                )
+                            )
+                            if beam
+                            else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
+                        ),
+                    )
+                else:
+                    wall = Wall(
+                        cell_rect.x,
+                        cell_rect.y,
+                        cell_rect.width,
+                        cell_rect.height,
+                        health=INTERNAL_WALL_HEALTH,
+                        palette=palette,
+                        palette_category="inner_wall",
+                        bevel_mask=bevel_mask,
+                        draw_bottom_side=draw_bottom_side,
+                        on_destroy=(
+                            (
+                                lambda _w, b=beam, cell=wall_cell: (
+                                    remove_wall_cell(cell),
+                                    add_beam_to_groups(b),
+                                )
+                            )
+                            if beam
+                            else (lambda _w, cell=wall_cell: remove_wall_cell(cell))
+                        ),
+                    )
                 wall_group.add(wall)
                 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 ch == "f":
+                fuel_cells.append((x, y))
+            if ch == "l":
+                flashlight_cells.append((x, y))
+            if ch == "s":
+                shoes_cells.append((x, y))
 
             if cell_has_beam and ch != "1":
                 beam = SteelBeam(
@@ -215,12 +275,17 @@ 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
+    game_data.layout.pitfall_cells = pitfall_cells
     fall_spawn_cells = _expand_zone_cells(
         stage.fall_spawn_zones,
         grid_cols=stage.grid_cols,
@@ -246,5 +311,9 @@ def generate_level_from_blueprint(
         "player_cells": player_cells,
         "car_cells": car_cells,
         "zombie_cells": zombie_cells,
+        "fuel_cells": fuel_cells,
+        "flashlight_cells": flashlight_cells,
+        "shoes_cells": shoes_cells,
         "walkable_cells": walkable_cells,
+        "car_walkable_cells": list(car_reachable_cells),
     }

zombie_escape/gameplay/movement.py

@@ -13,15 +13,16 @@ from ..entities import (
     Zombie,
 )
 from ..entities_constants import (
+    HUMANOID_WALL_BUMP_FRAMES,
     PLAYER_SPEED,
     ZOMBIE_SEPARATION_DISTANCE,
-    ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
+    ZOMBIE_WALL_HUG_SENSOR_DISTANCE,
 )
 from ..gameplay_constants import (
     SHOES_SPEED_MULTIPLIER_ONE,
     SHOES_SPEED_MULTIPLIER_TWO,
 )
-from ..models import GameData
+from ..models import FallingZombie, GameData
 from ..world_grid import WallIndex, apply_tile_edge_nudge, walls_for_radius
 from .constants import MAX_ZOMBIES
 from .spawn import spawn_weighted_zombie, update_falling_zombies
@@ -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:
@@ -80,6 +84,28 @@ def _shoes_speed_multiplier(shoes_count: int) -> float:
     return 1.0
 
 
+def _handle_pitfall_detection(
+    x: float,
+    y: float,
+    cell_size: int,
+    pitfall_cells: set[tuple[int, int]],
+    pull_distance: float,
+) -> tuple[int, int] | None:
+    """Check if position is in pitfall and return pulled target coordinates if so."""
+    cx, cy = int(x // cell_size), int(y // cell_size)
+    if (cx, cy) not in pitfall_cells:
+        return None
+
+    cell_center_x = (cx * cell_size) + (cell_size // 2)
+    cell_center_y = (cy * cell_size) + (cell_size // 2)
+    dx, dy = cell_center_x - x, cell_center_y - y
+    dist = math.hypot(dx, dy)
+    if dist > 0:
+        move_factor = min(1.0, pull_distance / dist)
+        return int(x + dx * move_factor), int(y + dy * move_factor)
+    return int(x), int(y)
+
+
 def update_entities(
     game_data: GameData,
     player_dx: float,
@@ -101,6 +127,8 @@ def update_entities(
     stage = game_data.stage
     active_car = car if car and car.alive() else None
     wall_cells = game_data.layout.wall_cells
+    pitfall_cells = game_data.layout.pitfall_cells
+    walkable_cells = game_data.layout.walkable_cells
     bevel_corners = game_data.layout.bevel_corners
 
     all_walls = list(wall_group) if wall_index is None else None
@@ -131,7 +159,14 @@ def update_entities(
             grid_rows=stage.grid_rows,
         )
         car_walls = _walls_near((active_car.x, active_car.y), 150.0)
-        active_car.move(car_dx, car_dy, car_walls, walls_nearby=wall_index is not None)
+        active_car.move(
+            car_dx,
+            car_dy,
+            car_walls,
+            walls_nearby=wall_index is not None,
+            cell_size=game_data.cell_size,
+            pitfall_cells=pitfall_cells,
+        )
         player.rect.center = active_car.rect.center
         player.x, player.y = active_car.x, active_car.y
     elif not player.in_car:
@@ -157,6 +192,8 @@ def update_entities(
             cell_size=game_data.cell_size,
             level_width=game_data.level_width,
             level_height=game_data.level_height,
+            pitfall_cells=pitfall_cells,
+            walkable_cells=walkable_cells,
         )
     else:
         # Player flagged as in-car but car is gone; drop them back to foot control
@@ -166,7 +203,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
@@ -254,7 +309,7 @@ def update_entities(
                         + (pos[1] - zombie.y) ** 2,
                     )
         nearby_candidates = _nearby_zombies(idx)
-        zombie_search_radius = ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE + zombie.radius + 120
+        zombie_search_radius = ZOMBIE_WALL_HUG_SENSOR_DISTANCE + zombie.radius + 120
         nearby_walls = _walls_near((zombie.x, zombie.y), zombie_search_radius)
         zombie.update(
             target,
@@ -268,5 +323,30 @@ def update_entities(
             level_height=game_data.level_height,
             outer_wall_cells=game_data.layout.outer_wall_cells,
             wall_cells=game_data.layout.wall_cells,
+            pitfall_cells=game_data.layout.pitfall_cells,
             bevel_corners=game_data.layout.bevel_corners,
         )
+
+        # Check zombie pitfall
+        pull_dist = zombie.radius * 0.5
+        pitfall_target = _handle_pitfall_detection(
+            zombie.x,
+            zombie.y,
+            game_data.cell_size,
+            pitfall_cells,
+            pull_dist,
+        )
+        if pitfall_target is not None:
+            zombie.kill()
+            fall = FallingZombie(
+                start_pos=(int(zombie.x), int(zombie.y)),
+                target_pos=pitfall_target,
+                started_at_ms=pygame.time.get_ticks(),
+                pre_fx_ms=0,
+                fall_duration_ms=500,
+                dust_duration_ms=0,
+                tracker=zombie.tracker,
+                wall_hugging=zombie.wall_hugging,
+                mode="pitfall",
+            )
+            game_data.state.falling_zombies.append(fall)