zombie-escape 1.7.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

zombie_escape/screens/title.py

@@ -14,6 +14,18 @@ from ..models import Stage
 from ..progress import load_progress
 from ..render import show_message
 from ..rng import generate_seed
+from ..input_utils import (
+    CONTROLLER_BUTTON_DOWN,
+    CONTROLLER_BUTTON_DPAD_DOWN,
+    CONTROLLER_BUTTON_DPAD_LEFT,
+    CONTROLLER_BUTTON_DPAD_RIGHT,
+    CONTROLLER_BUTTON_DPAD_UP,
+    CONTROLLER_DEVICE_ADDED,
+    CONTROLLER_DEVICE_REMOVED,
+    init_first_controller,
+    init_first_joystick,
+    is_confirm_event,
+)
 from ..screens import (
     ScreenID,
     ScreenTransition,
@@ -193,6 +205,8 @@ def title_screen(
         0,
     )
     selected = min(selected_stage_index, len(options) - 1)
+    controller = init_first_controller()
+    joystick = init_first_joystick() if controller is None else None
 
     while True:
         for event in pygame.event.get():
@@ -205,6 +219,22 @@ def title_screen(
             if event.type in (pygame.WINDOWSIZECHANGED, pygame.VIDEORESIZE):
                 sync_window_size(event)
                 continue
+            if event.type == pygame.JOYDEVICEADDED or (
+                CONTROLLER_DEVICE_ADDED is not None
+                and event.type == CONTROLLER_DEVICE_ADDED
+            ):
+                if controller is None:
+                    controller = init_first_controller()
+                if controller is None:
+                    joystick = init_first_joystick()
+            if event.type == pygame.JOYDEVICEREMOVED or (
+                CONTROLLER_DEVICE_REMOVED is not None
+                and event.type == CONTROLLER_DEVICE_REMOVED
+            ):
+                if controller and not controller.get_init():
+                    controller = None
+                if joystick and not joystick.get_init():
+                    joystick = None
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_BACKSPACE:
                     current_seed_text = _generate_auto_seed_text()
@@ -273,6 +303,87 @@ def title_screen(
                             seed_text=current_seed_text,
                             seed_is_auto=current_seed_auto,
                         )
+            if event.type == pygame.JOYBUTTONDOWN or (
+                CONTROLLER_BUTTON_DOWN is not None
+                and event.type == CONTROLLER_BUTTON_DOWN
+            ):
+                if is_confirm_event(event):
+                    current = options[selected]
+                    if current["type"] == "stage" and current.get("available"):
+                        seed_value = (
+                            int(current_seed_text) if current_seed_text else None
+                        )
+                        return ScreenTransition(
+                            ScreenID.GAMEPLAY,
+                            stage=current["stage"],
+                            seed=seed_value,
+                            seed_text=current_seed_text,
+                            seed_is_auto=current_seed_auto,
+                        )
+                    if current["type"] == "settings":
+                        return ScreenTransition(
+                            ScreenID.SETTINGS,
+                            seed_text=current_seed_text,
+                            seed_is_auto=current_seed_auto,
+                        )
+                    if current["type"] == "readme":
+                        _open_readme_link()
+                        continue
+                    if current["type"] == "quit":
+                        return ScreenTransition(
+                            ScreenID.EXIT,
+                            seed_text=current_seed_text,
+                            seed_is_auto=current_seed_auto,
+                        )
+                if CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN:
+                    if (
+                        CONTROLLER_BUTTON_DPAD_UP is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_UP
+                    ):
+                        selected = (selected - 1) % len(options)
+                    if (
+                        CONTROLLER_BUTTON_DPAD_DOWN is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_DOWN
+                    ):
+                        selected = (selected + 1) % len(options)
+                    if (
+                        CONTROLLER_BUTTON_DPAD_LEFT is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_LEFT
+                    ):
+                        if current_page > 0:
+                            current_page -= 1
+                            options, stage_options = _build_options(current_page)
+                            selected = 0
+                    if (
+                        CONTROLLER_BUTTON_DPAD_RIGHT is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_RIGHT
+                    ):
+                        if (
+                            current_page < len(stage_pages) - 1
+                            and _page_available(current_page + 1)
+                        ):
+                            current_page += 1
+                            options, stage_options = _build_options(current_page)
+                            selected = 0
+            if event.type == pygame.JOYHATMOTION:
+                hat_x, hat_y = event.value
+                if hat_y == 1:
+                    selected = (selected - 1) % len(options)
+                elif hat_y == -1:
+                    selected = (selected + 1) % len(options)
+                if hat_x == -1:
+                    if current_page > 0:
+                        current_page -= 1
+                        options, stage_options = _build_options(current_page)
+                        selected = 0
+                elif hat_x == 1:
+                    if (
+                        current_page < len(stage_pages) - 1
+                        and _page_available(current_page + 1)
+                    ):
+                        current_page += 1
+                        options, stage_options = _build_options(current_page)
+                        selected = 0
 
         screen.fill(BLACK)
         title_text = tr("game.title")

zombie_escape/stage_constants.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from .entities_constants import ZOMBIE_AGING_DURATION_FRAMES
 from .gameplay_constants import SURVIVOR_SPAWN_RATE
+from .level_constants import DEFAULT_GRID_COLS, DEFAULT_GRID_ROWS
 from .models import Stage
 
 STAGES: list[Stage] = [
@@ -23,6 +24,7 @@ STAGES: list[Stage] = [
         requires_fuel=True,
         exterior_spawn_weight=0.97,
         interior_spawn_weight=0.03,
+        initial_interior_spawn_rate=0.007,
     ),
     Stage(
         id="stage3",
@@ -33,6 +35,7 @@ STAGES: list[Stage] = [
         requires_fuel=True,
         exterior_spawn_weight=0.97,
         interior_spawn_weight=0.03,
+        initial_interior_spawn_rate=0.007,
     ),
     Stage(
         id="stage4",
@@ -42,6 +45,7 @@ STAGES: list[Stage] = [
         rescue_stage=True,
         waiting_car_target_count=2,
         survivor_spawn_rate=SURVIVOR_SPAWN_RATE,
+        initial_interior_spawn_rate=0.007,
     ),
     Stage(
         id="stage5",
@@ -49,8 +53,8 @@ STAGES: list[Stage] = [
         description_key="stages.stage5.description",
         available=True,
         requires_fuel=True,
-        survival_stage=True,
-        survival_goal_ms=1_200_000,
+        endurance_stage=True,
+        endurance_goal_ms=1_200_000,
         fuel_spawn_count=0,
         exterior_spawn_weight=0.4,
         interior_spawn_weight=0.6,
@@ -67,6 +71,7 @@ STAGES: list[Stage] = [
         zombie_normal_ratio=0.4,
         zombie_tracker_ratio=0.6,
         zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.01,
     ),
     Stage(
         id="stage7",
@@ -82,6 +87,7 @@ STAGES: list[Stage] = [
         zombie_tracker_ratio=0.3,
         zombie_wall_follower_ratio=0.3,
         zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.01,
     ),
     Stage(
         id="stage8",
@@ -97,20 +103,127 @@ STAGES: list[Stage] = [
         zombie_tracker_ratio=0.3,
         zombie_wall_follower_ratio=0.7,
         zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.01,
     ),
     Stage(
         id="stage9",
         name_key="stages.stage9.name",
         description_key="stages.stage9.description",
-        available=False,
+        available=True,
         rescue_stage=True,
         tile_size=35,
         requires_fuel=True,
         exterior_spawn_weight=0.4,
         interior_spawn_weight=0.6,
         waiting_car_target_count=1,
+        zombie_normal_ratio=0,
+        zombie_tracker_ratio=0.3,
+        zombie_wall_follower_ratio=0.7,
         survivor_spawn_rate=SURVIVOR_SPAWN_RATE,
         zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.01,
+    ),
+    Stage(
+        id="stage10",
+        name_key="stages.stage10.name",
+        description_key="stages.stage10.description",
+        available=True,
+        rescue_stage=True,
+        tile_size=40,
+        wall_algorithm="sparse",
+        exterior_spawn_weight=0.7,
+        interior_spawn_weight=0.3,
+        zombie_normal_ratio=0.4,
+        zombie_tracker_ratio=0.4,
+        zombie_wall_follower_ratio=0.2,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.02,
+        waiting_car_target_count=1,
+        survivor_spawn_rate=0.35,
+    ),
+    Stage(
+        id="stage11",
+        name_key="stages.stage11.name",
+        description_key="stages.stage11.description",
+        grid_cols=120,
+        grid_rows=7,
+        available=True,
+        wall_algorithm="sparse",
+        exterior_spawn_weight=0.3,
+        interior_spawn_weight=0.7,
+        zombie_normal_ratio=0.5,
+        zombie_tracker_ratio=0.5,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_interior_spawn_rate=0.1,
+        waiting_car_target_count=1,
+    ),
+    Stage(
+        id="stage12",
+        name_key="stages.stage12.name",
+        description_key="stages.stage12.description",
+        grid_cols=32,
+        grid_rows=32,
+        available=True,
+        requires_fuel=True,
+        exterior_spawn_weight=0.5,
+        interior_spawn_weight=0.2,
+        interior_fall_spawn_weight=0.3,
+        fall_spawn_zones=[
+            (3, 3, 12, 12),
+            (3, 17, 12, 12),
+            (17, 3, 12, 12),
+            (17, 17, 12, 12),
+        ],
+        initial_flashlight_count=5,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+    ),
+    Stage(
+        id="stage13",
+        name_key="stages.stage13.name",
+        description_key="stages.stage13.description",
+        available=True,
+        wall_algorithm="grid_wire",
+        buddy_required_count=1,
+        requires_fuel=True,
+        exterior_spawn_weight=0.6,
+        interior_spawn_weight=0.1,
+        interior_fall_spawn_weight=0.3,
+        zombie_normal_ratio=0.4,
+        zombie_tracker_ratio=0.3,
+        zombie_wall_follower_ratio=0.3,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+        initial_flashlight_count=3,
+        fall_spawn_zones=[
+            (x, y, 2, 2)
+            for y in range(2, DEFAULT_GRID_ROWS - 2, 4)
+            for x in range(2, DEFAULT_GRID_COLS - 2, 4)
+        ],
+    ),
+    Stage(
+        id="stage14",
+        name_key="stages.stage14.name",
+        description_key="stages.stage14.description",
+        grid_cols=42,
+        grid_rows=27,
+        available=False,
+        requires_fuel=True,
+        exterior_spawn_weight=0.2,
+        interior_spawn_weight=0.1,
+        interior_fall_spawn_weight=0.7,
+        fall_spawn_zones=[
+            (4, 10, 3, 3),
+            (5, 20, 3, 3),
+            (15, 17, 3, 3),
+            (22, 16, 3, 3),
+            (17, 20, 3, 3),
+            (26, 22, 3, 3),
+            (31, 17, 3, 3),
+            (33, 10, 3, 3),
+            (34, 7, 3, 3),
+            (35, 13, 3, 3),
+        ],
+        initial_flashlight_count=5,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
     ),
 ]
 DEFAULT_STAGE_ID = "stage1"

zombie_escape/world_grid.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import math
+from typing import Iterable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .entities import Wall
+
+
+WallIndex = dict[tuple[int, int], list["Wall"]]
+
+
+def build_wall_index(walls: Iterable["Wall"], *, cell_size: int) -> WallIndex:
+    index: WallIndex = {}
+    if cell_size <= 0:
+        return index
+    for wall in walls:
+        cell_x = int(wall.rect.centerx // cell_size)
+        cell_y = int(wall.rect.centery // cell_size)
+        index.setdefault((cell_x, cell_y), []).append(wall)
+    return index
+
+
+def _infer_grid_size_from_index(wall_index: WallIndex) -> tuple[int | None, int | None]:
+    if not wall_index:
+        return None, None
+    max_col = max(cell[0] for cell in wall_index)
+    max_row = max(cell[1] for cell in wall_index)
+    return max_col + 1, max_row + 1
+
+
+def walls_for_radius(
+    wall_index: WallIndex,
+    center: tuple[float, float],
+    radius: float,
+    *,
+    cell_size: int,
+    grid_cols: int | None = None,
+    grid_rows: int | None = None,
+) -> list["Wall"]:
+    if grid_cols is None or grid_rows is None:
+        grid_cols, grid_rows = _infer_grid_size_from_index(wall_index)
+    if grid_cols is None or grid_rows is None:
+        return []
+    search_radius = radius + cell_size
+    min_x = max(0, int((center[0] - search_radius) // cell_size))
+    max_x = min(grid_cols - 1, int((center[0] + search_radius) // cell_size))
+    min_y = max(0, int((center[1] - search_radius) // cell_size))
+    max_y = min(grid_rows - 1, int((center[1] + search_radius) // cell_size))
+    candidates: list[Wall] = []
+    for cy in range(min_y, max_y + 1):
+        for cx in range(min_x, max_x + 1):
+            candidates.extend(wall_index.get((cx, cy), []))
+    return candidates
+
+
+def apply_tile_edge_nudge(
+    x: float,
+    y: float,
+    dx: float,
+    dy: float,
+    *,
+    cell_size: int,
+    wall_cells: set[tuple[int, int]] | None,
+    bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] | None = None,
+    grid_cols: int,
+    grid_rows: int,
+    strength: float = 0.03,
+    edge_margin_ratio: float = 0.15,
+    min_margin: float = 2.0,
+) -> tuple[float, float]:
+    if dx == 0 and dy == 0:
+        return dx, dy
+    if cell_size <= 0 or not wall_cells:
+        return dx, dy
+    cell_x = int(x // cell_size)
+    cell_y = int(y // cell_size)
+    if cell_x < 0 or cell_y < 0 or cell_x >= grid_cols or cell_y >= grid_rows:
+        return dx, dy
+    speed = math.hypot(dx, dy)
+    if speed <= 0:
+        return dx, dy
+
+    edge_margin = max(min_margin, cell_size * edge_margin_ratio)
+    left_dist = x - (cell_x * cell_size)
+    right_dist = ((cell_x + 1) * cell_size) - x
+    top_dist = y - (cell_y * cell_size)
+    bottom_dist = ((cell_y + 1) * cell_size) - y
+
+    def apply_push(dist: float, direction: float) -> float:
+        if dist >= edge_margin:
+            return 0.0
+        ratio = (edge_margin - dist) / edge_margin
+        return ratio * speed * strength * direction
+
+    if (cell_x - 1, cell_y) in wall_cells:
+        dx += apply_push(left_dist, 1.0)
+    if (cell_x + 1, cell_y) in wall_cells:
+        dx += apply_push(right_dist, -1.0)
+    if (cell_x, cell_y - 1) in wall_cells:
+        dy += apply_push(top_dist, 1.0)
+    if (cell_x, cell_y + 1) in wall_cells:
+        dy += apply_push(bottom_dist, -1.0)
+
+    def apply_corner_push(dist_a: float, dist_b: float, boost: float = 1.0) -> float:
+        if dist_a >= edge_margin or dist_b >= edge_margin:
+            return 0.0
+        ratio = (edge_margin - min(dist_a, dist_b)) / edge_margin
+        return ratio * speed * strength * boost
+
+    if bevel_corners:
+        boosted = 1.25
+        corner_wall = bevel_corners.get((cell_x - 1, cell_y - 1))
+        if corner_wall and corner_wall[2]:
+            push = apply_corner_push(left_dist, top_dist, boosted)
+            dx += push
+            dy += push
+        corner_wall = bevel_corners.get((cell_x + 1, cell_y - 1))
+        if corner_wall and corner_wall[3]:
+            push = apply_corner_push(right_dist, top_dist, boosted)
+            dx -= push
+            dy += push
+        corner_wall = bevel_corners.get((cell_x + 1, cell_y + 1))
+        if corner_wall and corner_wall[0]:
+            push = apply_corner_push(right_dist, bottom_dist, boosted)
+            dx -= push
+            dy -= push
+        corner_wall = bevel_corners.get((cell_x - 1, cell_y + 1))
+        if corner_wall and corner_wall[1]:
+            push = apply_corner_push(left_dist, bottom_dist, boosted)
+            dx += push
+            dy -= push
+
+    return dx, dy

zombie_escape/zombie_escape.py

@@ -22,7 +22,7 @@ from .gameplay import calculate_car_speed_for_passengers
 from .level_constants import DEFAULT_TILE_SIZE
 from .localization import set_language
 from .models import GameData, Stage
-from .render_constants import build_render_assets
+from .render_constants import RenderAssets, build_render_assets
 from .screen_constants import (
     DEFAULT_WINDOW_SCALE,
     FPS,
@@ -83,6 +83,9 @@ def main() -> None:
     sys.argv = [sys.argv[0]] + remaining
 
     pygame.init()
+    pygame.joystick.init()
+    if hasattr(pygame, "controller"):
+        pygame.controller.init()
     try:
         pygame.font.init()
     except pygame.error as e:
@@ -92,6 +95,7 @@ def main() -> None:
     from .screens.gameplay import gameplay_screen
 
     apply_window_scale(DEFAULT_WINDOW_SCALE)
+    pygame.mouse.set_visible(True)
     screen = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT)).convert_alpha()
     clock = pygame.time.Clock()
 
@@ -106,15 +110,54 @@ def main() -> None:
         save_config(config, config_path)
     set_language(config.get("language"))
 
+    def _profiled_gameplay_screen(
+        screen: pygame.Surface,
+        clock: pygame.time.Clock,
+        config: dict[str, Any],
+        fps: int,
+        stage: Stage,
+        *,
+        show_pause_overlay: bool,
+        seed: int | None,
+        render_assets: RenderAssets,
+        debug_mode: bool,
+    ) -> ScreenTransition:
+        import cProfile
+        import pstats
+
+        profiler = cProfile.Profile()
+        try:
+            return profiler.runcall(
+                gameplay_screen,
+                screen,
+                clock,
+                config,
+                fps,
+                stage,
+                show_pause_overlay=show_pause_overlay,
+                seed=seed,
+                render_assets=render_assets,
+                debug_mode=debug_mode,
+            )
+        finally:
+            output_path = Path(args.profile_output)
+            profiler.dump_stats(output_path)
+            summary_path = output_path.with_suffix(".txt")
+            with summary_path.open("w", encoding="utf-8") as handle:
+                stats = pstats.Stats(
+                    profiler,
+                    stream=handle,
+                ).sort_stats("tottime")
+                stats.print_stats(50)
+            print(f"Profile saved to {output_path} and {summary_path}")
+
     next_screen = ScreenID.TITLE
-    pending_stage: Stage | None = None
-    pending_game_data: GameData | None = None
-    pending_config: dict[str, Any] | None = None
-    pending_seed: int | None = None
+    transition: ScreenTransition | None = None
     running = True
 
     while running:
-        transition: ScreenTransition | None = None
+        incoming = transition
+        transition = None
 
         if next_screen == ScreenID.TITLE:
             seed_input = None if title_seed_is_auto else title_seed_text
@@ -144,56 +187,26 @@ def main() -> None:
             set_language(config.get("language"))
             transition = ScreenTransition(ScreenID.TITLE)
         elif next_screen == ScreenID.GAMEPLAY:
-            stage = pending_stage
-            pending_stage = None
-            seed_value = pending_seed
-            pending_seed = None
+            stage = incoming.stage
+            seed_value = incoming.seed
             if stage is None:
                 transition = ScreenTransition(ScreenID.TITLE)
             else:
                 last_stage_id = stage.id
+                render_assets = build_render_assets(stage.tile_size)
                 try:
-                    if args.profile:
-                        import cProfile
-                        import pstats
-
-                        profiler = cProfile.Profile()
-                        try:
-                            render_assets = build_render_assets(stage.tile_size)
-                            transition = profiler.runcall(
-                                gameplay_screen,
-                                screen,
-                                clock,
-                                config,
-                                FPS,
-                                stage,
-                                show_pause_overlay=not debug_mode,
-                                seed=seed_value,
-                                render_assets=render_assets,
-                                debug_mode=debug_mode,
-                            )
-                        finally:
-                            output_path = Path(args.profile_output)
-                            profiler.dump_stats(output_path)
-                            summary_path = output_path.with_suffix(".txt")
-                            stats = pstats.Stats(profiler).sort_stats("tottime")
-                            with summary_path.open("w", encoding="utf-8") as handle:
-                                stats.stream = handle
-                                stats.print_stats(50)
-                            print(f"Profile saved to {output_path} and {summary_path}")
-                    else:
-                        render_assets = build_render_assets(stage.tile_size)
-                        transition = gameplay_screen(
-                            screen,
-                            clock,
-                            config,
-                            FPS,
-                            stage,
-                            show_pause_overlay=not debug_mode,
-                            seed=seed_value,
-                            render_assets=render_assets,
-                            debug_mode=debug_mode,
-                        )
+                    gs = _profiled_gameplay_screen if args.profile else gameplay_screen
+                    transition = gs(
+                        screen,
+                        clock,
+                        config,
+                        FPS,
+                        stage,
+                        show_pause_overlay=not debug_mode,
+                        seed=seed_value,
+                        render_assets=render_assets,
+                        debug_mode=debug_mode,
+                    )
                 except SystemExit:
                     running = False
                     break
@@ -203,12 +216,10 @@ def main() -> None:
                     running = False
                     break
         elif next_screen == ScreenID.GAME_OVER:
-            game_data = pending_game_data
-            stage = pending_stage
-            config_payload = pending_config
-            pending_game_data = None
-            pending_stage = None
-            pending_config = None
+            game_data = incoming.game_data if incoming else None
+            stage = incoming.stage if incoming else None
+            config_payload = incoming.config if incoming else None
+            assert config_payload is not None
             if game_data is not None:
                 render_assets = build_render_assets(game_data.cell_size)
             elif stage is not None:
@@ -232,10 +243,6 @@ def main() -> None:
         if not transition:
             break
 
-        pending_stage = transition.stage
-        pending_game_data = transition.game_data
-        pending_config = transition.config
-        pending_seed = transition.seed
         if transition.next_screen == ScreenID.GAMEPLAY:
             title_seed_text = cli_seed_text
             title_seed_is_auto = cli_seed_is_auto

{zombie_escape-1.7.1.dist-info → zombie_escape-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.7.1
+Version: 1.10.0
 Summary: Top-down zombie survival game built with pygame.
 Project-URL: Homepage, https://github.com/tos-kamiya/zombie-escape
 Author-email: Toshihiro Kamiya <kamiya@mbj.nifty.com>
@@ -12,12 +12,19 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.10
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Requires-Dist: pygame
 Requires-Dist: python-i18n
+Requires-Dist: typing-extensions; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: pydeps; extra == 'dev'
+Requires-Dist: pyright; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Zombie Escape
@@ -46,10 +53,11 @@ This game is a simple 2D top-down action game where the player aims to escape by
 
 -   **Player/Car Movement:** `W` / `↑` (Up), `A` / `←` (Left), `S` / `↓` (Down), `D` / `→` (Right)
 -   **Enter Car:** Overlap the player with the car.
--   **Quit Game:** `ESC` key
+-   **Pause:** `P`/Start or `ESC`/Select
+-   **Quit Game:** `ESC`/Select (from pause)
 -   **Restart:** `R` key (on Game Over/Clear screen)
 -   **Window/Fullscreen (title/settings only):** `[` to shrink, `]` to enlarge, `F` to toggle fullscreen
--   **Time Acceleration:** Hold either `Shift` key to run the entire world 4x faster; release to return to normal speed.
+-   **Time Acceleration:** Hold either `Shift` key or `R1` to run the entire world 4x faster; release to return to normal speed.
 
 ## Title Screen