zombie-escape 1.14.4__py3-none-any.whl → 1.15.2__py3-none-any.whl

zombie_escape/gameplay/state.py

@@ -4,11 +4,51 @@ from typing import Any
 
 import pygame
 
-from ..colors import DAWN_AMBIENT_PALETTE_KEY, ambient_palette_key_for_flashlights
+from ..colors import DAWN_AMBIENT_PALETTE_KEY, WHITE, ambient_palette_key_for_flashlights
 from ..entities_constants import SURVIVOR_MAX_SAFE_PASSENGERS
-from ..models import GameData, Groups, LevelLayout, ProgressState, Stage
+from ..localization import translate as tr
+from ..models import GameData, Groups, LevelLayout, ProgressState, Stage, TimedMessage
+from ..screen_constants import FPS
 from ..entities import Camera
 from .ambient import _set_ambient_palette
+from .constants import INTRO_MESSAGE_DISPLAY_FRAMES
+
+
+def frames_to_ms(frames: int) -> int:
+    if frames <= 0:
+        return 0
+    return max(1, int(round((1000 / max(1, FPS)) * frames)))
+
+
+def ms_to_frames(ms: int) -> int:
+    if ms <= 0:
+        return 0
+    return max(1, int(round((max(1, FPS) / 1000) * ms)))
+
+
+def schedule_timed_message(
+    state: ProgressState,
+    text: str | None,
+    *,
+    duration_frames: int,
+    clear_on_input: bool = False,
+    color: tuple[int, int, int] | None = None,
+    align: str = "center",
+    now_ms: int | None = None,
+) -> None:
+    if not text:
+        state.timed_message = None
+        return
+    duration_ms = frames_to_ms(duration_frames)
+    if now_ms is None:
+        now_ms = state.elapsed_play_ms
+    state.timed_message = TimedMessage(
+        text=text,
+        expires_at_ms=now_ms + duration_ms,
+        clear_on_input=clear_on_input,
+        color=color,
+        align=align,
+    )
 
 
 def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
@@ -19,10 +59,12 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
     starts_with_flashlight = False
     initial_flashlights = 1 if starts_with_flashlight else 0
     initial_palette_key = ambient_palette_key_for_flashlights(initial_flashlights)
+    intro_message = tr(stage.intro_key) if stage.intro_key else None
     game_state = ProgressState(
         game_over=False,
         game_won=False,
-        game_over_message=None,
+        timed_message=None,
+        fade_in_started_at_ms=None,
         game_over_at=None,
         scaled_overview=None,
         overview_created=False,
@@ -36,9 +78,9 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         ambient_palette_key=initial_palette_key,
         hint_expires_at=0,
         hint_target_type=None,
-        fuel_message_until=0,
         buddy_rescued=0,
         buddy_onboard=0,
+        buddy_merged_count=0,
         survivors_onboard=0,
         survivors_rescued=0,
         survivor_messages=[],
@@ -59,6 +101,18 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         player_wall_target_cell=None,
         player_wall_target_ttl=0,
     )
+    if intro_message:
+        schedule_timed_message(
+            game_state,
+            intro_message,
+            duration_frames=INTRO_MESSAGE_DISPLAY_FRAMES,
+            clear_on_input=True,
+            color=WHITE,
+            align="left",
+        )
+
+    # Start fade-in from black when gameplay begins.
+    game_state.fade_in_started_at_ms = game_state.elapsed_play_ms
 
     # Create sprite groups
     all_sprites = pygame.sprite.LayeredUpdates()
@@ -67,7 +121,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
     survivor_group = pygame.sprite.Group()
 
     # Create camera
-    cell_size = stage.tile_size
+    cell_size = stage.cell_size
     level_width = stage.grid_cols * cell_size
     level_height = stage.grid_rows * cell_size
     camera = Camera(level_width, level_height)
@@ -86,6 +140,8 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         camera=camera,
         layout=LevelLayout(
             field_rect=field_rect,
+            grid_cols=stage.grid_cols,
+            grid_rows=stage.grid_rows,
             outside_cells=set(),
             walkable_cells=[],
             outer_wall_cells=set(),
@@ -101,8 +157,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         },
         stage=stage,
         cell_size=cell_size,
-        level_width=level_width,
-        level_height=level_height,
+        blueprint=None,
         fuel=None,
         flashlights=[],
         shoes=[],

zombie_escape/gameplay/survivors.py

@@ -23,7 +23,7 @@ from ..rng import get_rng
 from ..entities import Survivor, Zombie, spritecollideany_walls
 from ..world_grid import WallIndex
 from .spawn import _create_zombie
