zombie-escape 1.3.5__tar.gz → 1.3.6__tar.gz

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.3.5
+Version: 1.3.6
 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>

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.3.5"
+__version__ = "1.3.6"

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/entities.py

@@ -623,10 +623,24 @@ class Zombie(pygame.sprite.Sprite):
 
 
 class Car(pygame.sprite.Sprite):
-    def __init__(self: Self, x: int, y: int) -> None:
+    COLOR_SCHEMES: dict[str, dict[str, tuple[int, int, int]]] = {
+        "default": {
+            "healthy": YELLOW,
+            "damaged": ORANGE,
+            "critical": DARK_RED,
+        },
+        "disabled": {
+            "healthy": (185, 185, 185),
+            "damaged": (150, 150, 150),
+            "critical": (110, 110, 110),
+        },
+    }
+
+    def __init__(self: Self, x: int, y: int, *, appearance: str = "default") -> None:
         super().__init__()
         self.original_image = pygame.Surface((CAR_WIDTH, CAR_HEIGHT), pygame.SRCALPHA)
-        self.base_color = YELLOW
+        self.appearance = appearance if appearance in self.COLOR_SCHEMES else "default"
+        self.base_color = self.COLOR_SCHEMES[self.appearance]["healthy"]
         self.image = self.original_image.copy()
         self.rect = self.image.get_rect(center=(x, y))
         self.speed = CAR_SPEED
@@ -645,11 +659,12 @@ class Car(pygame.sprite.Sprite):
 
     def update_color(self: Self) -> None:
         health_ratio = max(0, self.health / self.max_health)
-        color = YELLOW
+        palette = self.COLOR_SCHEMES.get(self.appearance, self.COLOR_SCHEMES["default"])
+        color = palette["healthy"]
         if health_ratio < 0.6:
-            color = ORANGE
+            color = palette["damaged"]
         if health_ratio < 0.3:
-            color = DARK_RED
+            color = palette["critical"]
         self.original_image.fill((0, 0, 0, 0))
 
         body_rect = pygame.Rect(1, 4, CAR_WIDTH - 2, CAR_HEIGHT - 8)

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/gameplay/logic.py

@@ -79,6 +79,10 @@ from ..entities import (
 LOGICAL_SCREEN_RECT = pygame.Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)
 RNG = get_rng()
 
