zombie-escape 1.10.1__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/gameplay_constants.py

@@ -13,6 +13,11 @@ SURVIVOR_SPAWN_RATE = 0.07
 # --- Flashlight settings ---
 DEFAULT_FLASHLIGHT_SPAWN_COUNT = 2
 
+# --- Shoes settings ---
+DEFAULT_SHOES_SPAWN_COUNT = 0
+SHOES_SPEED_MULTIPLIER_ONE = 1.176
+SHOES_SPEED_MULTIPLIER_TWO = 1.25
+
 # --- Zombie settings ---
 ZOMBIE_SPAWN_DELAY_MS = 4000
 
@@ -25,6 +30,9 @@ __all__ = [
     "SURVIVAL_FAKE_CLOCK_RATIO",
     "SURVIVOR_SPAWN_RATE",
     "DEFAULT_FLASHLIGHT_SPAWN_COUNT",
+    "DEFAULT_SHOES_SPAWN_COUNT",
+    "SHOES_SPEED_MULTIPLIER_ONE",
+    "SHOES_SPEED_MULTIPLIER_TWO",
     "ZOMBIE_SPAWN_DELAY_MS",
     "CAR_HINT_DELAY_MS_DEFAULT",
 ]

zombie_escape/level_blueprints.py

@@ -84,11 +84,17 @@ def _place_exits(grid: list[list[str]], exits_per_side: int) -> None:
             grid[y][x] = "E"
 
 