-from .utils import find_nearby_offscreen_spawn_position, rect_visible_on_screen
+from .utils import find_nearby_offscreen_spawn_position, is_entity_in_fov, rect_visible_on_screen
 
 RNG = get_rng()
 
@@ -38,6 +38,7 @@ def update_survivors(
     survivor_group = game_data.groups.survivor_group
     wall_group = game_data.groups.wall_group
     player = game_data.player
+    assert player is not None
     car = game_data.car
     if not player:
         return
@@ -51,14 +52,7 @@ def update_survivors(
             wall_group,
             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,
+            layout=game_data.layout,
             wall_target_cell=wall_target_cell,
         )
 
@@ -84,6 +78,50 @@ def update_survivors(
     for survivor in survivors:
         _separate_from_point(survivor, player_point, player_overlap)
 
+    def _resolve_wall_overlap(survivor: Survivor) -> None:
+        for _ in range(4):
+            hit_wall = spritecollideany_walls(
+                survivor,
+                wall_group,
+                wall_index=wall_index,
+                cell_size=game_data.cell_size,
+                grid_cols=game_data.stage.grid_cols,
+                grid_rows=game_data.stage.grid_rows,
+            )
+            if not hit_wall:
+                return
+            cx, cy = survivor.rect.center
+            radius = survivor.radius
+            rect = hit_wall.rect
+            closest_x = min(max(cx, rect.left), rect.right)
+            closest_y = min(max(cy, rect.top), rect.bottom)
+            dx = cx - closest_x
+            dy = cy - closest_y
+            if dx == 0 and dy == 0:
+                left_pen = cx - rect.left
+                right_pen = rect.right - cx
+                top_pen = cy - rect.top
+                bottom_pen = rect.bottom - cy
+                min_pen = min(left_pen, right_pen, top_pen, bottom_pen)
+                if min_pen == left_pen:
+                    cx = rect.left - radius
+                elif min_pen == right_pen:
+                    cx = rect.right + radius
+                elif min_pen == top_pen:
+                    cy = rect.top - radius
+                else:
+                    cy = rect.bottom + radius
+            else:
+                dist = math.hypot(dx, dy)
+                if dist == 0:
+                    return
+                push = max(1.0, radius - dist)
+                cx += (dx / dist) * push
+                cy += (dy / dist) * push
+            survivor.x = float(cx)
+            survivor.y = float(cy)
+            survivor.rect.center = (int(survivor.x), int(survivor.y))
+
     survivors_with_x = sorted(((survivor.x, survivor) for survivor in survivors), key=lambda item: item[0])
     for i, (base_x, survivor) in enumerate(survivors_with_x):
         for other_base_x, other in survivors_with_x[i + 1 :]:
@@ -107,6 +145,9 @@ def update_survivors(
                 survivor.rect.center = (int(survivor.x), int(survivor.y))
                 other.rect.center = (int(other.x), int(other.y))
 
+    for survivor in survivors:
+        _resolve_wall_overlap(survivor)
+
 
 def calculate_car_speed_for_passengers(passengers: int, *, capacity: int = SURVIVOR_MAX_SAFE_PASSENGERS) -> float:
     cap = max(1, capacity)
@@ -240,6 +281,10 @@ def handle_survivor_zombie_collisions(game_data: GameData, config: dict[str, Any
     camera = game_data.camera
     walkable_cells = game_data.layout.walkable_cells
     cell_size = game_data.cell_size
+    player = game_data.player
+    car = game_data.car
+    active_car = car if car and car.alive() else None
+    fov_target = active_car if player and player.in_car and active_car else player
 
     for survivor in list(survivor_group):
         if not survivor.alive():
@@ -269,7 +314,13 @@ def handle_survivor_zombie_collisions(game_data: GameData, config: dict[str, Any
 
         if collided_zombie is None:
             continue
-        if not rect_visible_on_screen(camera, survivor.rect):
+        survivor_on_screen = rect_visible_on_screen(camera, survivor.rect)
+        survivor_in_fov = is_entity_in_fov(
+            survivor.rect,
+            fov_target=fov_target,
+            flashlight_count=game_data.state.flashlight_count,
+        )
+        if not (survivor_on_screen and survivor_in_fov):
             spawn_pos = find_nearby_offscreen_spawn_position(
                 walkable_cells,
                 cell_size,

zombie_escape/gameplay/utils.py

@@ -4,6 +4,12 @@ import pygame
 
 from ..entities import Camera, Player, random_position_outside_building
 from ..rng import get_rng
+from ..render_constants import (
+    FLASHLIGHT_FOG_SCALE_ONE,
+    FLASHLIGHT_FOG_SCALE_TWO,
+    FOG_RADIUS_SCALE,
+    FOV_RADIUS,
+)
 from ..screen_constants import SCREEN_HEIGHT, SCREEN_WIDTH
 
 LOGICAL_SCREEN_RECT = pygame.Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)
@@ -12,6 +18,8 @@ RNG = get_rng()
 __all__ = [
     "LOGICAL_SCREEN_RECT",
     "rect_visible_on_screen",
+    "fov_radius_for_flashlights",
+    "is_entity_in_fov",
     "find_interior_spawn_positions",
     "find_nearby_offscreen_spawn_position",
     "find_exterior_spawn_position",
@@ -24,6 +32,31 @@ def rect_visible_on_screen(camera: Camera | None, rect: pygame.Rect) -> bool:
     return camera.apply_rect(rect).colliderect(LOGICAL_SCREEN_RECT)
 
 
+def fov_radius_for_flashlights(flashlight_count: int) -> float:
+    count = max(0, int(flashlight_count))
+    if count <= 0:
+        scale = FOG_RADIUS_SCALE
+    elif count == 1:
+        scale = FLASHLIGHT_FOG_SCALE_ONE
+    else:
+        scale = FLASHLIGHT_FOG_SCALE_TWO
+    return FOV_RADIUS * scale
+
+
+def is_entity_in_fov(
+    entity_rect: pygame.Rect,
+    *,
+    fov_target: pygame.sprite.Sprite | None,
+    flashlight_count: int,
+) -> bool:
+    if fov_target is None:
+        return False
+    fov_radius = fov_radius_for_flashlights(flashlight_count)
+    dx = entity_rect.centerx - fov_target.rect.centerx
+    dy = entity_rect.centery - fov_target.rect.centery
+    return (dx * dx + dy * dy) <= fov_radius * fov_radius
+
+
 def _scatter_positions_on_walkable(
     walkable_cells: list[tuple[int, int]],
     cell_size: int,

zombie_escape/level_blueprints.py

@@ -1,6 +1,7 @@
 # Blueprint generator for randomized layouts.
 
 from collections import deque
+from dataclasses import dataclass, field
 
 from .level_constants import (
     DEFAULT_GRID_WIRE_WALL_LINES,
@@ -14,7 +15,6 @@ EXITS_PER_SIDE = 1  # currently fixed to 1 per side (can be tuned)
 WALL_MIN_LEN = 3
 WALL_MAX_LEN = 10
 SPAWN_MARGIN = 3  # keep spawns away from walls/edges
-SPAWN_ZOMBIES = 3
 
 RNG = get_rng()
 
@@ -23,30 +23,37 @@ class MapGenerationError(Exception):
     """Raised when a valid map cannot be generated after several attempts."""
 
 
+@dataclass
+class Blueprint:
+    grid: list[str]
+    steel_cells: set[tuple[int, int]] = field(default_factory=set)
+    car_reachable_cells: set[tuple[int, int]] = field(default_factory=set)
+
+
 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.
+    Returns the set of reachable cells if valid, otherwise None.
     """
     rows = len(grid)
     cols = len(grid[0])
 
     start_pos = None
-    passable_tiles = set()
-    exit_tiles = set()
+    passable_cells = set()
+    exit_cells = 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 not in ("x", "B", "O"):
+                passable_cells.add((x, y))
                 if ch == "E":
-                    exit_tiles.add((x, y))
+                    exit_cells.add((x, y))
 
     if start_pos is None:
         # If no car candidate, we can't validate car pathing.
-        return passable_tiles
+        return passable_cells
 
     reachable = {start_pos}
     queue = deque([start_pos])
@@ -54,23 +61,23 @@ def validate_car_connectivity(grid: list[str]) -> set[tuple[int, int]] | None:
         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:
+            if (nx, ny) in passable_cells 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):
+    if exit_cells and not any(e in reachable for e in exit_cells):
         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)."""
+    """Check if all floor cells are reachable by Humans (8-way BFS with jumps)."""
     rows = len(grid)
     cols = len(grid[0])
 
     start_pos = None
-    passable_tiles = set()
+    passable_cells = set()
 
     for y in range(rows):
         for x in range(cols):
@@ -78,7 +85,7 @@ def validate_humanoid_connectivity(grid: list[str]) -> bool:
             if ch == "P":
                 start_pos = (x, y)
             if ch not in ("x", "B"):
-                passable_tiles.add((x, y))
+                passable_cells.add((x, y))
 
     if start_pos is None:
         return False
@@ -89,16 +96,16 @@ def validate_humanoid_connectivity(grid: list[str]) -> bool:
         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:
+            if (nx, ny) in passable_cells and (nx, ny) not in reachable:
                 reachable.add((nx, ny))
                 queue.append((nx, ny))
 
-    return len(passable_tiles) == len(reachable)
+    return len(passable_cells) == 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.
+    Returns car reachable cells if both pass, otherwise None.
     """
     car_reachable = validate_car_connectivity(grid)
     if car_reachable is None:
@@ -190,7 +197,7 @@ def _place_walls_default(
             for i in range(length):
                 if (x + i, y) in forbidden:
                     continue
-                if grid[y][x + i] in (".", "Z"):
+                if grid[y][x + i] == ".":
                     grid[y][x + i] = "1"
         else:
             x = rng(2, cols - 3)
@@ -198,7 +205,7 @@ def _place_walls_default(
             for i in range(length):
                 if (x, y + i) in forbidden:
                     continue
-                if grid[y + i][x] in (".", "Z"):
+                if grid[y + i][x] == ".":
                     grid[y + i][x] = "1"
 
 
@@ -317,7 +324,7 @@ def _place_walls_sparse_moore(
     density: float = DEFAULT_SPARSE_WALL_DENSITY,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
-    """Place isolated wall tiles at a low density, avoiding adjacency."""
+    """Place isolated wall cells at a low density, avoiding adjacency."""
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
     if forbidden_cells:
@@ -350,7 +357,7 @@ def _place_walls_sparse_ortho(
     density: float = DEFAULT_SPARSE_WALL_DENSITY,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
-    """Place isolated wall tiles at a low density, avoiding orthogonal adjacency."""
+    """Place isolated wall cells at a low density, avoiding orthogonal adjacency."""
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
     if forbidden_cells:
@@ -407,7 +414,7 @@ def _place_pitfalls(
     pitfall_zones: list[tuple[int, int, int, int]] | None = None,
     forbidden_cells: set[tuple[int, int]] | None = None,
 ) -> None:
-    """Replace empty floor tiles with pitfalls based on density."""
+    """Replace empty floor cells with pitfalls based on density."""
     cols, rows = len(grid[0]), len(grid)
     forbidden = _collect_exit_adjacent_cells(grid)
     if forbidden_cells:
@@ -468,11 +475,11 @@ def _generate_random_blueprint(
     wall_algo: str = "default",
     pitfall_density: float = 0.0,
     pitfall_zones: list[tuple[int, int, int, int]] | None = None,
-) -> dict:
+) -> Blueprint:
     grid = _init_grid(cols, rows)
     _place_exits(grid, EXITS_PER_SIDE)
 
-    # Spawns: player, car, zombies
+    # Spawns: player, car
     reserved_cells: set[tuple[int, int]] = set()
     px, py = _pick_empty_cell(grid, SPAWN_MARGIN)
     grid[py][px] = "P"
@@ -480,10 +487,7 @@ def _generate_random_blueprint(
     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))
+    # (No zombie candidate cells; initial spawns are handled by gameplay.)
 
     # Items
     fx, fy = _pick_empty_cell(grid, SPAWN_MARGIN)
@@ -591,7 +595,7 @@ def _generate_random_blueprint(
     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}
+    return Blueprint(grid=blueprint_rows, steel_cells=steel_beams)
 
 
 def choose_blueprint(
@@ -603,7 +607,7 @@ def choose_blueprint(
     pitfall_density: float = 0.0,
     pitfall_zones: list[tuple[int, int, int, int]] | None = None,
     base_seed: int | None = None,
-) -> dict:
+) -> Blueprint:
     # Currently only random generation; hook for future variants.
     steel_conf = config.get("steel_beams", {})
     try:
@@ -624,9 +628,9 @@ def choose_blueprint(
             pitfall_zones=pitfall_zones,
         )
 
-        car_reachable = validate_connectivity(blueprint["grid"])
+        car_reachable = validate_connectivity(blueprint.grid)
         if car_reachable is not None:
-            blueprint["car_reachable_cells"] = car_reachable
+            blueprint.car_reachable_cells = car_reachable
             return blueprint
 
     raise MapGenerationError("Connectivity validation failed after 20 attempts")

zombie_escape/level_constants.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 DEFAULT_GRID_COLS = 48
 DEFAULT_GRID_ROWS = 30
-DEFAULT_TILE_SIZE = 50  # world units per cell; adjust to scale the whole map
+DEFAULT_CELL_SIZE = 50  # world units per cell; adjust to scale the whole map
 DEFAULT_WALL_LINES = 80  # reduced density (roughly 1/5 of previous 450)
 DEFAULT_GRID_WIRE_WALL_LINES = int(DEFAULT_WALL_LINES * 0.7)
 DEFAULT_SPARSE_WALL_DENSITY = 0.10
@@ -13,7 +13,7 @@ DEFAULT_STEEL_BEAM_CHANCE = 0.02
 __all__ = [
     "DEFAULT_GRID_COLS",
     "DEFAULT_GRID_ROWS",
-    "DEFAULT_TILE_SIZE",
+    "DEFAULT_CELL_SIZE",
     "DEFAULT_WALL_LINES",
     "DEFAULT_GRID_WIRE_WALL_LINES",
     "DEFAULT_SPARSE_WALL_DENSITY",

zombie_escape/locales/ui.en.json

@@ -9,14 +9,15 @@
     "fonts": {
       "primary": {
         "resource": "assets/fonts/Silkscreen-Regular.ttf",
-        "scale": 0.75
+        "scale": 0.75,
+        "line_height_scale": 1.0
       }
     },
     "menu": {
       "settings": "Settings",
       "quit": "Quit",
       "locked_suffix": "[Locked]",
-      "window_hint": "Resize window: [ to shrink, ] to enlarge.\nF: toggle fullscreen.",
+      "window_hint": "Resize window: [ to shrink by one step (400x300), ] to enlarge by one step.\nF: toggle fullscreen.",
       "seed_label": "Seed: %{value}",
       "seed_hint": "Type 0-9 to set a custom seed, Backspace clears",
       "seed_empty": "(auto)",
@@ -24,7 +25,7 @@
         "stage_select": "Stages",
         "resources": "Resources"
       },
-      "readme": "Open README",
+      "readme": "README/LICENSE",
       "readme_stage6": "Open Stage 6+ Guide",
       "hints": {
         "navigate": "Up/Down: choose an option",
@@ -34,7 +35,7 @@
       "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. License information is also available there.",
         "readme_stage6": "Open the Stage 6+ guide in your browser."
       }
     },
@@ -67,7 +68,8 @@
       },
       "stage5": {
         "name": "#5 Survive Until Dawn",
-        "description": "No fuel—endure 20 minutes, then walk out when dawn arrives."
+        "description": "No fuel—endure 20 minutes, then walk out when dawn arrives.",
+        "intro": "(No fuel inside, it seems...\nGuess I'll have to\nsurvive until dawn.)"
       },
       "stage6": {
         "name": "#6 Tracker Run",
@@ -94,6 +96,7 @@
       "stage10": {
         "name": "#10 Outbreak",
         "description": "Zombies have infiltrated a building where survivors took shelter.",
+        "intro": "(A large open floor,\npacked with survivors...\nI have a bad feeling about this.)",
         "survivor_conversion_messages": [
           "It hurts!",
           "I can't hold on!",
@@ -128,7 +131,8 @@
       },
       "stage15": {
         "name": "#15 The Divide",
-        "description": "A central hazard splits the building. Cross with care."
+        "description": "A central hazard splits the building. Cross with care.",
+        "intro": "A maintenance hatch looms faintly\nabove the center of the floor."
       },
       "stage16": {
         "name": "#16 Floor Collapse",
@@ -145,6 +149,11 @@
       "stage19": {
         "name": "#19 Corridors",
         "description": "A floor of narrow corridors."
+      },
+      "stage20": {
+        "name": "#20 Rescue Request",
+        "description": "Link up and escape by car.",
+        "intro": "\"... \nThey should be inside.\nLink up with them.\""
       }
     },
     "status": {
@@ -173,9 +182,9 @@
       "find_fuel": "Find the fuel can",
       "find_car": "Find the car",
       "escape": "Escape the building",
+      "merge_buddy_single": "Meet up with your buddy",
+      "merge_buddy_multi": "Meet up with your crew (Joined: %{count}/%{limit})",
       "pickup_buddy": "Pick up your buddy",
-      "find_buddy": "Find your buddy",
-      "escape_with_buddy": "Get your buddy in the car and escape",
       "board_buddy": "Get your buddy in the car",
       "buddy_onboard": "Buddy onboard: %{count}",
       "escape_with_survivors": "Escape with the survivors aboard",
@@ -188,6 +197,7 @@
         "menu": "Menu",
         "localization": "Localization",
         "player_support": "Player support",
+        "visual": "Visual",
         "tougher_enemies": "Tougher enemies"
       },
       "rows": {
@@ -195,6 +205,7 @@
         "language": "Language",
         "footprints": "Footprints",
         "car_hint": "Car hint",
+        "shadows": "Shadows",
         "fast_zombies": "Fast zombies",
         "steel_beams": "Steel beams"
       },