+
+def car_appearance_for_stage(stage: Stage | None) -> str:
+    return "disabled" if stage and stage.survival_stage else "default"
+
 __all__ = [
     "create_zombie",
     "rect_for_cell",
@@ -276,6 +280,7 @@ def place_new_car(
     walkable_cells: list[pygame.Rect],
     *,
     existing_cars: Sequence[Car] | None = None,
+    appearance: str = "default",
 ) -> Car | None:
     if not walkable_cells:
         return None
@@ -284,7 +289,7 @@ def place_new_car(
     for attempt in range(max_attempts):
         cell = RNG.choice(walkable_cells)
         c_x, c_y = cell.center
-        temp_car = Car(c_x, c_y)
+        temp_car = Car(c_x, c_y, appearance=appearance)
         temp_rect = temp_car.rect.inflate(30, 30)
         nearby_walls = pygame.sprite.Group()
         nearby_walls.add(
@@ -628,6 +633,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
     if active_car:
         obstacles.append(active_car)
     camera = game_data.camera
+    appearance = car_appearance_for_stage(game_data.stage)
     offscreen_attempts = 6
     while offscreen_attempts > 0:
         new_car = place_new_car(
@@ -635,6 +641,7 @@ def spawn_waiting_car(game_data: GameData) -> Car | None:
             player,
             walkable_cells,
             existing_cars=obstacles,
+            appearance=appearance,
         )
         if not new_car:
             return None
@@ -989,6 +996,7 @@ def setup_player_and_cars(
 
     car_candidates = list(layout_data["car_cells"] or walkable_cells)
     waiting_cars: list[Car] = []
+    car_appearance = car_appearance_for_stage(game_data.stage)
 
     def _pick_car_position() -> tuple[int, int]:
         """Favor distant cells for the first car, otherwise fall back to random picks."""
@@ -1011,7 +1019,7 @@ def setup_player_and_cars(
 
     for idx in range(max(1, car_count)):
         car_pos = _pick_car_position()
-        car = Car(*car_pos)
+        car = Car(*car_pos, appearance=car_appearance)
         waiting_cars.append(car)
         all_sprites.add(car, layer=1)
         if not car_candidates:

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/locales/ui.en.json

@@ -19,7 +19,21 @@
       "window_hint": "Resize window: [ to shrink, ] to enlarge (menu only)",
       "seed_label": "Seed: %{value}",
       "seed_hint": "Type 0-9 to set a custom seed, Backspace clears",
-      "seed_empty": "(auto)"
+      "seed_empty": "(auto)",
+      "sections": {
+        "stage_select": "Stages",
+        "resources": "Resources"
+      },
+      "readme": "Open README",
+      "hints": {
+        "navigate": "Up/Down: choose an option",
+        "confirm": "Enter/Space: activate selection"
+      },
+      "option_help": {
+        "settings": "Open Settings to adjust assists and localization.",
+        "quit": "Close the game.",
+        "readme": "Open the GitHub README in your browser."
+      }
     },
     "stages": {
       "stage1": {

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/locales/ui.ja.json

@@ -19,7 +19,21 @@
       "window_hint": "[キーでウィンドウを小さく、]キーで大きく(メニュー画面のみ)",
       "seed_label": "シード: %{value}",
       "seed_hint": "数字キーで入力、BSでクリア",
-      "seed_empty": "(自動)"
+      "seed_empty": "(自動)",
+      "sections": {
+        "stage_select": "ステージ",
+        "resources": "リソース"
+      },
+      "readme": "README を開く",
+      "hints": {
+        "navigate": "↑↓: 項目選択",
+        "confirm": "Enter/Space: 決定または実行"
+      },
+      "option_help": {
+        "settings": "設定画面を開いて言語や補助オプションを変更します。",
+        "quit": "ゲームを終了します。",
+        "readme": "GitHub の README ページをブラウザで開きます。"
+      }
     },
     "stages": {
       "stage1": {
@@ -44,7 +58,7 @@
         }
       },
       "stage5": {
-        "name": "#5 朝まで耐えろ",
+        "name": "#5 持久戦",
         "description": "燃料なし。20分耐え、夜明けになったら徒歩で脱出せよ。"
       }
     },

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/screens/game_over.py

@@ -6,7 +6,6 @@ import pygame
 from pygame import surface, time
 
 from ..colors import BLACK, GREEN, LIGHT_GRAY, RED, WHITE
-from ..font_utils import load_font
 from ..localization import translate as tr
 from ..models import GameData, Stage
 from ..render import (

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/screens/gameplay.py

@@ -271,7 +271,6 @@ def gameplay_screen(
         player = game_data.player
         if player is None:
             raise ValueError("Player missing from game data")
-        car = game_data.car
 
         car_hint_conf = config.get("car_hint", {})
         hint_delay = car_hint_conf.get("delay_ms", CAR_HINT_DELAY_MS_DEFAULT)

{zombie_escape-1.3.5 → zombie_escape-1.3.6}/src/zombie_escape/screens/settings.py

@@ -212,27 +212,29 @@ def settings_screen(
         try:
             font_settings = get_font_settings()
             label_font = load_font(
-                font_settings.resource, font_settings.scaled_size(11)
+                font_settings.resource, font_settings.scaled_size(13)
             )
             value_font = load_font(
-                font_settings.resource, font_settings.scaled_size(11)
+                font_settings.resource, font_settings.scaled_size(13)
             )
             section_font = load_font(
-                font_settings.resource, font_settings.scaled_size(11)
+                font_settings.resource, font_settings.scaled_size(12)
             )
             highlight_color = (70, 70, 70)
 
-            row_height = 18
-            start_y = 44
+            row_height = 22
+            start_y = 52
 
-            segment_width = 26
-            segment_height = 16
-            segment_gap = 8
+            segment_width = 30
+            segment_height = 18
+            segment_gap = 10
             segment_total_width = segment_width * 2 + segment_gap
 
-            column_margin = 20
+            column_margin = 24
             column_width = screen_width // 2 - column_margin * 2
             section_spacing = 6
+            row_indent = 12
+            value_padding = 20
 
             section_states: dict[str, dict] = {}
             y_cursor = start_y
@@ -258,7 +260,8 @@ def settings_screen(
             for idx, row in enumerate(rows):
                 section_label = row_sections[idx]
                 state = section_states[section_label]
-                col_x = column_margin
+                col_x = column_margin + row_indent
+                row_width = column_width - row_indent + value_padding
                 value = _get_value(
                     row["path"], row.get("easy_value", row.get("choices", [None])[0])
                 )
@@ -266,7 +269,7 @@ def settings_screen(
                 state["next_y"] += row_height
 
                 highlight_rect = pygame.Rect(
-                    col_x, row_y_current - 2, column_width, row_height - 4
+                    col_x, row_y_current - 2, row_width, row_height - 4
                 )
                 if idx == selected:
                     pygame.draw.rect(screen, highlight_color, highlight_rect)
@@ -289,14 +292,14 @@ def settings_screen(
                     value_surface = value_font.render(display_text, False, WHITE)
                     value_rect = value_surface.get_rect(
                         midright=(
-                            col_x + column_width,
+                            col_x + row_width,
                             row_y_current + row_height // 2,
                         )
                     )
                     screen.blit(value_surface, value_rect)
                 else:
                     slider_y = row_y_current + (row_height - segment_height) // 2 - 2
-                    slider_x = col_x + column_width - segment_total_width
+                    slider_x = col_x + row_width - segment_total_width
                     left_rect = pygame.Rect(
                         slider_x, slider_y, segment_width, segment_height
                     )

zombie_escape-1.3.6/src/zombie_escape/screens/title.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+import webbrowser
+from typing import Any, Sequence
+
+import pygame
+from pygame import surface, time
+
+from ..colors import BLACK, GRAY, LIGHT_GRAY, WHITE, YELLOW
+from ..font_utils import load_font
+from ..localization import get_font_settings, get_language, translate as tr
+from ..models import Stage
+from ..render import show_message
+from ..screens import ScreenID, ScreenTransition, nudge_window_scale, present
+from ..rng import generate_seed
+
+MAX_SEED_DIGITS = 19
+README_URLS: dict[str, str] = {
+    "en": "https://github.com/tos-kamiya/zombie-escape/blob/main/README.md",
+    "ja": "https://github.com/tos-kamiya/zombie-escape/blob/main/README-ja_JP.md",
+}
+
+
+def _open_readme_link() -> None:
+    """Open the GitHub README for the active UI language."""
+
+    language = get_language()
+    url = README_URLS.get(language, README_URLS["en"])
+    try:
+        webbrowser.open(url, new=0, autoraise=True)
+    except Exception as exc:  # pragma: no cover - best effort only
+        print(f"Unable to open README URL {url}: {exc}")
+
+
+def _wrap_long_segment(
+    segment: str, font: pygame.font.Font, max_width: int
+) -> list[str]:
+    lines: list[str] = []
+    current = ""
+    for char in segment:
+        candidate = current + char
+        if font.size(candidate)[0] <= max_width or not current:
+            current = candidate
+        else:
+            lines.append(current)
+            current = char
+    if current:
+        lines.append(current)
+    return lines
+
+
+def _wrap_text(text: str, font: pygame.font.Font, max_width: int) -> list[str]:
+    """Break text into multiple lines within a max width (supports CJK text)."""
+
+    if max_width <= 0:
+        return [text]
+    paragraphs = text.splitlines() or [text]
+    lines: list[str] = []
+    for paragraph in paragraphs:
+        if not paragraph:
+            lines.append("")
+            continue
+        words = paragraph.split(" ")
+        if len(words) == 1:
+            lines.extend(_wrap_long_segment(paragraph, font, max_width))
+            continue
+        current = ""
+        for word in words:
+            candidate = f"{current} {word}".strip() if current else word
+            if font.size(candidate)[0] <= max_width:
+                current = candidate
+                continue
+            if current:
+                lines.append(current)
+            if font.size(word)[0] <= max_width:
+                current = word
+            else:
+                lines.extend(_wrap_long_segment(word, font, max_width))
+                current = ""
+        if current:
+            lines.append(current)
+    return lines
+
+
+def _blit_wrapped_text(
+    target: surface.Surface,
+    text: str,
+    font: pygame.font.Font,
+    color: tuple[int, int, int],
+    topleft: tuple[int, int],
+    max_width: int,
+) -> None:
+    """Render text with simple wrapping constrained to max_width."""
+
+    x, y = topleft
+    line_height = font.get_linesize()
+    for line in _wrap_text(text, font, max_width):
+        if not line:
+            y += line_height
+            continue
+        rendered = font.render(line, False, color)
+        target.blit(rendered, (x, y))
+        y += line_height
+
+
+def _generate_auto_seed_text() -> str:
+    raw = generate_seed()
+    trimmed = raw // 100  # drop lower 2 digits for stability
+    return str(trimmed % 100000).zfill(5)
+
+
+def title_screen(
+    screen: surface.Surface,
+    clock: time.Clock,
+    config: dict[str, Any],
+    fps: int,
+    *,
+    stages: Sequence[Stage],
+    default_stage_id: str,
+    screen_size: tuple[int, int],
+    seed_text: str | None = None,
+    seed_is_auto: bool = False,
+) -> ScreenTransition:
+    """Display the title menu and return the selected transition."""
+
+    width, height = screen_size
+    options: list[dict] = [
+        {"type": "stage", "stage": stage, "available": stage.available}
+        for stage in stages
+        if stage.available
+    ]
+    action_options: list[dict[str, Any]] = [
+        {"type": "settings"},
+        {"type": "readme"},
+        {"type": "quit"},
+    ]
+    options += action_options
+
+    selected_stage_index = next(
+        (
+            i
+            for i, opt in enumerate(options)
+            if opt["type"] == "stage" and opt["stage"].id == default_stage_id
+        ),
+        0,
+    )
+    selected = min(selected_stage_index, len(options) - 1)
+    generated = seed_text is None
+    current_seed_text = seed_text if seed_text is not None else _generate_auto_seed_text()
+    current_seed_auto = seed_is_auto or generated
+
+    while True:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                return ScreenTransition(
+                    ScreenID.EXIT,
+                    seed_text=current_seed_text,
+                    seed_is_auto=current_seed_auto,
+                )
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_BACKSPACE:
+                    current_seed_text = _generate_auto_seed_text()
+                    current_seed_auto = True
+                    continue
+                if event.unicode and event.unicode.isdigit():
+                    if current_seed_auto:
+                        current_seed_text = ""
+                        current_seed_auto = False
+                    if len(current_seed_text) < MAX_SEED_DIGITS:
+                        current_seed_text += event.unicode
+                    continue
+                if event.key == pygame.K_LEFTBRACKET:
+                    nudge_window_scale(0.5)
+                    continue
+                if event.key == pygame.K_RIGHTBRACKET:
+                    nudge_window_scale(2.0)
+                    continue
+                if event.key in (pygame.K_UP, pygame.K_w):
+                    selected = (selected - 1) % len(options)
+                elif event.key in (pygame.K_DOWN, pygame.K_s):
+                    selected = (selected + 1) % len(options)
+                elif event.key in (pygame.K_RETURN, pygame.K_SPACE):
+                    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,
+                        )
+
+        screen.fill(BLACK)
+        show_message(screen, tr("game.title"), 32, LIGHT_GRAY, (width // 2, 40))
+
+        try:
+            font_settings = get_font_settings()
+            option_font = load_font(
+                font_settings.resource, font_settings.scaled_size(14)
+            )
+            desc_font = load_font(font_settings.resource, font_settings.scaled_size(11))
+            section_font = load_font(
+                font_settings.resource, font_settings.scaled_size(12)
+            )
+            hint_font = load_font(font_settings.resource, font_settings.scaled_size(11))
+
+            row_height = 22
+            stage_column_x = 24
+            stage_column_width = width // 2 - 48
+            resource_column_x = width // 2 + 12
+            resource_column_width = width - resource_column_x - 24
+            section_top = 70
+            highlight_color = (70, 70, 70)
+
+            stage_options = [opt for opt in options if opt["type"] == "stage"]
+            stage_count = len(stage_options)
+            resource_count = len(options) - stage_count
+
+            stage_header = section_font.render(
+                tr("menu.sections.stage_select"), False, LIGHT_GRAY
+            )
+            stage_header_pos = (stage_column_x, section_top)
+            screen.blit(stage_header, stage_header_pos)
+            stage_rows_start = stage_header_pos[1] + stage_header.get_height() + 6
+
+            resource_header = section_font.render(
+                tr("menu.sections.resources"), False, LIGHT_GRAY
+            )
+            resource_header_pos = (resource_column_x, section_top)
+            screen.blit(resource_header, resource_header_pos)
+            resource_rows_start = (
+                resource_header_pos[1] + resource_header.get_height() + 6
+            )
+
+            for idx, option in enumerate(stage_options):
+                row_top = stage_rows_start + idx * row_height
+                highlight_rect = pygame.Rect(
+                    stage_column_x, row_top - 2, stage_column_width, row_height
+                )
+                color = YELLOW if idx == selected else WHITE
+                if idx == selected:
+                    pygame.draw.rect(screen, highlight_color, highlight_rect)
+                label = option["stage"].name
+                if not option.get("available"):
+                    locked_suffix = tr("menu.locked_suffix")
+                    label = f"{label} {locked_suffix}"
+                    color = GRAY
+                text_surface = option_font.render(label, False, color)
+                text_rect = text_surface.get_rect(
+                    midleft=(
+                        stage_column_x + 8,
+                        row_top + row_height // 2,
+                    )
+                )
+                screen.blit(text_surface, text_rect)
+
+            for idx, option in enumerate(action_options):
+                option_idx = stage_count + idx
+                row_top = resource_rows_start + idx * row_height
+                highlight_rect = pygame.Rect(
+                    resource_column_x, row_top - 2, resource_column_width, row_height
+                )
+                is_selected = option_idx == selected
+                if is_selected:
+                    pygame.draw.rect(screen, highlight_color, highlight_rect)
+                if option["type"] == "settings":
+                    label = tr("menu.settings")
+                elif option["type"] == "readme":
+                    label = f"> {tr('menu.readme')}"
+                else:
+                    label = tr("menu.quit")
+                color = YELLOW if is_selected else WHITE
+                text_surface = option_font.render(label, False, color)
+                text_rect = text_surface.get_rect(
+                    midleft=(
+                        resource_column_x + 8,
+                        row_top + row_height // 2,
+                    )
+                )
+                screen.blit(text_surface, text_rect)
+
+            current = options[selected]
+            desc_area_top = stage_rows_start + stage_count * row_height + 12
+            if current["type"] == "stage":
+                desc_color = LIGHT_GRAY if current.get("available") else GRAY
+                _blit_wrapped_text(
+                    screen,
+                    current["stage"].description,
+                    desc_font,
+                    desc_color,
+                    (stage_column_x, desc_area_top),
+                    stage_column_width,
+                )
+
+            option_help_top = resource_rows_start + resource_count * row_height + 12
+            help_text = ""
+            if current["type"] == "settings":
+                help_text = tr("menu.option_help.settings")
+            elif current["type"] == "quit":
+                help_text = tr("menu.option_help.quit")
+            elif current["type"] == "readme":
+                help_text = tr("menu.option_help.readme")
+
+            if help_text:
+                _blit_wrapped_text(
+                    screen,
+                    help_text,
+                    desc_font,
+                    LIGHT_GRAY,
+                    (resource_column_x, option_help_top),
+                    resource_column_width,
+                )
+
+            hint_lines = [tr("menu.hints.navigate"), tr("menu.hints.confirm")]
+            hint_start_y = height - 96
+            for offset, line in enumerate(hint_lines):
+                hint_surface = hint_font.render(line, False, LIGHT_GRAY)
+                hint_rect = hint_surface.get_rect(
+                    topleft=(resource_column_x, hint_start_y + offset * 18)
+                )
+                screen.blit(hint_surface, hint_rect)
+
+            window_hint = tr("menu.window_hint")
+            window_hint_surface = hint_font.render(window_hint, False, LIGHT_GRAY)
+            window_hint_rect = window_hint_surface.get_rect(
+                center=(width // 2, height - 46)
+            )
+            screen.blit(window_hint_surface, window_hint_rect)
+
+            seed_font = load_font(font_settings.resource, font_settings.scaled_size(12))
+            seed_value_display = (
+                current_seed_text if current_seed_text else tr("menu.seed_empty")
+            )
+            seed_label = tr("menu.seed_label", value=seed_value_display)
+            seed_surface = seed_font.render(seed_label, False, LIGHT_GRAY)
+            seed_rect = seed_surface.get_rect(right=width - 14, bottom=height - 12)
+            screen.blit(seed_surface, seed_rect)
+
+            seed_hint = tr("menu.seed_hint")
+            seed_hint_surface = hint_font.render(seed_hint, False, GRAY)
+            seed_hint_rect = seed_hint_surface.get_rect(left=14, bottom=height - 12)
+            screen.blit(seed_hint_surface, seed_hint_rect)
+        except pygame.error as e:
+            print(f"Error rendering title screen: {e}")
+
+        present(screen)
+        clock.tick(fps)

zombie_escape-1.3.5/src/zombie_escape/screens/title.py

@@ -1,186 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Sequence
-
-import pygame
-from pygame import surface, time
-
-from ..colors import BLACK, GRAY, LIGHT_GRAY, WHITE, YELLOW
-from ..font_utils import load_font
-from ..localization import get_font_settings, translate as tr
-from ..models import Stage
-from ..render import show_message
-from ..screens import ScreenID, ScreenTransition, nudge_window_scale, present
-from ..rng import generate_seed
-
-MAX_SEED_DIGITS = 19
-
-
-def _generate_auto_seed_text() -> str:
-    raw = generate_seed()
-    trimmed = raw // 100  # drop lower 2 digits for stability
-    return str(trimmed % 100000).zfill(5)
-
-
-def title_screen(
-    screen: surface.Surface,
-    clock: time.Clock,
-    config: dict[str, Any],
-    fps: int,
-    *,
-    stages: Sequence[Stage],
-    default_stage_id: str,
-    screen_size: tuple[int, int],
-    seed_text: str | None = None,
-    seed_is_auto: bool = False,
-) -> ScreenTransition:
-    """Display the title menu and return the selected transition."""
-
-    width, height = screen_size
-    options: list[dict] = [
-        {"type": "stage", "stage": stage, "available": stage.available}
-        for stage in stages
-        if stage.available
-    ]
-    options += [{"type": "settings"}, {"type": "quit"}]
-
-    selected = next(
-        (
-            i
-            for i, opt in enumerate(options)
-            if opt["type"] == "stage" and opt["stage"].id == default_stage_id
-        ),
-        0,
-    )
-    generated = seed_text is None
-    current_seed_text = seed_text if seed_text is not None else _generate_auto_seed_text()
-    current_seed_auto = seed_is_auto or generated
-
-    while True:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                return ScreenTransition(
-                    ScreenID.EXIT,
-                    seed_text=current_seed_text,
-                    seed_is_auto=current_seed_auto,
-                )
-            if event.type == pygame.KEYDOWN:
-                if event.key == pygame.K_BACKSPACE:
-                    current_seed_text = _generate_auto_seed_text()
-                    current_seed_auto = True
-                    continue
-                if event.unicode and event.unicode.isdigit():
-                    if current_seed_auto:
-                        current_seed_text = ""
-                        current_seed_auto = False
-                    if len(current_seed_text) < MAX_SEED_DIGITS:
-                        current_seed_text += event.unicode
-                    continue
-                if event.key == pygame.K_LEFTBRACKET:
-                    nudge_window_scale(0.5)
-                    continue
-                if event.key == pygame.K_RIGHTBRACKET:
-                    nudge_window_scale(2.0)
-                    continue
-                if event.key in (pygame.K_UP, pygame.K_w):
-                    selected = (selected - 1) % len(options)
-                elif event.key in (pygame.K_DOWN, pygame.K_s):
-                    selected = (selected + 1) % len(options)
-                elif event.key in (pygame.K_RETURN, pygame.K_SPACE):
-                    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"] == "quit":
-                        return ScreenTransition(
-                            ScreenID.EXIT,
-                            seed_text=current_seed_text,
-                            seed_is_auto=current_seed_auto,
-                        )
-
-        screen.fill(BLACK)
-        show_message(
-            screen,
-            tr("game.title"),
-            32,
-            LIGHT_GRAY,
-            (width // 2, 40),
-        )
-
-        try:
-            font_settings = get_font_settings()
-            font = load_font(font_settings.resource, font_settings.scaled_size(18))
-            line_height = 18
-            start_y = 84
-            for idx, option in enumerate(options):
-                if option["type"] == "stage":
-                    label = option["stage"].name
-                    if not option.get("available"):
-                        locked_suffix = tr("menu.locked_suffix")
-                        label += f" {locked_suffix}"
-                    color = (
-                        YELLOW
-                        if idx == selected
-                        else (WHITE if option.get("available") else GRAY)
-                    )
-                elif option["type"] == "settings":
-                    label = tr("menu.settings")
-                    color = YELLOW if idx == selected else WHITE
-                else:
-                    label = tr("menu.quit")
-                    color = YELLOW if idx == selected else WHITE
-
-                text_surface = font.render(label, False, color)
-                text_rect = text_surface.get_rect(
-                    center=(width // 2, start_y + idx * line_height)
-                )
-                screen.blit(text_surface, text_rect)
-
-            current = options[selected]
-            if current["type"] == "stage":
-                desc_font = load_font(
-                    font_settings.resource, font_settings.scaled_size(11)
-                )
-                desc_color = LIGHT_GRAY if current.get("available") else GRAY
-                desc_surface = desc_font.render(
-                    current["stage"].description, False, desc_color
-                )
-                desc_rect = desc_surface.get_rect(center=(width // 2, height // 2 + 74))
-                screen.blit(desc_surface, desc_rect)
-
-            seed_font = load_font(font_settings.resource, font_settings.scaled_size(12))
-            seed_value_display = (
-                current_seed_text if current_seed_text else tr("menu.seed_empty")
-            )
-            seed_label = tr("status.seed", value=seed_value_display)
-            seed_surface = seed_font.render(seed_label, False, LIGHT_GRAY)
-            seed_rect = seed_surface.get_rect(right=width - 14, bottom=height - 12)
-            screen.blit(seed_surface, seed_rect)
-
-            hint_font = load_font(font_settings.resource, font_settings.scaled_size(11))
-            hint_text = tr("menu.window_hint")
-            hint_surface = hint_font.render(hint_text, False, LIGHT_GRAY)
-            hint_rect = hint_surface.get_rect(center=(width // 2, height - 60))
-            screen.blit(hint_surface, hint_rect)
-
-            seed_hint = tr("menu.seed_hint")
-            seed_hint_surface = hint_font.render(seed_hint, False, GRAY)
-            seed_hint_rect = seed_hint_surface.get_rect(left=14, bottom=height - 12)
-            screen.blit(seed_hint_surface, seed_hint_rect)
-        except pygame.error as e:
-            print(f"Error rendering title screen: {e}")
-
-        present(screen)
-        clock.tick(fps)