-def _place_walls_default(grid: list[list[str]]) -> None:
+def _place_walls_default(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     cols, rows = len(grid[0]), len(grid)
     rng = RNG.randint
-    # Avoid placing walls adjacent to exits: collect forbidden cells (exits + neighbors)
+    # Avoid placing walls adjacent to exits and on reserved cells.
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
 
     for _ in range(NUM_WALL_LINES):
         length = rng(WALL_MIN_LEN, WALL_MAX_LEN)
@@ -111,12 +117,20 @@ def _place_walls_default(grid: list[list[str]]) -> None:
                     grid[y + i][x] = "1"
 
 
-def _place_walls_empty(grid: list[list[str]]) -> None:
+def _place_walls_empty(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     """Place no internal walls (open floor plan)."""
-    pass
+    _ = (grid, forbidden_cells)
 
 
-def _place_walls_grid_wire(grid: list[list[str]]) -> None:
+def _place_walls_grid_wire(
+    grid: list[list[str]],
+    *,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
     """
     Place walls using a 2-pass approach with independent layers.
     Vertical and horizontal walls are generated on separate grids to ensure
@@ -127,6 +141,8 @@ def _place_walls_grid_wire(grid: list[list[str]]) -> None:
     cols, rows = len(grid[0]), len(grid)
     rng = RNG.randint
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
 
     # Temporary grids for independent generation
     # They only track the internal walls ("1").
@@ -202,17 +218,24 @@ def _place_walls_grid_wire(grid: list[list[str]]) -> None:
                 grid[y][x] = "1"
 
 
-def _place_walls_sparse(grid: list[list[str]]) -> None:
+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."""
     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() >= SPARSE_WALL_DENSITY:
+            if RNG.random() >= density:
                 continue
             if (
                 grid[y - 1][x] == "1"
@@ -228,20 +251,54 @@ def _place_walls_sparse(grid: list[list[str]]) -> None:
             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,
 }
 
 
 def _place_steel_beams(
-    grid: list[list[str]], *, chance: float = STEEL_BEAM_CHANCE
+    grid: list[list[str]],
+    *,
+    chance: float = STEEL_BEAM_CHANCE,
+    forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> set[tuple[int, int]]:
     """Pick individual cells for steel beams, avoiding exits and their neighbors."""
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
     beams: set[tuple[int, int]] = set()
     for y in range(2, rows - 2):
         for x in range(2, cols - 2):
@@ -257,7 +314,6 @@ def _place_steel_beams(
 def _pick_empty_cell(
     grid: list[list[str]],
     margin: int,
-    forbidden: set[tuple[int, int]],
 ) -> tuple[int, int]:
     cols, rows = len(grid[0]), len(grid)
     attempts = 0
@@ -265,12 +321,12 @@ def _pick_empty_cell(
         attempts += 1
         x = RNG.randint(margin, cols - margin - 1)
         y = RNG.randint(margin, rows - margin - 1)
-        if grid[y][x] == "." and (x, y) not in forbidden:
+        if grid[y][x] == ".":
             return x, y
     # Fallback: scan for any acceptable cell
     for y in range(margin, rows - margin):
         for x in range(margin, cols - margin):
-            if grid[y][x] == "." and (x, y) not in forbidden:
+            if grid[y][x] == ".":
                 return x, y
     return cols // 2, rows // 2
 
@@ -281,7 +337,70 @@ def _generate_random_blueprint(
     grid = _init_grid(cols, rows)
     _place_exits(grid, EXITS_PER_SIDE)
 
-    # Select and run the wall placement algorithm
+    # Spawns: player, car, zombies
+    reserved_cells: set[tuple[int, int]] = set()
+    px, py = _pick_empty_cell(grid, SPAWN_MARGIN)
+    grid[py][px] = "P"
+    reserved_cells.add((px, py))
+    cx, cy = _pick_empty_cell(grid, SPAWN_MARGIN)
+    grid[cy][cx] = "C"
+    reserved_cells.add((cx, cy))
+    for _ in range(SPAWN_ZOMBIES):
+        zx, zy = _pick_empty_cell(grid, SPAWN_MARGIN)
+        grid[zy][zx] = "Z"
+        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'."
@@ -289,18 +408,14 @@ def _generate_random_blueprint(
         wall_algo = "default"
 
     algo_func = WALL_ALGORITHMS[wall_algo]
-    algo_func(grid)
-
-    steel_beams = _place_steel_beams(grid, chance=steel_chance)
+    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)
 
-    # Spawns: player, car, zombies
-    px, py = _pick_empty_cell(grid, SPAWN_MARGIN, forbidden=steel_beams)
-    grid[py][px] = "P"
-    cx, cy = _pick_empty_cell(grid, SPAWN_MARGIN, forbidden=steel_beams)
-    grid[cy][cx] = "C"
-    for _ in range(SPAWN_ZOMBIES):
-        zx, zy = _pick_empty_cell(grid, SPAWN_MARGIN, forbidden=steel_beams)
-        grid[zy][zx] = "Z"
+    steel_beams = _place_steel_beams(
+        grid, chance=steel_chance, forbidden_cells=reserved_cells
+    )
 
     blueprint_rows = ["".join(row) for row in grid]
     return {"grid": blueprint_rows, "steel_cells": steel_beams}

zombie_escape/locales/ui.en.json

@@ -118,7 +118,15 @@
       },
       "stage13": {
         "name": "#13 Rescue Buddy 3",
-        "description": "Rescue your buddy. Zombies may fall from above."
+        "description": "Rescue your buddy. Falling zombies."
+      },
+      "stage14": {
+        "name": "#14 Falling Factory",
+        "description": "A factory with collapsed upper floors. Break through obstacles."
+      },
+      "stage15": {
+        "name": "#15 The Divide",
+        "description": "A central hazard splits the building. Cross with care."
       }
     },
     "status": {

zombie_escape/locales/ui.ja.json

@@ -119,6 +119,14 @@
       "stage13": {
         "name": "#13 相棒を救え 3",
         "description": "はぐれた相棒を救え。ゾンビの落下あり。"
+      },
+      "stage14": {
+        "name": "#14 崩落工場",
+        "description": "上階の床が崩れた工場。破壊しながら進め。"
+      },
+      "stage15": {
+        "name": "#15 分断ライン",
+        "description": "建物中央を分断する危険地帯。横断には注意。"
       }
     },
     "status": {

zombie_escape/models.py

@@ -11,6 +11,7 @@ from pygame import sprite, surface
 from .entities_constants import ZOMBIE_AGING_DURATION_FRAMES
 from .gameplay_constants import (
     DEFAULT_FLASHLIGHT_SPAWN_COUNT,
+    DEFAULT_SHOES_SPAWN_COUNT,
     SURVIVOR_SPAWN_RATE,
     ZOMBIE_SPAWN_DELAY_MS,
 )
@@ -18,17 +19,16 @@ from .level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS
 from .localization import translate as tr
 
 if TYPE_CHECKING:  # pragma: no cover - typing-only imports
-    from .entities import Camera, Car, Flashlight, FuelCan, Player
+    from .entities import Camera, Car, Flashlight, FuelCan, Player, Shoes
 
 
 @dataclass
 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]]
@@ -82,6 +82,7 @@ class ProgressState:
     elapsed_play_ms: int
     has_fuel: bool
     flashlight_count: int
+    shoes_count: int
     ambient_palette_key: str
     hint_expires_at: int
     hint_target_type: str | None
@@ -104,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
@@ -131,6 +134,7 @@ class GameData:
     level_height: int
     fuel: FuelCan | None = None
     flashlights: list[Flashlight] | None = None
+    shoes: list[Shoes] | None = None
     player: Player | None = None
     car: Car | None = None
     waiting_cars: list[Car] = field(default_factory=list)
@@ -153,6 +157,7 @@ class Stage:
     endurance_goal_ms: int = 0
     fuel_spawn_count: int = 1
     initial_flashlight_count: int = DEFAULT_FLASHLIGHT_SPAWN_COUNT
+    initial_shoes_count: int = DEFAULT_SHOES_SPAWN_COUNT
     survivor_spawn_rate: float = SURVIVOR_SPAWN_RATE
     spawn_interval_ms: int = ZOMBIE_SPAWN_DELAY_MS
     initial_interior_spawn_rate: float = 0.015
@@ -160,6 +165,7 @@ class Stage:
     interior_spawn_weight: float = 0.0
     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
     zombie_tracker_ratio: float = 0.0
     zombie_wall_follower_ratio: float = 0.0
     zombie_normal_ratio: float = 1.0