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

zombie_escape/gameplay/movement.py

@@ -16,13 +16,13 @@ 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
@@ -84,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,
@@ -105,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
@@ -135,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:
@@ -161,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
@@ -276,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,
@@ -290,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)

zombie_escape/gameplay/spawn.py

@@ -35,6 +35,9 @@ from ..render_constants import (
 )
 from ..rng import get_rng
 from .constants import (
+    FALLING_ZOMBIE_DUST_DURATION_MS,
+    FALLING_ZOMBIE_DURATION_MS,
+    FALLING_ZOMBIE_PRE_FX_MS,
     MAX_ZOMBIES,
     ZOMBIE_SPAWN_PLAYER_BUFFER,
     ZOMBIE_TRACKER_AGING_DURATION_FRAMES,
@@ -82,22 +85,22 @@ def _car_appearance_for_stage(stage: Stage | None) -> str:
 def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
     normal_ratio = 1.0
     tracker_ratio = 0.0
-    wall_follower_ratio = 0.0
+    wall_hugging_ratio = 0.0
     if stage is not None:
         normal_ratio = max(0.0, min(1.0, stage.zombie_normal_ratio))
         tracker_ratio = max(0.0, min(1.0, stage.zombie_tracker_ratio))
-        wall_follower_ratio = max(0.0, min(1.0, stage.zombie_wall_follower_ratio))
-        if normal_ratio + tracker_ratio + wall_follower_ratio <= 0:
+        wall_hugging_ratio = max(0.0, min(1.0, stage.zombie_wall_hugging_ratio))
+        if normal_ratio + tracker_ratio + wall_hugging_ratio <= 0:
             normal_ratio = 1.0
             tracker_ratio = 0.0
-            wall_follower_ratio = 0.0
+            wall_hugging_ratio = 0.0
         if (
             normal_ratio == 1.0
-            and (tracker_ratio > 0.0 or wall_follower_ratio > 0.0)
-            and tracker_ratio + wall_follower_ratio <= 1.0
+            and (tracker_ratio > 0.0 or wall_hugging_ratio > 0.0)
+            and tracker_ratio + wall_hugging_ratio <= 1.0
         ):
-            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_follower_ratio)
-    total_ratio = normal_ratio + tracker_ratio + wall_follower_ratio
+            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_hugging_ratio)
+    total_ratio = normal_ratio + tracker_ratio + wall_hugging_ratio
     if total_ratio <= 0:
         return False, False
     pick = RNG.random() * total_ratio
