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

zombie_escape/gameplay/__init__.py

@@ -14,6 +14,7 @@ from .spawn import (
     place_flashlights,
     place_fuel_can,
     place_new_car,
+    place_shoes,
     setup_player_and_cars,
     spawn_exterior_zombie,
     spawn_initial_zombies,
@@ -46,6 +47,7 @@ __all__ = [
     "place_new_car",
     "place_fuel_can",
     "place_flashlights",
+    "place_shoes",
     "place_buddies",
     "find_interior_spawn_positions",
     "find_nearby_offscreen_spawn_position",

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

@@ -12,6 +12,8 @@ from ..entities_constants import (
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
     HUMANOID_RADIUS,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
     SURVIVOR_APPROACH_RADIUS,
     SURVIVOR_MAX_SAFE_PASSENGERS,
 )
@@ -55,11 +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
@@ -70,6 +74,18 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
     flashlight_interaction_radius = _interaction_radius(
         FLASHLIGHT_WIDTH, FLASHLIGHT_HEIGHT
     )
+    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
@@ -118,6 +134,21 @@ def check_interactions(game_data: GameData, config: dict[str, Any]) -> None:
                 print("Flashlight acquired!")
                 break
 
+        for shoes in list(shoes_list):
+            if not shoes.alive():
+                continue
+            if _player_near_point(shoes.rect.center, shoes_interaction_radius):
+                state.shoes_count += 1
+                state.hint_expires_at = 0
+                state.hint_target_type = None
+                shoes.kill()
+                try:
+                    shoes_list.remove(shoes)
+                except ValueError:
+                    pass
+                print("Shoes acquired!")
+                break
+
     sync_ambient_palette_with_flashlights(game_data)
 
     buddies = [
@@ -170,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)
@@ -322,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
 
@@ -332,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

zombie_escape/gameplay/layout.py

@@ -10,9 +10,12 @@ from ..entities_constants import INTERNAL_WALL_HEALTH, STEEL_BEAM_HEALTH
 from .constants import OUTER_WALL_HEALTH
 from ..level_blueprints import choose_blueprint
 from ..models import GameData
+from ..rng import get_rng
 
 __all__ = ["generate_level_from_blueprint"]
 
+RNG = get_rng()
+
 
 def _rect_for_cell(x_idx: int, y_idx: int, cell_size: int) -> pygame.Rect:
     return pygame.Rect(
@@ -89,11 +92,15 @@ 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]] = []
+    player_cells: list[tuple[int, int]] = []
+    car_cells: list[tuple[int, int]] = []
+    zombie_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)
 
@@ -118,7 +125,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)
@@ -140,7 +147,7 @@ def generate_level_from_blueprint(
                 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:
@@ -189,14 +196,14 @@ def generate_level_from_blueprint(
                 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 cell_has_beam and ch != "1":
                 beam = SteelBeam(
@@ -208,17 +215,35 @@ 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.fall_spawn_cells = _expand_zone_cells(
+    fall_spawn_cells = _expand_zone_cells(
         stage.fall_spawn_zones,
         grid_cols=stage.grid_cols,
         grid_rows=stage.grid_rows,
     )
+    floor_ratio = max(0.0, min(1.0, stage.fall_spawn_floor_ratio))
+    if floor_ratio > 0.0 and interior_min_x <= interior_max_x:
+        for y in range(interior_min_y, interior_max_y + 1):
+            for x in range(interior_min_x, interior_max_x + 1):
+                if RNG.random() < floor_ratio:
+                    fall_spawn_cells.add((x, y))
+        if not fall_spawn_cells:
+            fall_spawn_cells.add(
+                (
+                    RNG.randint(interior_min_x, interior_max_x),
+                    RNG.randint(interior_min_y, interior_max_y),
+                )
+            )
+    game_data.layout.fall_spawn_cells = fall_spawn_cells
     game_data.layout.bevel_corners = bevel_corners
 
     return {

zombie_escape/gameplay/movement.py

@@ -13,10 +13,15 @@ from ..entities import (
     Zombie,
 )
 from ..entities_constants import (
+    HUMANOID_WALL_BUMP_FRAMES,
     PLAYER_SPEED,
     ZOMBIE_SEPARATION_DISTANCE,
     ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
 )
+from ..gameplay_constants import (
+    SHOES_SPEED_MULTIPLIER_ONE,
+    SHOES_SPEED_MULTIPLIER_TWO,
+)
 from ..models import GameData
 from ..world_grid import WallIndex, apply_tile_edge_nudge, walls_for_radius
 from .constants import MAX_ZOMBIES
@@ -29,6 +34,7 @@ def process_player_input(
     keys: Sequence[bool],
     player: Player,
     car: Car | None,
+    shoes_count: int = 0,
     pad_input: tuple[float, float] = (0.0, 0.0),
 ) -> tuple[float, float, float, float]:
     """Process keyboard input and return movement deltas."""
@@ -44,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:
@@ -55,7 +64,7 @@ def process_player_input(
                 (dy_input / move_len) * target_speed,
             )
     elif not player.in_car:
-        target_speed = PLAYER_SPEED
+        target_speed = PLAYER_SPEED * _shoes_speed_multiplier(shoes_count)
         move_len = math.hypot(dx_input, dy_input)
         if move_len > 0:
             player_dx, player_dy = (
@@ -66,6 +75,15 @@ def process_player_input(
     return player_dx, player_dy, car_dx, car_dy
 
 
+def _shoes_speed_multiplier(shoes_count: int) -> float:
+    count = max(0, int(shoes_count))
+    if count >= 2:
+        return SHOES_SPEED_MULTIPLIER_TWO
+    if count == 1:
+        return SHOES_SPEED_MULTIPLIER_ONE
+    return 1.0
+
+
 def update_entities(
     game_data: GameData,
     player_dx: float,
@@ -152,7 +170,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