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

zombie_escape/gameplay/survivors.py

@@ -29,7 +29,9 @@ RNG = get_rng()
 
 
 def update_survivors(
-    game_data: GameData, wall_index: WallIndex | None = None
+    game_data: GameData,
+    wall_index: WallIndex | None = None,
+    wall_target_cell: tuple[int, int] | None = None,
 ) -> None:
     if not (game_data.stage.rescue_stage or game_data.stage.buddy_required_count > 0):
         return
@@ -42,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,
@@ -49,11 +52,14 @@ 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,
             level_width=game_data.level_width,
             level_height=game_data.level_height,
+            wall_target_cell=wall_target_cell,
         )
 
     # Gently prevent survivors from overlapping the player or each other
@@ -106,6 +112,7 @@ def update_survivors(
                 other.rect.center = (int(other.x), int(other.y))
 
 
+
 def calculate_car_speed_for_passengers(
     passengers: int, *, capacity: int = SURVIVOR_MAX_SAFE_PASSENGERS
 ) -> float:
@@ -243,6 +250,7 @@ def handle_survivor_zombie_collisions(
     zombie_xs = [z.rect.centerx for z in zombies]
     camera = game_data.camera
     walkable_cells = game_data.layout.walkable_cells
+    cell_size = game_data.cell_size
 
     for survivor in list(survivor_group):
         if not survivor.alive():
@@ -275,6 +283,7 @@ def handle_survivor_zombie_collisions(
         if not rect_visible_on_screen(camera, survivor.rect):
             spawn_pos = find_nearby_offscreen_spawn_position(
                 walkable_cells,
+                cell_size,
                 camera=camera,
             )
             survivor.teleport(spawn_pos)
@@ -288,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)
@@ -310,6 +319,7 @@ def respawn_buddies_near_player(game_data: GameData) -> None:
     wall_group = game_data.groups.wall_group
     camera = game_data.camera
     walkable_cells = game_data.layout.walkable_cells
+    cell_size = game_data.cell_size
     offsets = [
         (BUDDY_RADIUS * 3, 0),
         (-BUDDY_RADIUS * 3, 0),
@@ -321,6 +331,7 @@ def respawn_buddies_near_player(game_data: GameData) -> None:
         if walkable_cells:
             spawn_pos = find_nearby_offscreen_spawn_position(
                 walkable_cells,
+                cell_size,
                 camera=camera,
             )
         else:

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/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]]:
@@ -218,9 +299,10 @@ def _place_walls_grid_wire(
                 grid[y][x] = "1"
 
 
-def _place_walls_sparse(
+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."""
@@ -234,7 +316,7 @@ def _place_walls_sparse(
                 continue
             if grid[y][x] != ".":
                 continue
-            if RNG.random() >= SPARSE_WALL_DENSITY:
+            if RNG.random() >= density:
                 continue
             if (
                 grid[y - 1][x] == "1"
@@ -250,11 +332,40 @@ def _place_walls_sparse(
             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,
 }
 
 
@@ -281,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,
@@ -302,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)
@@ -320,15 +460,90 @@ 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
+    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'."
         )
         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]
-    algo_func(grid, forbidden_cells=reserved_cells)
+    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)
 
     steel_beams = _place_steel_beams(
         grid, chance=steel_chance, forbidden_cells=reserved_cells
@@ -339,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", {})
@@ -347,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."
     }
   }
 }

zombie_escape/locales/ui.ja.json

@@ -16,7 +16,7 @@
       "settings": "設定",
       "quit": "終了",
       "locked_suffix": "[Locked]",
-      "window_hint": "[キーでウィンドウを小さく、]キーで大きく。\nF: フルスクリーン切替。\n（タイトル、設定画面のみ）",
+      "window_hint": "[キーでウィンドウを小さく、]キーで大きく。\nF: フルスクリーン切替。",
       "seed_label": "シード: %{value}",
       "seed_hint": "数字キーで入力、BSでクリア",
       "seed_empty": "(自動)",
@@ -25,6 +25,7 @@
         "resources": "リソース"
       },
       "readme": "README を開く",
+      "readme_stage6": "ステージ6以降の説明を開く",
       "hints": {
         "navigate": "上下: 項目選択",
         "page_switch": "左右: ステージ群切替",
@@ -33,7 +34,8 @@
       "option_help": {
         "settings": "設定画面を開いて言語や補助オプションを変更します。",
         "quit": "ゲームを終了します。",
-        "readme": "GitHub の README ページをブラウザで開きます。"
+        "readme": "GitHub の README ページをブラウザで開きます。",
+        "readme_stage6": "ステージ6以降の説明ページをブラウザで開きます。"
       }
     },
     "stages": {
@@ -127,6 +129,10 @@
       "stage15": {
         "name": "#15 分断ライン",
         "description": "建物中央を分断する危険地帯。横断には注意。"
+      },
+      "stage16": {
+        "name": "#16 奈落",
+        "description": "崩落した床パネルを回り込んでゾンビを誘い込もう。"
       }
     },
     "status": {
@@ -198,10 +204,14 @@
     "game_over": {
       "win": "脱出成功！",
       "lose": "ゲームオーバー",
+      "fell_into_abyss": "奈落の底へ落ちてしまった...",
       "prompt": "ESC/Space/Select/South: タイトルへ  R: 再挑戦",
       "scream": "ぎゃあーーー!!",
       "survivors_summary": "救出人数: %{count}",
       "endurance_duration": "逃げ延びた時間 %{time}"
+    },
+    "errors": {
+      "map_generation_failed": "マップの生成に失敗しました。シード値を変えるか、別のステージを選んでください。"
     }
   }
 }