@@ -210,7 +213,7 @@ def _schedule_falling_zombie(
     if len(zombie_group) + len(state.falling_zombies) >= MAX_ZOMBIES:
         return "blocked"
     min_distance = game_data.stage.tile_size * 0.5
-    tracker, wall_follower = _pick_zombie_variant(game_data.stage)
+    tracker, wall_hugging = _pick_zombie_variant(game_data.stage)
 
     def _candidate_clear(pos: tuple[int, int]) -> bool:
         candidate = _create_zombie(
@@ -218,7 +221,7 @@ def _schedule_falling_zombie(
             start_pos=pos,
             stage=game_data.stage,
             tracker=tracker,
-            wall_follower=wall_follower,
+            wall_hugging=wall_hugging,
         )
         return _is_spawn_position_clear(game_data, candidate)
 
@@ -231,17 +234,17 @@ def _schedule_falling_zombie(
         if allow_carry:
             state.falling_spawn_carry += 1
         return "no_position"
-    start_offset = game_data.stage.tile_size * 0.7
-    start_pos = (int(spawn_pos[0]), int(spawn_pos[1] - start_offset))
+    # start_offset removed; animation handles "falling" via scaling now.
+    start_pos = (int(spawn_pos[0]), int(spawn_pos[1]))
     fall = FallingZombie(
         start_pos=start_pos,
         target_pos=(int(spawn_pos[0]), int(spawn_pos[1])),
         started_at_ms=pygame.time.get_ticks(),
-        pre_fx_ms=350,
-        fall_duration_ms=450,
-        dust_duration_ms=220,
+        pre_fx_ms=FALLING_ZOMBIE_PRE_FX_MS,
+        fall_duration_ms=FALLING_ZOMBIE_DURATION_MS,
+        dust_duration_ms=FALLING_ZOMBIE_DUST_DURATION_MS,
         tracker=tracker,
-        wall_follower=wall_follower,
+        wall_hugging=wall_hugging,
     )
     state.falling_zombies.append(fall)
     return "scheduled"
@@ -254,7 +257,7 @@ def _create_zombie(
     hint_pos: tuple[float, float] | None = None,
     stage: Stage | None = None,
     tracker: bool | None = None,
-    wall_follower: bool | None = None,
+    wall_hugging: bool | None = None,
 ) -> Zombie:
     """Factory to create zombies with optional fast variants."""
     fast_conf = config.get("fast_zombies", {})
@@ -271,14 +274,14 @@ def _create_zombie(
         )
     else:
         aging_duration_frames = ZOMBIE_AGING_DURATION_FRAMES
-    if tracker is None or wall_follower is None:
-        picked_tracker, picked_wall_follower = _pick_zombie_variant(stage)
+    if tracker is None or wall_hugging is None:
+        picked_tracker, picked_wall_hugging = _pick_zombie_variant(stage)
         if tracker is None:
             tracker = picked_tracker
-        if wall_follower is None:
-            wall_follower = picked_wall_follower
+        if wall_hugging is None:
+            wall_hugging = picked_wall_hugging
     if tracker:
-        wall_follower = False
+        wall_hugging = False
     if tracker:
         ratio = (
             ZOMBIE_TRACKER_AGING_DURATION_FRAMES / ZOMBIE_AGING_DURATION_FRAMES
@@ -312,7 +315,7 @@ def _create_zombie(
         y=float(start_pos[1]),
         speed=base_speed,
         tracker=tracker,
-        wall_follower=wall_follower,
+        wall_hugging=wall_hugging,
         aging_duration_frames=aging_duration_frames,
     )
 
@@ -656,7 +659,8 @@ def setup_player_and_cars(
     player_pos = _pick_center(layout_data["player_cells"] or walkable_cells)
     player = Player(*player_pos)
 
-    car_candidates = list(layout_data["car_cells"] or walkable_cells)
+    car_walkable = layout_data.get("car_walkable_cells") or walkable_cells
+    car_candidates = list(layout_data["car_cells"] or car_walkable)
     waiting_cars: list[Car] = []
     car_appearance = _car_appearance_for_stage(game_data.stage)
 
@@ -722,7 +726,7 @@ def spawn_initial_zombies(
             start_pos=candidate_center,
             stage=game_data.stage,
             tracker=True,
-            wall_follower=False,
+            wall_hugging=False,
         )
         if not spritecollideany_walls(tentative, wall_group):
             zombie_group.add(tentative)
@@ -741,13 +745,13 @@ def spawn_initial_zombies(
     )
 
     for pos in positions:
-        tracker, wall_follower = _pick_zombie_variant(game_data.stage)
+        tracker, wall_hugging = _pick_zombie_variant(game_data.stage)
         tentative = _create_zombie(
             config,
             start_pos=pos,
             stage=game_data.stage,
             tracker=tracker,
-            wall_follower=wall_follower,
+            wall_hugging=wall_hugging,
         )
         if spritecollideany_walls(tentative, wall_group):
             continue
@@ -763,7 +767,9 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
     player = game_data.player
     if not player:
         return None
-    walkable_cells = game_data.layout.walkable_cells
+    # Use cells that are 4-way reachable by car
+    car_walkable = list(game_data.layout.car_walkable_cells)
+    walkable_cells = car_walkable if car_walkable else game_data.layout.walkable_cells
     if not walkable_cells:
         return None
     wall_group = game_data.groups.wall_group
@@ -919,18 +925,19 @@ def update_falling_zombies(game_data: GameData, config: dict[str, Any]) -> None:
             fall.dust_started = True
         if now < spawn_at:
             continue
-        if len(zombie_group) >= MAX_ZOMBIES:
-            state.falling_zombies.remove(fall)
-            continue
-        candidate = _create_zombie(
-            config,
-            start_pos=fall.target_pos,
-            stage=game_data.stage,
-            tracker=fall.tracker,
-            wall_follower=fall.wall_follower,
-        )
-        zombie_group.add(candidate)
-        all_sprites.add(candidate, layer=1)
+
+        if getattr(fall, "mode", "spawn") == "spawn":
+            if len(zombie_group) < MAX_ZOMBIES:
+                candidate = _create_zombie(
+                    config,
+                    start_pos=fall.target_pos,
+                    stage=game_data.stage,
+                    tracker=fall.tracker,
+                    wall_hugging=fall.wall_hugging,
+                )
+                zombie_group.add(candidate)
+                all_sprites.add(candidate, layer=1)
+
         state.falling_zombies.remove(fall)
 
 

zombie_escape/gameplay/state.py

@@ -51,6 +51,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         last_zombie_spawn_time=0,
         dawn_carbonized=False,
         debug_mode=False,
+        show_fps=False,
         falling_zombies=[],
         falling_spawn_carry=0,
         dust_rings=[],
@@ -88,6 +89,8 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
             walkable_cells=[],
             outer_wall_cells=set(),
             wall_cells=set(),
+            pitfall_cells=set(),
+            car_walkable_cells=set(),
             fall_spawn_cells=set(),
             bevel_corners={},
         ),

zombie_escape/gameplay/survivors.py

@@ -44,6 +44,7 @@ def update_survivors(
     target_rect = car.rect if player.in_car and car and car.alive() else player.rect
     target_pos = target_rect.center
     survivors = [s for s in survivor_group if s.alive()]
+
     for survivor in survivors:
         survivor.update_behavior(
             target_pos,
@@ -51,6 +52,8 @@ def update_survivors(
             wall_index=wall_index,
             cell_size=game_data.cell_size,
             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,
             grid_cols=game_data.stage.grid_cols,
             grid_rows=game_data.stage.grid_rows,
@@ -294,7 +297,7 @@ def handle_survivor_zombie_collisions(
             start_pos=survivor.rect.center,
             stage=game_data.stage,
             tracker=collided_zombie.tracker,
-            wall_follower=collided_zombie.wall_follower,
+            wall_hugging=collided_zombie.wall_hugging,
         )
         zombie_group.add(new_zombie)
         game_data.groups.all_sprites.add(new_zombie, layer=1)

zombie_escape/level_blueprints.py

@@ -1,6 +1,8 @@
 # Blueprint generator for randomized layouts.
 
-from .rng import get_rng
+from collections import deque
+
+from .rng import get_rng, seed_rng
 
 EXITS_PER_SIDE = 1  # currently fixed to 1 per side (can be tuned)
 NUM_WALL_LINES = 80  # reduced density (roughly 1/5 of previous 450)
@@ -13,15 +15,94 @@ SPAWN_ZOMBIES = 3
 RNG = get_rng()
 STEEL_BEAM_CHANCE = 0.02
 
-# Legend:
-# O: outside area (win when car reaches)
-# B: outer wall band (solid)
-# E: exit tile (opening in outer wall)
-# 1: internal wall
-# .: empty floor
-# P: player spawn candidate
-# C: car spawn candidate
-# Z: zombie spawn candidate
+
+class MapGenerationError(Exception):
+    """Raised when a valid map cannot be generated after several attempts."""
+
+
+def validate_car_connectivity(grid: list[str]) -> set[tuple[int, int]] | None:
+    """Check if the Car can reach at least one exit (4-way BFS).
+    Returns the set of reachable tiles if valid, otherwise None.
+    """
+    rows = len(grid)
+    cols = len(grid[0])
+
+    start_pos = None
+    passable_tiles = set()
+    exit_tiles = set()
+
+    for y in range(rows):
+        for x in range(cols):
+            ch = grid[y][x]
+            if ch == "C":
+                start_pos = (x, y)
+            if ch not in ("x", "B"):
+                passable_tiles.add((x, y))
+                if ch == "E":
+                    exit_tiles.add((x, y))
+
+    if start_pos is None:
+        # If no car candidate, we can't validate car pathing.
+        return passable_tiles
+
+    reachable = {start_pos}
+    queue = deque([start_pos])
+    while queue:
+        x, y = queue.popleft()
+        for dx, dy in ((0, 1), (0, -1), (1, 0), (-1, 0)):
+            nx, ny = x + dx, y + dy
+            if (nx, ny) in passable_tiles and (nx, ny) not in reachable:
+                reachable.add((nx, ny))
+                queue.append((nx, ny))
+
+    # Car must reach at least one exit
+    if exit_tiles and not any(e in reachable for e in exit_tiles):
+        return None
+    return reachable
+
+
+def validate_humanoid_connectivity(grid: list[str]) -> bool:
+    """Check if all floor tiles are reachable by Humans (8-way BFS with jumps)."""
+    rows = len(grid)
+    cols = len(grid[0])
+
+    start_pos = None
+    passable_tiles = set()
+
+    for y in range(rows):
+        for x in range(cols):
+            ch = grid[y][x]
+            if ch == "P":
+                start_pos = (x, y)
+            if ch not in ("x", "B"):
+                passable_tiles.add((x, y))
+
+    if start_pos is None:
+        return False
+
+    reachable = {start_pos}
+    queue = deque([start_pos])
+    while queue:
+        x, y = queue.popleft()
+        for dx, dy in ((0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)):
+            nx, ny = x + dx, y + dy
+            if (nx, ny) in passable_tiles and (nx, ny) not in reachable:
+                reachable.add((nx, ny))
+                queue.append((nx, ny))
+
+    return len(passable_tiles) == len(reachable)
+
+
+def validate_connectivity(grid: list[str]) -> set[tuple[int, int]] | None:
+    """Validate both car and humanoid movement conditions.
+    Returns car reachable tiles if both pass, otherwise None.
+    """
+    car_reachable = validate_car_connectivity(grid)
+    if car_reachable is None:
+        return None
+    if not validate_humanoid_connectivity(grid):
+        return None
+    return car_reachable
 
 
 def _collect_exit_adjacent_cells(grid: list[list[str]]) -> set[tuple[int, int]]:
@@ -311,6 +392,30 @@ def _place_steel_beams(
     return beams
 
 
+def _place_pitfalls(
+    grid: list[list[str]],
+    *,
+    density: float,
+    forbidden_cells: set[tuple[int, int]] | None = None,
+) -> None:
+    """Replace empty floor tiles with pitfalls based on density."""
+    if density <= 0.0:
+        return
+    cols, rows = len(grid[0]), len(grid)
+    forbidden = _collect_exit_adjacent_cells(grid)
+    if forbidden_cells:
+        forbidden |= forbidden_cells
+
+    for y in range(1, rows - 1):
+        for x in range(1, cols - 1):
+            if (x, y) in forbidden:
+                continue
+            if grid[y][x] != ".":
+                continue
+            if RNG.random() < density:
+                grid[y][x] = "x"
+
+
 def _pick_empty_cell(
     grid: list[list[str]],
     margin: int,
@@ -332,7 +437,12 @@ def _pick_empty_cell(
 
 
 def _generate_random_blueprint(
-    steel_chance: float, *, cols: int, rows: int, wall_algo: str = "default"
+    steel_chance: float,
+    *,
+    cols: int,
+    rows: int,
+    wall_algo: str = "default",
+    pitfall_density: float = 0.0,
 ) -> dict:
     grid = _init_grid(cols, rows)
     _place_exits(grid, EXITS_PER_SIDE)
@@ -350,6 +460,21 @@ def _generate_random_blueprint(
         grid[zy][zx] = "Z"
         reserved_cells.add((zx, zy))
 
+    # Items
+    fx, fy = _pick_empty_cell(grid, SPAWN_MARGIN)
+    grid[fy][fx] = "f"
+    reserved_cells.add((fx, fy))
+
+    for _ in range(2):
+        lx, ly = _pick_empty_cell(grid, SPAWN_MARGIN)
+        grid[ly][lx] = "l"
+        reserved_cells.add((lx, ly))
+
+    for _ in range(2):
+        sx, sy = _pick_empty_cell(grid, SPAWN_MARGIN)
+        grid[sy][sx] = "s"
+        reserved_cells.add((sx, sy))
+
     # Select and run the wall placement algorithm (after reserving spawns)
     sparse_density = SPARSE_WALL_DENSITY
     original_wall_algo = wall_algo
@@ -407,6 +532,13 @@ def _generate_random_blueprint(
         )
         wall_algo = "default"
 
+    # Place pitfalls BEFORE walls so walls avoid them (consistent with spawn reservation)
+    _place_pitfalls(
+        grid,
+        density=pitfall_density,
+        forbidden_cells=reserved_cells,
+    )
+
     algo_func = WALL_ALGORITHMS[wall_algo]
     if wall_algo in {"sparse_moore", "sparse_ortho"}:
         algo_func(grid, density=sparse_density, forbidden_cells=reserved_cells)
@@ -422,7 +554,13 @@ def _generate_random_blueprint(
 
 
 def choose_blueprint(
-    config: dict, *, cols: int, rows: int, wall_algo: str = "default"
+    config: dict,
+    *,
+    cols: int,
+    rows: int,
+    wall_algo: str = "default",
+    pitfall_density: float = 0.0,
+    base_seed: int | None = None,
 ) -> dict:
     # Currently only random generation; hook for future variants.
     steel_conf = config.get("steel_beams", {})
@@ -430,6 +568,22 @@ def choose_blueprint(
         steel_chance = float(steel_conf.get("chance", STEEL_BEAM_CHANCE))
     except (TypeError, ValueError):
         steel_chance = STEEL_BEAM_CHANCE
-    return _generate_random_blueprint(
-        steel_chance=steel_chance, cols=cols, rows=rows, wall_algo=wall_algo
-    )
+
+    for attempt in range(20):
+        if base_seed is not None:
+            seed_rng(base_seed + attempt)
+
+        blueprint = _generate_random_blueprint(
+            steel_chance=steel_chance,
+            cols=cols,
+            rows=rows,
+            wall_algo=wall_algo,
+            pitfall_density=pitfall_density,
+        )
+
+        car_reachable = validate_connectivity(blueprint["grid"])
+        if car_reachable is not None:
+            blueprint["car_reachable_cells"] = car_reachable
+            return blueprint
+
+    raise MapGenerationError("Connectivity validation failed after 20 attempts")

zombie_escape/locales/ui.en.json

@@ -16,7 +16,7 @@
       "settings": "Settings",
       "quit": "Quit",
       "locked_suffix": "[Locked]",
-      "window_hint": "Resize window: [ to shrink, ] to enlarge.\nF: toggle fullscreen.\n(Title/Settings only)",
+      "window_hint": "Resize window: [ to shrink, ] to enlarge.\nF: toggle fullscreen.",
       "seed_label": "Seed: %{value}",
       "seed_hint": "Type 0-9 to set a custom seed, Backspace clears",
       "seed_empty": "(auto)",
@@ -25,6 +25,7 @@
         "resources": "Resources"
       },
       "readme": "Open README",
+      "readme_stage6": "Open Stage 6+ Guide",
       "hints": {
         "navigate": "Up/Down: choose an option",
         "page_switch": "Left/Right: switch stage groups",
@@ -33,7 +34,8 @@
       "option_help": {
         "settings": "Open Settings to adjust assists and localization.",
         "quit": "Close the game.",
-        "readme": "Open the GitHub README in your browser."
+        "readme": "Open the GitHub README in your browser.",
+        "readme_stage6": "Open the Stage 6+ guide in your browser."
       }
     },
     "stages": {
@@ -127,6 +129,10 @@
       "stage15": {
         "name": "#15 The Divide",
         "description": "A central hazard splits the building. Cross with care."
+      },
+      "stage16": {
+        "name": "#16 Floor Collapse",
+        "description": "Circumnavigate the collapsed floor panels and lure the zombies into the abyss."
       }
     },
     "status": {
@@ -198,10 +204,14 @@
     "game_over": {
       "win": "YOU ESCAPED!",
       "lose": "GAME OVER",
+      "fell_into_abyss": "You fell into the abyss...",
       "prompt": "ESC/SPACE/Select/South: Title · R: Retry",
       "scream": "AAAAHHH!!",
       "survivors_summary": "Evacuated: %{count}",
       "endurance_duration": "Time survived %{time}"
+    },
+    "errors": {
+      "map_generation_failed": "Map generation failed. Please try a different seed or stage."
     }
   }
 }