crimsonland 0.1.0.dev11__py3-none-any.whl → 0.1.0.dev13__py3-none-any.whl

crimson/game.py

@@ -51,6 +51,19 @@ from .demo_trial import (
 )
 from .frontend.boot import BootView
 from .frontend.assets import MenuAssets, _ensure_texture_cache, load_menu_assets
+from .frontend.high_scores_layout import (
+    HS_BACK_BUTTON_X,
+    HS_BACK_BUTTON_Y,
+    HS_BUTTON_STEP_Y,
+    HS_BUTTON_X,
+    HS_BUTTON_Y0,
+    HS_LEFT_PANEL_HEIGHT,
+    HS_LEFT_PANEL_POS_X,
+    HS_LEFT_PANEL_POS_Y,
+    HS_RIGHT_PANEL_HEIGHT,
+    HS_RIGHT_PANEL_POS_X,
+    HS_RIGHT_PANEL_POS_Y,
+)
 from .frontend.menu import (
     MENU_PANEL_HEIGHT,
     MENU_PANEL_OFFSET_X,
@@ -72,13 +85,18 @@ from .frontend.menu import (
 )
 from .frontend.panels.base import PANEL_TIMELINE_END_MS, PANEL_TIMELINE_START_MS, PanelMenuView
 from .frontend.panels.controls import ControlsMenuView
+from .frontend.panels.credits import CreditsView
+from .frontend.panels.databases import UnlockedPerksDatabaseView, UnlockedWeaponsDatabaseView
 from .frontend.panels.mods import ModsMenuView
 from .frontend.panels.options import OptionsMenuView
 from .frontend.panels.play_game import PlayGameMenuView
 from .frontend.panels.stats import StatisticsMenuView
+from .frontend.pause_menu import PauseMenuView
 from .frontend.transitions import _draw_screen_fade, _update_screen_fade
 from .persistence.save_status import GameStatus, ensure_game_status
 from .ui.demo_trial_overlay import DEMO_PURCHASE_URL, DemoTrialOverlayUi
+from .ui.menu_panel import draw_classic_menu_panel
+from .ui.perk_menu import UiButtonState, UiButtonTextureSet, button_draw, button_update, button_width
 from .paths import default_runtime_dir
 from .assets_fetch import download_missing_paqs
 
@@ -124,6 +142,7 @@ class GameState:
     snd_freq_adjustment_enabled: bool = False
     menu_ground: GroundRenderer | None = None
     menu_sign_locked: bool = False
+    pause_background: PauseBackground | None = None
     pending_quest_level: str | None = None
     pending_high_scores: HighScoresRequest | None = None
     quest_outcome: QuestRunOutcome | None = None
@@ -141,6 +160,7 @@ AUTOEXEC_NAME = "autoexec.txt"
 
 QUEST_MENU_BASE_X = -5.0
 QUEST_MENU_BASE_Y = 185.0
+QUEST_MENU_PANEL_OFFSET_X = -63.0
 
 QUEST_TITLE_X_OFFSET = 219.0  # 300 + 64 - 145
 QUEST_TITLE_Y_OFFSET = 44.0  # 40 + 4
@@ -166,8 +186,9 @@ QUEST_HARDCORE_CHECKBOX_X_OFFSET = 132.0
 QUEST_HARDCORE_CHECKBOX_Y_OFFSET = -12.0
 QUEST_HARDCORE_LIST_Y_SHIFT = 10.0
 
-QUEST_BACK_BUTTON_X_OFFSET = 148.0
+QUEST_BACK_BUTTON_X_OFFSET = 138.0
 QUEST_BACK_BUTTON_Y_OFFSET = 212.0
+QUEST_PANEL_HEIGHT = 378.0
 
 
 class QuestsMenuView:
@@ -192,6 +213,8 @@ class QuestsMenuView:
         self._check_off: rl.Texture2D | None = None
         self._button_sm: rl.Texture2D | None = None
         self._button_md: rl.Texture2D | None = None
+        self._button_textures: UiButtonTextureSet | None = None
+        self._back_button = UiButtonState("Back")
 
         self._menu_screen_width = 0
         self._widescreen_y_shift = 0.0
@@ -224,11 +247,13 @@ class QuestsMenuView:
         self._check_off = cache.get_or_load("ui_checkOff", "ui/ui_checkOff.jaz").texture
         self._button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
         self._button_md = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
+        self._button_textures = UiButtonTextureSet(button_sm=self._button_sm, button_md=self._button_md)
 
         self._action = None
         self._dirty = False
         self._stage = max(1, min(5, int(self._stage)))
         self._cursor_pulse_time = 0.0
+        self._back_button = UiButtonState("Back")
 
         # Ensure the quest registry is populated so titles render.
         # (The package import registers all tier builders.)
@@ -247,6 +272,7 @@ class QuestsMenuView:
                 pass
             self._dirty = False
         self._ground = None
+        self._button_textures = None
 
     def update(self, dt: float) -> None:
         if self._state.audio is not None:
@@ -283,9 +309,26 @@ class QuestsMenuView:
         if self._hardcore_checkbox_clicked(layout):
             return
 
-        if self._back_button_clicked(layout):
-            self._action = "open_play_game"
-            return
+        textures = self._button_textures
+        if textures is not None and (textures.button_sm is not None or textures.button_md is not None):
+            back_x = layout["list_x"] + QUEST_BACK_BUTTON_X_OFFSET
+            back_y = self._rows_y0(layout) + QUEST_BACK_BUTTON_Y_OFFSET
+            dt_ms = min(float(dt), 0.1) * 1000.0
+            font = self._ensure_small_font()
+            back_w = button_width(font, self._back_button.label, scale=1.0, force_wide=self._back_button.force_wide)
+            mouse = rl.get_mouse_position()
+            click = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
+            if button_update(
+                self._back_button,
+                x=float(back_x),
+                y=float(back_y),
+                width=float(back_w),
+                dt_ms=float(dt_ms),
+                mouse=mouse,
+                click=bool(click),
+            ):
+                self._action = "open_play_game"
+                return
 
         # Quick-select row numbers 1..0 (10).
         row_from_key = self._digit_row_pressed()
@@ -329,10 +372,10 @@ class QuestsMenuView:
 
     def _layout(self) -> dict[str, float]:
         # `sub_447d40` base sums:
-        #   x_sum = <ui_element_x> + (-5)
-        #   y_sum = <ui_element_y> + 185 (+ widescreen shift via ui_menu_layout_init)
-        x_sum = QUEST_MENU_BASE_X
-        y_sum = QUEST_MENU_BASE_Y + self._widescreen_y_shift
+        #   x_sum = <ui_element_x> + <ui_element_offset_x>  (x=-5)
+        #   y_sum = <ui_element_y> + <ui_element_offset_y>  (y=185 + widescreen shift via ui_menu_layout_init)
+        x_sum = QUEST_MENU_BASE_X + MENU_PANEL_OFFSET_X
+        y_sum = QUEST_MENU_BASE_Y + MENU_PANEL_OFFSET_Y + self._widescreen_y_shift
 
         title_x = x_sum + QUEST_TITLE_X_OFFSET
         title_y = y_sum + QUEST_TITLE_Y_OFFSET
@@ -392,20 +435,6 @@ class QuestsMenuView:
             return True
         return False
 
-    def _back_button_clicked(self, layout: dict[str, float]) -> bool:
-        tex = self._button_sm
-        if tex is None:
-            tex = self._button_md
-        if tex is None:
-            return False
-        x = layout["list_x"] + QUEST_BACK_BUTTON_X_OFFSET
-        y = self._rows_y0(layout) + QUEST_BACK_BUTTON_Y_OFFSET
-        w = float(tex.width)
-        h = float(tex.height)
-        mouse = rl.get_mouse_position()
-        hovered = x <= mouse.x <= x + w and y <= mouse.y <= y + h
-        return hovered and rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
-
     @staticmethod
     def _digit_row_pressed() -> int | None:
         keys = [
@@ -634,12 +663,15 @@ class QuestsMenuView:
             else:
                 title = "???"
             draw_small_text(font, title, list_x + QUEST_LIST_NAME_X_OFFSET, y, 1.0, color)
+            title_w = measure_small_text_width(font, title, 1.0) if unlocked else 0.0
+            if unlocked:
+                line_y = y + 13.0
+                rl.draw_line(int(list_x), int(line_y), int(list_x + title_w + 32.0), int(line_y), color)
 
             if show_counts and unlocked:
                 counts = self._quest_counts(stage=stage, row=row)
                 if counts is not None:
                     completed, games = counts
-                    title_w = measure_small_text_width(font, title, 1.0)
                     counts_x = list_x + QUEST_LIST_NAME_X_OFFSET + title_w + 12.0
                     draw_small_text(font, f"({completed}/{games})", counts_x, y, 1.0, color)
 
@@ -650,28 +682,12 @@ class QuestsMenuView:
             draw_small_text(font, "(completed/games)", header_x, header_y, 1.0, base_color)
 
         # Back button.
-        button = self._button_sm or self._button_md
-        if button is not None:
+        textures = self._button_textures
+        if textures is not None and (textures.button_sm is not None or textures.button_md is not None):
             back_x = list_x + QUEST_BACK_BUTTON_X_OFFSET
             back_y = y0 + QUEST_BACK_BUTTON_Y_OFFSET
-            back_w = float(button.width)
-            back_h = float(button.height)
-            mouse = rl.get_mouse_position()
-            hovered = back_x <= mouse.x <= back_x + back_w and back_y <= mouse.y <= back_y + back_h
-            rl.draw_texture_pro(
-                button,
-                rl.Rectangle(0.0, 0.0, float(button.width), float(button.height)),
-                rl.Rectangle(back_x, back_y, back_w, back_h),
-                rl.Vector2(0.0, 0.0),
-                0.0,
-                rl.WHITE,
-            )
-            label = "Back"
-            label_w = measure_small_text_width(font, label, 1.0)
-            text_x = back_x + (back_w - label_w) * 0.5 + 1.0
-            text_y = back_y + 10.0
-            text_alpha = 255 if hovered else 179
-            draw_small_text(font, label, text_x, text_y, 1.0, rl.Color(255, 255, 255, text_alpha))
+            back_w = button_width(font, self._back_button.label, scale=1.0, force_wide=self._back_button.force_wide)
+            button_draw(textures, font, self._back_button, x=float(back_x), y=float(back_y), width=float(back_w), scale=1.0)
 
     def _draw_sign(self) -> None:
         assets = self._assets
@@ -719,53 +735,19 @@ class QuestsMenuView:
         panel = self._panel_tex
         if panel is None:
             return
-        panel_scale = 0.9 if self._menu_screen_width < 641 else 1.0
-        dst = rl.Rectangle(
-            QUEST_MENU_BASE_X,
-            QUEST_MENU_BASE_Y + self._widescreen_y_shift,
-            MENU_PANEL_WIDTH * panel_scale,
-            MENU_PANEL_HEIGHT * panel_scale,
-        )
-        origin = rl.Vector2(-(MENU_PANEL_OFFSET_X * panel_scale), -(MENU_PANEL_OFFSET_Y * panel_scale))
         fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
-        if fx_detail:
-            MenuView._draw_ui_quad_shadow(
-                texture=panel,
-                src=rl.Rectangle(0.0, 0.0, float(panel.width), float(panel.height)),
-                dst=rl.Rectangle(dst.x + UI_SHADOW_OFFSET, dst.y + UI_SHADOW_OFFSET, dst.width, dst.height),
-                origin=origin,
-                rotation_deg=0.0,
-            )
-        MenuView._draw_ui_quad(
-            texture=panel,
-            src=rl.Rectangle(0.0, 0.0, float(panel.width), float(panel.height)),
-            dst=dst,
-            origin=origin,
-            rotation_deg=0.0,
-            tint=rl.WHITE,
+        draw_classic_menu_panel(
+            panel,
+            dst=rl.Rectangle(
+                float(QUEST_MENU_BASE_X + QUEST_MENU_PANEL_OFFSET_X),
+                float(QUEST_MENU_BASE_Y + MENU_PANEL_OFFSET_Y + self._widescreen_y_shift),
+                float(MENU_PANEL_WIDTH),
+                float(QUEST_PANEL_HEIGHT),
+            ),
+            shadow=fx_detail,
         )
 
 
-class QuestStartView(PanelMenuView):
-    def __init__(self, state: GameState) -> None:
-        super().__init__(
-            state,
-            title="Quest",
-            body="Quest gameplay is not implemented yet.",
-            back_action="open_quests",
-        )
-
-    def open(self) -> None:
-        level = self._state.pending_quest_level or "unknown"
-        self._title = f"Quest {level}"
-        self._body_lines = [
-            f"Selected quest: {level}",
-            "",
-            "Quest gameplay is not implemented yet.",
-        ]
-        super().open()
-
-
 class FrontView(Protocol):
     def open(self) -> None: ...
 
@@ -778,6 +760,10 @@ class FrontView(Protocol):
     def take_action(self) -> str | None: ...
 
 
+class PauseBackground(Protocol):
+    def draw_pause_background(self) -> None: ...
+
+
 class SurvivalGameView:
     """Gameplay view wrapper that adapts SurvivalMode into `crimson game`."""
 
@@ -817,6 +803,9 @@ class SurvivalGameView:
     def update(self, dt: float) -> None:
         self._mode.update(dt)
         mode_action = self._mode.take_action()
+        if mode_action == "open_pause_menu":
+            self._action = "open_pause_menu"
+            return
         if mode_action == "open_high_scores":
             self._state.pending_high_scores = HighScoresRequest(game_mode_id=1)
             self._action = "open_high_scores"
@@ -832,6 +821,9 @@ class SurvivalGameView:
     def draw(self) -> None:
         self._mode.draw()
 
+    def draw_pause_background(self) -> None:
+        self._mode.draw_pause_background()
+
     def take_action(self) -> str | None:
         action = self._action
         self._action = None
@@ -875,6 +867,9 @@ class RushGameView:
     def update(self, dt: float) -> None:
         self._mode.update(dt)
         mode_action = self._mode.take_action()
+        if mode_action == "open_pause_menu":
+            self._action = "open_pause_menu"
+            return
         if mode_action == "open_high_scores":
             self._state.pending_high_scores = HighScoresRequest(game_mode_id=2)
             self._action = "open_high_scores"
@@ -890,6 +885,9 @@ class RushGameView:
     def draw(self) -> None:
         self._mode.draw()
 
+    def draw_pause_background(self) -> None:
+        self._mode.draw_pause_background()
+
     def take_action(self) -> str | None:
         action = self._action
         self._action = None
@@ -933,6 +931,9 @@ class TypoShooterGameView:
     def update(self, dt: float) -> None:
         self._mode.update(dt)
         mode_action = self._mode.take_action()
+        if mode_action == "open_pause_menu":
+            self._action = "open_pause_menu"
+            return
         if mode_action == "open_high_scores":
             self._state.pending_high_scores = HighScoresRequest(game_mode_id=4)
             self._action = "open_high_scores"
@@ -948,6 +949,9 @@ class TypoShooterGameView:
     def draw(self) -> None:
         self._mode.draw()
 
+    def draw_pause_background(self) -> None:
+        self._mode.draw_pause_background()
+
     def take_action(self) -> str | None:
         action = self._action
         self._action = None
@@ -991,6 +995,10 @@ class TutorialGameView:
 
     def update(self, dt: float) -> None:
         self._mode.update(dt)
+        mode_action = self._mode.take_action()
+        if mode_action == "open_pause_menu":
+            self._action = "open_pause_menu"
+            return
         if getattr(self._mode, "close_requested", False):
             self._action = "back_to_menu"
             self._mode.close_requested = False
@@ -998,6 +1006,9 @@ class TutorialGameView:
     def draw(self) -> None:
         self._mode.draw()
 
+    def draw_pause_background(self) -> None:
+        self._mode.draw_pause_background()
+
     def take_action(self) -> str | None:
         action = self._action
         self._action = None
@@ -1046,6 +1057,10 @@ class QuestGameView:
 
     def update(self, dt: float) -> None:
         self._mode.update(dt)
+        mode_action = self._mode.take_action()
+        if mode_action == "open_pause_menu":
+            self._action = "open_pause_menu"
+            return
         if getattr(self._mode, "close_requested", False):
             outcome = self._mode.consume_outcome()
             if outcome is not None:
@@ -1063,6 +1078,9 @@ class QuestGameView:
     def draw(self) -> None:
         self._mode.draw()
 
+    def draw_pause_background(self) -> None:
+        self._mode.draw_pause_background()
+
     def take_action(self) -> str | None:
         action = self._action
         self._action = None
@@ -1103,45 +1121,35 @@ class QuestResultsView:
     def __init__(self, state: GameState) -> None:
         self._state = state
         self._ground: GroundRenderer | None = None
-        self._outcome: QuestRunOutcome | None = None
+        self._quest_level: str = ""
         self._quest_title: str = ""
         self._quest_stage_major = 0
         self._quest_stage_minor = 0
         self._unlock_weapon_name: str = ""
         self._unlock_perk_name: str = ""
-        self._breakdown = None
-        self._breakdown_anim = None
-        self._record = None
-        self._rank_index: int | None = None
+        self._ui = None
         self._action: str | None = None
-        self._cursor_pulse_time = 0.0
-        self._small_font: SmallFontData | None = None
-        self._button_tex: rl.Texture2D | None = None
 
     def open(self) -> None:
-        from .quests.results import QuestResultsBreakdownAnim, compute_quest_final_time
-        from .persistence.highscores import HighScoreRecord, scores_path_for_config, upsert_highscore_record
+        from .persistence.highscores import HighScoreRecord
+        from .quests.results import compute_quest_final_time
+        from .ui.quest_results import QuestResultsUi
 
         self._action = None
-        self._ground = ensure_menu_ground(self._state)
-        self._cursor_pulse_time = 0.0
-        self._outcome = self._state.quest_outcome
-        self._state.quest_outcome = None
-        outcome = self._outcome
+        self._ground = None if self._state.pause_background is not None else ensure_menu_ground(self._state)
         self._state.quest_fail_retry_count = 0
+        outcome = self._state.quest_outcome
+        self._state.quest_outcome = None
+        self._quest_level = ""
         self._quest_title = ""
         self._quest_stage_major = 0
         self._quest_stage_minor = 0
         self._unlock_weapon_name = ""
         self._unlock_perk_name = ""
-        self._breakdown = None
-        self._breakdown_anim = None
-        self._record = None
-        self._rank_index = None
-        self._button_tex = None
-        self._small_font = None
+        self._ui = None
         if outcome is None:
             return
+        self._quest_level = str(outcome.level or "")
 
         major, minor = 0, 0
         try:
@@ -1199,7 +1207,8 @@ class QuestResultsView:
             pending_perk_count=int(outcome.pending_perk_count),
         )
         record.survival_elapsed_ms = int(breakdown.final_time_ms)
-        record.set_name(_player_name_default(self._state.config) or "Player")
+        player_name_default = _player_name_default(self._state.config) or "Player"
+        record.set_name(player_name_default)
 
         global_index = (int(major) - 1) * 10 + (int(minor) - 1)
         if 0 <= global_index < 40:
@@ -1228,271 +1237,86 @@ class QuestResultsView:
         except Exception:
             pass
 
-        path = scores_path_for_config(self._state.base_dir, self._state.config, quest_stage_major=major, quest_stage_minor=minor)
-        try:
-            _table, rank_index = upsert_highscore_record(path, record)
-            self._rank_index = int(rank_index)
-        except Exception:
-            self._rank_index = None
-
-        cache = _ensure_texture_cache(self._state)
-        self._button_tex = cache.get_or_load("ui_button_md", "ui/ui_button_145x32.jaz").texture
-        self._record = record
-        self._breakdown = breakdown
-        self._breakdown_anim = QuestResultsBreakdownAnim.start()
+        self._ui = QuestResultsUi(
+            assets_root=self._state.assets_dir,
+            base_dir=self._state.base_dir,
+            config=self._state.config,
+        )
+        self._ui.open(
+            record=record,
+            breakdown=breakdown,
+            quest_level=str(outcome.level or ""),
+            quest_title=str(self._quest_title or ""),
+            quest_stage_major=int(self._quest_stage_major),
+            quest_stage_minor=int(self._quest_stage_minor),
+            unlock_weapon_name=str(self._unlock_weapon_name or ""),
+            unlock_perk_name=str(self._unlock_perk_name or ""),
+            player_name_default=player_name_default,
+        )
 
     def close(self) -> None:
-        self._small_font = None
-        self._button_tex = None
-        self._record = None
-        self._outcome = None
-        self._breakdown = None
-        self._breakdown_anim = None
-        self._rank_index = None
+        if self._ui is not None:
+            self._ui.close()
+            self._ui = None
+        self._ground = None
         self._quest_stage_major = 0
         self._quest_stage_minor = 0
+        self._quest_level = ""
+        self._quest_title = ""
         self._unlock_weapon_name = ""
         self._unlock_perk_name = ""
 
     def update(self, dt: float) -> None:
-        from .quests.results import tick_quest_results_breakdown_anim
-
         if self._state.audio is not None:
             update_audio(self._state.audio, dt)
         if self._ground is not None:
             self._ground.process_pending()
-        self._cursor_pulse_time += min(dt, 0.1) * 1.1
-
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
-            self._action = "back_to_menu"
+        ui = self._ui
+        if ui is None:
             return
+        audio = self._state.audio
+        rng = self._state.rng
 
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_H):
-            self._open_high_scores_list()
-            return
-
-        outcome = self._outcome
-        record = self._record
-        breakdown = self._breakdown
-        if record is None or outcome is None or breakdown is None:
-            return
-
-        anim = self._breakdown_anim
-        if anim is not None and not anim.done:
-            if rl.is_key_pressed(rl.KeyboardKey.KEY_SPACE) or rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT):
-                anim.set_final(breakdown)
-                return
-
-            clinks = tick_quest_results_breakdown_anim(
-                anim,
-                frame_dt_ms=int(min(dt, 0.1) * 1000.0),
-                target=breakdown,
-            )
-            if clinks > 0 and self._state.audio is not None:
-                play_sfx(self._state.audio, "sfx_ui_clink_01", rng=self._state.rng)
-            if not anim.done:
+        def _play(name: str) -> None:
+            if audio is None:
                 return
+            play_sfx(audio, name, rng=rng)
 
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_ENTER):
-            self._state.pending_quest_level = outcome.level
+        action = ui.update(dt, play_sfx=_play if audio is not None else None, rand=lambda: rng.getrandbits(32))
+        if action == "play_again":
+            self._state.pending_quest_level = self._quest_level
             self._action = "start_quest"
             return
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_N):
-            next_level = _next_quest_level(outcome.level)
+        if action == "play_next":
+            next_level = _next_quest_level(self._quest_level)
             if next_level is not None:
                 self._state.pending_quest_level = next_level
                 self._action = "start_quest"
-                return
-
-        tex = self._button_tex
-        if tex is None:
-            return
-        scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
-        button_w = float(tex.width) * scale
-        button_h = float(tex.height) * scale
-        gap_x = 18.0 * scale
-        gap_y = 12.0 * scale
-        x0 = 32.0
-        y0 = float(rl.get_screen_height()) - (button_h * 2.0 + gap_y) - 52.0 * scale
-        x1 = x0 + button_w + gap_x
-        y1 = y0 + button_h + gap_y
-
-        buttons = [
-            ("Play again", rl.Rectangle(x0, y0, button_w, button_h), "play_again"),
-            ("Play next", rl.Rectangle(x1, y0, button_w, button_h), "play_next"),
-            ("High scores", rl.Rectangle(x0, y1, button_w, button_h), "high_scores"),
-            ("Main menu", rl.Rectangle(x1, y1, button_w, button_h), "main_menu"),
-        ]
-        mouse = rl.get_mouse_position()
-        clicked = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
-        for _label, rect, action in buttons:
-            hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-            if not hovered or not clicked:
-                continue
-            if action == "play_again":
-                self._state.pending_quest_level = outcome.level
-                self._action = "start_quest"
-                return
-            if action == "play_next":
-                next_level = _next_quest_level(outcome.level)
-                if next_level is not None:
-                    self._state.pending_quest_level = next_level
-                    self._action = "start_quest"
-                    return
-            if action == "main_menu":
+            else:
                 self._action = "back_to_menu"
-                return
-            if action == "high_scores":
-                self._open_high_scores_list()
-                return
+            return
+        if action == "high_scores":
+            self._open_high_scores_list()
+            return
+        if action == "main_menu":
+            self._action = "back_to_menu"
+            return
 
     def draw(self) -> None:
         rl.clear_background(rl.BLACK)
-        if self._ground is not None:
+        pause_background = self._state.pause_background
+        if pause_background is not None:
+            pause_background.draw_pause_background()
+        elif self._ground is not None:
             self._ground.draw(0.0, 0.0)
         _draw_screen_fade(self._state)
-
-        record = self._record
-        outcome = self._outcome
-        breakdown = self._breakdown
-        if record is None or outcome is None or breakdown is None:
-            rl.draw_text("Quest results unavailable.", 32, 140, 28, rl.Color(235, 235, 235, 255))
-            rl.draw_text("Press ESC to return to the menu.", 32, 180, 18, rl.Color(190, 190, 200, 255))
+        ui = self._ui
+        if ui is not None:
+            ui.draw()
             return
 
-        anim = self._breakdown_anim
-        base_time_ms = int(breakdown.base_time_ms)
-        life_bonus_ms = int(breakdown.life_bonus_ms)
-        perk_bonus_ms = int(breakdown.unpicked_perk_bonus_ms)
-        final_time_ms = int(breakdown.final_time_ms)
-        step = 4
-        highlight_alpha = 1.0
-        if anim is not None and not anim.done:
-            base_time_ms = int(anim.base_time_ms)
-            life_bonus_ms = int(anim.life_bonus_ms)
-            perk_bonus_ms = int(anim.unpicked_perk_bonus_s) * 1000
-            final_time_ms = int(anim.final_time_ms)
-            step = int(anim.step)
-            highlight_alpha = float(anim.highlight_alpha())
-
-        def _fmt_clock(ms: int) -> str:
-            total_seconds = max(0, int(ms) // 1000)
-            minutes = total_seconds // 60
-            seconds = total_seconds % 60
-            return f"{minutes:02d}:{seconds:02d}"
-
-        def _fmt_bonus(ms: int) -> str:
-            return f"-{float(max(0, int(ms))) / 1000.0:.2f}s"
-
-        def _breakdown_color(idx: int, *, final: bool = False) -> rl.Color:
-            if anim is None or anim.done:
-                if final:
-                    return rl.Color(255, 255, 255, 255)
-                return rl.Color(255, 255, 255, int(255 * 0.8))
-
-            alpha = 0.2
-            if idx < step:
-                alpha = 0.4
-            elif idx == step:
-                alpha = 1.0
-                if final:
-                    alpha *= highlight_alpha
-            rgb = (255, 255, 255)
-            if idx == step:
-                rgb = (25, 200, 25)
-            return rl.Color(rgb[0], rgb[1], rgb[2], int(255 * max(0.0, min(1.0, alpha))))
-
-        title = f"Quest {outcome.level} completed"
-        subtitle = self._quest_title
-        rl.draw_text(title, 32, 120, 28, rl.Color(235, 235, 235, 255))
-        if subtitle:
-            rl.draw_text(subtitle, 32, 154, 18, rl.Color(190, 190, 200, 255))
-
-        font = self._ensure_small_font()
-        text_color = rl.Color(255, 255, 255, int(255 * 0.8))
-        y = 196.0
-        draw_small_text(font, f"Base time: {_fmt_clock(base_time_ms)}", 32.0, y, 1.0, _breakdown_color(0))
-        y += 18.0
-        draw_small_text(font, f"Life bonus: {_fmt_bonus(life_bonus_ms)}", 32.0, y, 1.0, _breakdown_color(1))
-        y += 18.0
-        draw_small_text(font, f"Perk bonus: {_fmt_bonus(perk_bonus_ms)}", 32.0, y, 1.0, _breakdown_color(2))
-        y += 18.0
-        draw_small_text(font, f"Final time: {_fmt_clock(final_time_ms)}", 32.0, y, 1.0, _breakdown_color(3, final=True))
-        y += 26.0
-        draw_small_text(font, f"Kills: {int(record.creature_kill_count)}", 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.8)))
-        y += 18.0
-        draw_small_text(font, f"XP: {int(record.score_xp)}", 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.8)))
-        if self._rank_index is not None and self._rank_index < 100:
-            y += 18.0
-            draw_small_text(font, f"Rank: {int(self._rank_index) + 1}", 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.8)))
-
-        if self._unlock_weapon_name:
-            y += 26.0
-            draw_small_text(font, "Weapon unlocked", 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.7)))
-            y += 16.0
-            draw_small_text(font, self._unlock_weapon_name, 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.9)))
-
-        if self._unlock_perk_name:
-            y += 20.0
-            draw_small_text(font, "Perk unlocked", 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.7)))
-            y += 16.0
-            draw_small_text(font, self._unlock_perk_name, 32.0, y, 1.0, rl.Color(255, 255, 255, int(255 * 0.9)))
-
-        tex = self._button_tex
-        y0 = 0.0
-        if tex is not None:
-            scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
-            button_w = float(tex.width) * scale
-            button_h = float(tex.height) * scale
-            gap_x = 18.0 * scale
-            gap_y = 12.0 * scale
-            x0 = 32.0
-            y0 = float(rl.get_screen_height()) - (button_h * 2.0 + gap_y) - 52.0 * scale
-            x1 = x0 + button_w + gap_x
-            y1 = y0 + button_h + gap_y
-
-            buttons = [
-                ("Play again", rl.Rectangle(x0, y0, button_w, button_h)),
-                ("Play next", rl.Rectangle(x1, y0, button_w, button_h)),
-                ("High scores", rl.Rectangle(x0, y1, button_w, button_h)),
-                ("Main menu", rl.Rectangle(x1, y1, button_w, button_h)),
-            ]
-            mouse = rl.get_mouse_position()
-            for label, rect in buttons:
-                hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-                alpha = 255 if hovered else 220
-                rl.draw_texture_pro(
-                    tex,
-                    rl.Rectangle(0.0, 0.0, float(tex.width), float(tex.height)),
-                    rect,
-                    rl.Vector2(0.0, 0.0),
-                    0.0,
-                    rl.Color(255, 255, 255, alpha),
-                )
-                label_w = measure_small_text_width(font, label, 1.0 * scale)
-                text_x = rect.x + (rect.width - label_w) * 0.5 + 1.0 * scale
-                text_y = rect.y + 10.0 * scale
-                draw_small_text(font, label, text_x, text_y, 1.0 * scale, rl.Color(20, 20, 20, 255))
-
-        if anim is not None and not anim.done:
-            draw_small_text(
-                font,
-                "SPACE / click: skip breakdown",
-                32.0,
-                float(rl.get_screen_height()) - 46.0,
-                0.9,
-                rl.Color(190, 190, 200, 255),
-            )
-
-        draw_small_text(
-            font,
-            "ENTER: Replay    N: Next    H: High scores    ESC: Menu",
-            32.0,
-            float(rl.get_screen_height()) - 28.0,
-            1.0,
-            rl.Color(190, 190, 200, 255),
-        )
-        _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
+        rl.draw_text("Quest results unavailable.", 32, 140, 28, rl.Color(235, 235, 235, 255))
+        rl.draw_text("Press ESC to return to the menu.", 32, 180, 18, rl.Color(190, 190, 200, 255))
 
     def take_action(self) -> str | None:
         action = self._action
@@ -1500,21 +1324,17 @@ class QuestResultsView:
         return action
 
     def _open_high_scores_list(self) -> None:
+        highlight_rank = None
+        if self._ui is not None:
+            highlight_rank = self._ui.highlight_rank
         self._state.pending_high_scores = HighScoresRequest(
             game_mode_id=3,
             quest_stage_major=int(self._quest_stage_major),
             quest_stage_minor=int(self._quest_stage_minor),
-            highlight_rank=self._rank_index,
+            highlight_rank=highlight_rank,
         )
         self._action = "open_high_scores"
 
-    def _ensure_small_font(self) -> SmallFontData:
-        if self._small_font is not None:
-            return self._small_font
-        missing_assets: list[str] = []
-        self._small_font = load_small_font(self._state.assets_dir, missing_assets)
-        return self._small_font
-
 
 class QuestFailedView:
     def __init__(self, state: GameState) -> None:
@@ -1529,13 +1349,17 @@ class QuestFailedView:
 
     def open(self) -> None:
         self._action = None
-        self._ground = ensure_menu_ground(self._state)
+        self._ground = None if self._state.pause_background is not None else ensure_menu_ground(self._state)
         self._cursor_pulse_time = 0.0
         self._outcome = self._state.quest_outcome
         self._state.quest_outcome = None
         self._quest_title = ""
         self._small_font = None
         self._button_tex = None
+        self._button_textures = None
+        self._retry_button = UiButtonState("Retry", force_wide=True)
+        self._quest_list_button = UiButtonState("Quest list", force_wide=True)
+        self._main_menu_button = UiButtonState("Main menu", force_wide=True)
         outcome = self._outcome
         if outcome is not None:
             try:
@@ -1547,7 +1371,9 @@ class QuestFailedView:
                 self._quest_title = ""
 
         cache = _ensure_texture_cache(self._state)
-        self._button_tex = cache.get_or_load("ui_button_md", "ui/ui_button_145x32.jaz").texture
+        self._button_tex = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
+        button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
+        self._button_textures = UiButtonTextureSet(button_sm=button_sm, button_md=self._button_tex)
 
     def close(self) -> None:
         self._ground = None
@@ -1555,6 +1381,7 @@ class QuestFailedView:
         self._quest_title = ""
         self._small_font = None
         self._button_tex = None
+        self._button_textures = None
 
     def update(self, dt: float) -> None:
         if self._state.audio is not None:
@@ -1578,44 +1405,56 @@ class QuestFailedView:
             self._action = "open_quests"
             return
 
-        tex = self._button_tex
-        if tex is None or outcome is None:
+        textures = self._button_textures
+        if outcome is None or textures is None or (textures.button_sm is None and textures.button_md is None):
             return
         scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
-        button_w = float(tex.width) * scale
-        button_h = float(tex.height) * scale
+        button_w = button_width(None, self._retry_button.label, scale=scale, force_wide=self._retry_button.force_wide)
+        button_h = 32.0 * scale
         gap_x = 18.0 * scale
         x0 = 32.0
         y0 = float(rl.get_screen_height()) - button_h - 56.0 * scale
 
-        buttons = [
-            ("Retry", rl.Rectangle(x0, y0, button_w, button_h), "retry"),
-            ("Quest list", rl.Rectangle(x0 + button_w + gap_x, y0, button_w, button_h), "quest_list"),
-            ("Main menu", rl.Rectangle(x0 + (button_w + gap_x) * 2.0, y0, button_w, button_h), "main_menu"),
-        ]
         mouse = rl.get_mouse_position()
-        clicked = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
-        for _label, rect, action in buttons:
-            hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-            if not hovered or not clicked:
-                continue
-            if action == "retry":
-                self._state.quest_fail_retry_count = int(self._state.quest_fail_retry_count) + 1
-                self._state.pending_quest_level = outcome.level
-                self._action = "start_quest"
-                return
-            if action == "quest_list":
-                self._state.quest_fail_retry_count = 0
-                self._action = "open_quests"
-                return
-            if action == "main_menu":
-                self._state.quest_fail_retry_count = 0
-                self._action = "back_to_menu"
-                return
+        click = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
+        dt_ms = min(float(dt), 0.1) * 1000.0
+
+        if button_update(self._retry_button, x=x0, y=y0, width=button_w, dt_ms=dt_ms, mouse=mouse, click=click):
+            self._state.quest_fail_retry_count = int(self._state.quest_fail_retry_count) + 1
+            self._state.pending_quest_level = outcome.level
+            self._action = "start_quest"
+            return
+        if button_update(
+            self._quest_list_button,
+            x=x0 + button_w + gap_x,
+            y=y0,
+            width=button_w,
+            dt_ms=dt_ms,
+            mouse=mouse,
+            click=click,
+        ):
+            self._state.quest_fail_retry_count = 0
+            self._action = "open_quests"
+            return
+        if button_update(
+            self._main_menu_button,
+            x=x0 + (button_w + gap_x) * 2.0,
+            y=y0,
+            width=button_w,
+            dt_ms=dt_ms,
+            mouse=mouse,
+            click=click,
+        ):
+            self._state.quest_fail_retry_count = 0
+            self._action = "back_to_menu"
+            return
 
     def draw(self) -> None:
         rl.clear_background(rl.BLACK)
-        if self._ground is not None:
+        pause_background = self._state.pause_background
+        if pause_background is not None:
+            pause_background.draw_pause_background()
+        elif self._ground is not None:
             self._ground.draw(0.0, 0.0)
         _draw_screen_fade(self._state)
 
@@ -1655,36 +1494,33 @@ class QuestFailedView:
             y += 18.0
             draw_small_text(font, f"XP: {int(outcome.experience)}", 32.0, y, 1.0, text_color)
 
-        tex = self._button_tex
-        if tex is not None:
+        textures = self._button_textures
+        if textures is not None and (textures.button_sm is not None or textures.button_md is not None):
             scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
-            button_w = float(tex.width) * scale
-            button_h = float(tex.height) * scale
+            button_w = button_width(None, self._retry_button.label, scale=scale, force_wide=self._retry_button.force_wide)
+            button_h = 32.0 * scale
             gap_x = 18.0 * scale
             x0 = 32.0
             y0 = float(rl.get_screen_height()) - button_h - 56.0 * scale
-
-            buttons = [
-                ("Retry", rl.Rectangle(x0, y0, button_w, button_h)),
-                ("Quest list", rl.Rectangle(x0 + button_w + gap_x, y0, button_w, button_h)),
-                ("Main menu", rl.Rectangle(x0 + (button_w + gap_x) * 2.0, y0, button_w, button_h)),
-            ]
-            mouse = rl.get_mouse_position()
-            for label, rect in buttons:
-                hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-                alpha = 255 if hovered else 220
-                rl.draw_texture_pro(
-                    tex,
-                    rl.Rectangle(0.0, 0.0, float(tex.width), float(tex.height)),
-                    rect,
-                    rl.Vector2(0.0, 0.0),
-                    0.0,
-                    rl.Color(255, 255, 255, alpha),
-                )
-                label_w = measure_small_text_width(font, label, 1.0 * scale)
-                text_x = rect.x + (rect.width - label_w) * 0.5 + 1.0 * scale
-                text_y = rect.y + 10.0 * scale
-                draw_small_text(font, label, text_x, text_y, 1.0 * scale, rl.Color(20, 20, 20, 255))
+            button_draw(textures, font, self._retry_button, x=x0, y=y0, width=button_w, scale=scale)
+            button_draw(
+                textures,
+                font,
+                self._quest_list_button,
+                x=x0 + button_w + gap_x,
+                y=y0,
+                width=button_w,
+                scale=scale,
+            )
+            button_draw(
+                textures,
+                font,
+                self._main_menu_button,
+                x=x0 + (button_w + gap_x) * 2.0,
+                y=y0,
+                width=button_w,
+                scale=scale,
+            )
 
         draw_small_text(
             font,
@@ -1712,11 +1548,19 @@ class QuestFailedView:
 class HighScoresView:
     def __init__(self, state: GameState) -> None:
         self._state = state
+        self._assets: MenuAssets | None = None
         self._ground: GroundRenderer | None = None
         self._action: str | None = None
         self._cursor_pulse_time = 0.0
+        self._widescreen_y_shift = 0.0
+        self._timeline_ms = 0
+        self._timeline_max_ms = PANEL_TIMELINE_START_MS
         self._small_font: SmallFontData | None = None
         self._button_tex: rl.Texture2D | None = None
+        self._button_textures: UiButtonTextureSet | None = None
+        self._update_button = UiButtonState("Update scores", force_wide=True)
+        self._play_button = UiButtonState("Play a game", force_wide=True)
+        self._back_button = UiButtonState("Back", force_wide=False)
 
         self._request: HighScoresRequest | None = None
         self._records: list = []
@@ -1725,14 +1569,25 @@ class HighScoresView:
     def open(self) -> None:
         from .persistence.highscores import read_highscore_table, scores_path_for_mode
 
+        layout_w = float(self._state.config.screen_width)
+        self._widescreen_y_shift = MenuView._menu_widescreen_y_shift(layout_w)
         self._action = None
-        self._ground = ensure_menu_ground(self._state)
+        self._assets = load_menu_assets(self._state)
+        self._ground = None if self._state.pause_background is not None else ensure_menu_ground(self._state)
         self._cursor_pulse_time = 0.0
+        self._timeline_ms = 0
+        self._timeline_max_ms = PANEL_TIMELINE_START_MS
         self._small_font = None
         self._scroll_index = 0
+        self._button_textures = None
+        self._update_button = UiButtonState("Update scores", force_wide=True)
+        self._play_button = UiButtonState("Play a game", force_wide=True)
+        self._back_button = UiButtonState("Back", force_wide=False)
 
         cache = _ensure_texture_cache(self._state)
-        self._button_tex = cache.get_or_load("ui_button_md", "ui/ui_button_145x32.jaz").texture
+        self._button_tex = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
+        button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
+        self._button_textures = UiButtonTextureSet(button_sm=button_sm, button_md=self._button_tex)
 
         request = self._state.pending_high_scores
         self._state.pending_high_scores = None
@@ -1768,11 +1623,18 @@ class HighScoresView:
         if self._small_font is not None:
             rl.unload_texture(self._small_font.texture)
             self._small_font = None
+        self._assets = None
         self._button_tex = None
+        self._button_textures = None
         self._request = None
         self._records = []
         self._scroll_index = 0
 
+    def _panel_top_left(self, *, pos_x: float, pos_y: float, scale: float) -> tuple[float, float]:
+        x0 = float(pos_x + MENU_PANEL_OFFSET_X * scale)
+        y0 = float(pos_y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * scale)
+        return x0, y0
+
     def update(self, dt: float) -> None:
         if self._state.audio is not None:
             update_audio(self._state.audio, dt)
@@ -1780,62 +1642,97 @@ class HighScoresView:
             self._ground.process_pending()
         self._cursor_pulse_time += min(dt, 0.1) * 1.1
 
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+        dt_ms = int(min(float(dt), 0.1) * 1000.0)
+        if dt_ms > 0:
+            self._timeline_ms = min(self._timeline_max_ms, int(self._timeline_ms + dt_ms))
+
+        enabled = self._timeline_ms >= self._timeline_max_ms
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE) and enabled:
             if self._state.audio is not None:
                 play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
             self._action = "back_to_previous"
             return
 
-        mouse = rl.get_mouse_position()
-        clicked = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
-        tex = self._button_tex
-        if tex is not None and clicked:
+        textures = self._button_textures
+        if enabled and textures is not None and (textures.button_sm is not None or textures.button_md is not None):
             scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
-            button_w = float(tex.width) * scale
-            button_h = float(tex.height) * scale
-            gap_x = 18.0 * scale
-            x0 = 32.0
-            y0 = float(rl.get_screen_height()) - button_h - 52.0 * scale
-            back_rect = rl.Rectangle(x0, y0, button_w, button_h)
-            menu_rect = rl.Rectangle(x0 + button_w + gap_x, y0, button_w, button_h)
-            if back_rect.x <= mouse.x <= back_rect.x + back_rect.width and back_rect.y <= mouse.y <= back_rect.y + back_rect.height:
+            panel_x0, panel_y0 = self._panel_top_left(pos_x=HS_LEFT_PANEL_POS_X, pos_y=HS_LEFT_PANEL_POS_Y, scale=scale)
+
+            x0 = panel_x0 + HS_BUTTON_X * scale
+            y0 = panel_y0 + HS_BUTTON_Y0 * scale
+            mouse = rl.get_mouse_position()
+            click = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
+            w = button_width(None, self._update_button.label, scale=scale, force_wide=self._update_button.force_wide)
+            if button_update(self._update_button, x=x0, y=y0, width=w, dt_ms=dt_ms, mouse=mouse, click=click):
+                # Reload scores from disk (no view transition).
                 if self._state.audio is not None:
                     play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
-                self._action = "back_to_previous"
+                self.open()
                 return
-            if menu_rect.x <= mouse.x <= menu_rect.x + menu_rect.width and menu_rect.y <= mouse.y <= menu_rect.y + menu_rect.height:
+            w = button_width(None, self._play_button.label, scale=scale, force_wide=self._play_button.force_wide)
+            if button_update(
+                self._play_button,
+                x=x0,
+                y=y0 + HS_BUTTON_STEP_Y * scale,
+                width=w,
+                dt_ms=dt_ms,
+                mouse=mouse,
+                click=click,
+            ):
                 if self._state.audio is not None:
                     play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
-                self._action = "back_to_menu"
+                self._action = "open_play_game"
+                return
+            back_w = button_width(None, self._back_button.label, scale=scale, force_wide=self._back_button.force_wide)
+            if button_update(
+                self._back_button,
+                x=panel_x0 + HS_BACK_BUTTON_X * scale,
+                y=panel_y0 + HS_BACK_BUTTON_Y * scale,
+                width=back_w,
+                dt_ms=dt_ms,
+                mouse=mouse,
+                click=click,
+            ):
+                if self._state.audio is not None:
+                    play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+                self._action = "back_to_previous"
                 return
 
-        font = self._ensure_small_font()
-        rows = self._visible_rows(font)
+        rows = 10
         max_scroll = max(0, len(self._records) - rows)
 
-        wheel = int(rl.get_mouse_wheel_move())
-        if wheel:
-            self._scroll_index = max(0, min(max_scroll, int(self._scroll_index) - wheel))
-
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_UP):
-            self._scroll_index = max(0, int(self._scroll_index) - 1)
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_DOWN):
-            self._scroll_index = min(max_scroll, int(self._scroll_index) + 1)
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_PAGE_UP):
-            self._scroll_index = max(0, int(self._scroll_index) - rows)
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_PAGE_DOWN):
-            self._scroll_index = min(max_scroll, int(self._scroll_index) + rows)
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_HOME):
-            self._scroll_index = 0
-        if rl.is_key_pressed(rl.KeyboardKey.KEY_END):
-            self._scroll_index = max_scroll
+        if enabled:
+            wheel = int(rl.get_mouse_wheel_move())
+            if wheel:
+                self._scroll_index = max(0, min(max_scroll, int(self._scroll_index) - wheel))
+
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_UP):
+                self._scroll_index = max(0, int(self._scroll_index) - 1)
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_DOWN):
+                self._scroll_index = min(max_scroll, int(self._scroll_index) + 1)
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_PAGE_UP):
+                self._scroll_index = max(0, int(self._scroll_index) - rows)
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_PAGE_DOWN):
+                self._scroll_index = min(max_scroll, int(self._scroll_index) + rows)
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_HOME):
+                self._scroll_index = 0
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_END):
+                self._scroll_index = max_scroll
 
     def draw(self) -> None:
         rl.clear_background(rl.BLACK)
-        if self._ground is not None:
+        pause_background = self._state.pause_background
+        if pause_background is not None:
+            pause_background.draw_pause_background()
+        elif self._ground is not None:
             self._ground.draw(0.0, 0.0)
         _draw_screen_fade(self._state)
 
+        assets = self._assets
+        if assets is None or assets.panel is None:
+            return
+
         font = self._ensure_small_font()
         request = self._request
         mode_id = int(request.game_mode_id) if request is not None else int(self._state.config.data.get("game_mode", 1) or 1)
@@ -1843,26 +1740,64 @@ class HighScoresView:
         quest_minor = int(request.quest_stage_minor) if request is not None else 0
         highlight_rank = request.highlight_rank if request is not None else None
 
-        title = "High scores"
-        subtitle = self._mode_label(mode_id, quest_major, quest_minor)
-        draw_small_text(font, title, 32.0, 120.0, 1.2, rl.Color(235, 235, 235, 255))
-        draw_small_text(font, subtitle, 32.0, 152.0, 1.0, rl.Color(190, 190, 200, 255))
+        scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
+        fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
+        panel_w = MENU_PANEL_WIDTH * scale
+        _angle_rad, left_slide_x = MenuView._ui_element_anim(
+            self,
+            index=1,
+            start_ms=PANEL_TIMELINE_START_MS,
+            end_ms=PANEL_TIMELINE_END_MS,
+            width=panel_w,
+            direction_flag=0,
+        )
+        _angle_rad, right_slide_x = MenuView._ui_element_anim(
+            self,
+            index=2,
+            start_ms=PANEL_TIMELINE_START_MS,
+            end_ms=PANEL_TIMELINE_END_MS,
+            width=panel_w,
+            direction_flag=1,
+        )
+
+        left_x0, left_y0 = self._panel_top_left(pos_x=HS_LEFT_PANEL_POS_X, pos_y=HS_LEFT_PANEL_POS_Y, scale=scale)
+        right_x0, right_y0 = self._panel_top_left(pos_x=HS_RIGHT_PANEL_POS_X, pos_y=HS_RIGHT_PANEL_POS_Y, scale=scale)
+        left_x0 += float(left_slide_x)
+        right_x0 += float(right_slide_x)
+
+        draw_classic_menu_panel(
+            assets.panel,
+            dst=rl.Rectangle(left_x0, left_y0, panel_w, HS_LEFT_PANEL_HEIGHT * scale),
+            tint=rl.WHITE,
+            shadow=fx_detail,
+        )
+        draw_classic_menu_panel(
+            assets.panel,
+            dst=rl.Rectangle(right_x0, right_y0, panel_w, HS_RIGHT_PANEL_HEIGHT * scale),
+            tint=rl.WHITE,
+            shadow=fx_detail,
+        )
+
+        title = "High scores - Quests" if int(mode_id) == 3 else f"High scores - {self._mode_label(mode_id, quest_major, quest_minor)}"
+        draw_small_text(font, title, left_x0 + 269.0 * scale, left_y0 + 41.0 * scale, 1.0 * scale, rl.Color(255, 255, 255, 255))
+        if int(mode_id) == 3:
+            quest_label = f"{int(quest_major)}.{int(quest_minor)}: {self._quest_title(quest_major, quest_minor)}"
+            draw_small_text(font, quest_label, left_x0 + 236.0 * scale, left_y0 + 63.0 * scale, 1.0 * scale, rl.Color(255, 255, 255, 255))
 
         header_color = rl.Color(255, 255, 255, int(255 * 0.85))
-        row_y0 = 188.0
-        draw_small_text(font, "Rank", 32.0, row_y0, 1.0, header_color)
-        draw_small_text(font, "Name", 96.0, row_y0, 1.0, header_color)
-        score_label = "Score" if mode_id not in (2, 3) else "Time"
-        draw_small_text(font, score_label, 320.0, row_y0, 1.0, header_color)
+        row_y0 = left_y0 + 84.0 * scale
+        draw_small_text(font, "Rank", left_x0 + 211.0 * scale, row_y0, 1.0 * scale, header_color)
+        draw_small_text(font, "Score", left_x0 + 246.0 * scale, row_y0, 1.0 * scale, header_color)
+        draw_small_text(font, "Player", left_x0 + 302.0 * scale, row_y0, 1.0 * scale, header_color)
 
-        row_step = float(font.cell_size)
-        rows = self._visible_rows(font)
+        row_step = 16.0 * scale
+        rows = 10
         start = max(0, int(self._scroll_index))
         end = min(len(self._records), start + rows)
-        y = row_y0 + row_step
+        y = left_y0 + 103.0 * scale
 
         if start >= end:
-            draw_small_text(font, "No scores yet.", 32.0, y + 8.0, 1.0, rl.Color(190, 190, 200, 255))
+            draw_small_text(font, "No scores yet.", left_x0 + 211.0 * scale, y + 8.0 * scale, 1.0 * scale, rl.Color(190, 190, 200, 255))
         else:
             for idx in range(start, end):
                 entry = self._records[idx]
@@ -1876,62 +1811,81 @@ class HighScoresView:
                 if len(name) > 16:
                     name = name[:16]
 
-                value = ""
-                if mode_id in (2, 3):
-                    seconds = float(int(getattr(entry, "survival_elapsed_ms", 0))) * 0.001
-                    value = f"{seconds:7.2f}s"
-                else:
-                    value = f"{int(getattr(entry, 'score_xp', 0)):7d}"
+                value = f"{int(getattr(entry, 'score_xp', 0))}"
 
                 color = rl.Color(255, 255, 255, int(255 * 0.7))
                 if highlight_rank is not None and int(highlight_rank) == idx:
                     color = rl.Color(255, 255, 255, 255)
 
-                draw_small_text(font, f"{idx + 1:>3}", 32.0, y, 1.0, color)
-                draw_small_text(font, name, 96.0, y, 1.0, color)
-                draw_small_text(font, value, 320.0, y, 1.0, color)
+                draw_small_text(font, f"{idx + 1}", left_x0 + 216.0 * scale, y, 1.0 * scale, color)
+                draw_small_text(font, value, left_x0 + 246.0 * scale, y, 1.0 * scale, color)
+                draw_small_text(font, name, left_x0 + 304.0 * scale, y, 1.0 * scale, color)
                 y += row_step
 
-        tex = self._button_tex
-        if tex is not None:
-            scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
-            button_w = float(tex.width) * scale
-            button_h = float(tex.height) * scale
-            gap_x = 18.0 * scale
-            x0 = 32.0
-            y0 = float(rl.get_screen_height()) - button_h - 52.0 * scale
-            x1 = x0 + button_w + gap_x
+        textures = self._button_textures
+        if textures is not None and (textures.button_sm is not None or textures.button_md is not None):
+            button_x = left_x0 + HS_BUTTON_X * scale
+            button_y0 = left_y0 + HS_BUTTON_Y0 * scale
+            w = button_width(None, self._update_button.label, scale=scale, force_wide=self._update_button.force_wide)
+            button_draw(textures, font, self._update_button, x=button_x, y=button_y0, width=w, scale=scale)
+            w = button_width(None, self._play_button.label, scale=scale, force_wide=self._play_button.force_wide)
+            button_draw(textures, font, self._play_button, x=button_x, y=button_y0 + HS_BUTTON_STEP_Y * scale, width=w, scale=scale)
+            w = button_width(None, self._back_button.label, scale=scale, force_wide=self._back_button.force_wide)
+            button_draw(
+                textures,
+                font,
+                self._back_button,
+                x=left_x0 + HS_BACK_BUTTON_X * scale,
+                y=left_y0 + HS_BACK_BUTTON_Y * scale,
+                width=w,
+                scale=scale,
+            )
 
-            buttons = [
-                ("Back", rl.Rectangle(x0, y0, button_w, button_h)),
-                ("Main menu", rl.Rectangle(x1, y0, button_w, button_h)),
-            ]
-            mouse = rl.get_mouse_position()
-            for label, rect in buttons:
-                hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-                alpha = 255 if hovered else 220
-                rl.draw_texture_pro(
-                    tex,
-                    rl.Rectangle(0.0, 0.0, float(tex.width), float(tex.height)),
-                    rect,
-                    rl.Vector2(0.0, 0.0),
-                    0.0,
-                    rl.Color(255, 255, 255, alpha),
-                )
-                label_w = measure_small_text_width(font, label, 1.0 * scale)
-                text_x = rect.x + (rect.width - label_w) * 0.5 + 1.0 * scale
-                text_y = rect.y + 10.0 * scale
-                draw_small_text(font, label, text_x, text_y, 1.0 * scale, rl.Color(20, 20, 20, 255))
+        self._draw_sign(assets)
+        _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
 
-        draw_small_text(
-            font,
-            "UP/DOWN: Scroll    PGUP/PGDN: Page    ESC: Back",
-            32.0,
-            float(rl.get_screen_height()) - 28.0,
-            1.0,
-            rl.Color(190, 190, 200, 255),
+    def _draw_sign(self, assets: MenuAssets) -> None:
+        if assets.sign is None:
+            return
+        sign = assets.sign
+        screen_w = float(self._state.config.screen_width)
+        sign_scale, shift_x = MenuView._sign_layout_scale(int(screen_w))
+        pos_x = screen_w + MENU_SIGN_POS_X_PAD
+        pos_y = MENU_SIGN_POS_Y if screen_w > MENU_SCALE_SMALL_THRESHOLD else MENU_SIGN_POS_Y_SMALL
+        sign_w = MENU_SIGN_WIDTH * sign_scale
+        sign_h = MENU_SIGN_HEIGHT * sign_scale
+        offset_x = MENU_SIGN_OFFSET_X * sign_scale + shift_x
+        offset_y = MENU_SIGN_OFFSET_Y * sign_scale
+        rotation_deg = 0.0
+        fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
+        if fx_detail:
+            MenuView._draw_ui_quad_shadow(
+                texture=sign,
+                src=rl.Rectangle(0.0, 0.0, float(sign.width), float(sign.height)),
+                dst=rl.Rectangle(pos_x + UI_SHADOW_OFFSET, pos_y + UI_SHADOW_OFFSET, sign_w, sign_h),
+                origin=rl.Vector2(-offset_x, -offset_y),
+                rotation_deg=rotation_deg,
+            )
+        MenuView._draw_ui_quad(
+            texture=sign,
+            src=rl.Rectangle(0.0, 0.0, float(sign.width), float(sign.height)),
+            dst=rl.Rectangle(pos_x, pos_y, sign_w, sign_h),
+            origin=rl.Vector2(-offset_x, -offset_y),
+            rotation_deg=rotation_deg,
+            tint=rl.WHITE,
         )
-        _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
+
+    @staticmethod
+    def _quest_title(major: int, minor: int) -> str:
+        try:
+            from .quests import quest_by_level
+
+            q = quest_by_level(f"{int(major)}.{int(minor)}")
+            if q is not None and q.title:
+                return str(q.title)
+        except Exception:
+            pass
+        return "???"
 
     def take_action(self) -> str | None:
         action = self._action
@@ -1986,6 +1940,7 @@ class GameLoopView:
         self._front_views: dict[str, FrontView] = {
             "open_play_game": PlayGameMenuView(state),
             "open_quests": QuestsMenuView(state),
+            "open_pause_menu": PauseMenuView(state),
             "start_quest": QuestGameView(state),
             "quest_results": QuestResultsView(state),
             "quest_failed": QuestFailedView(state),
@@ -1997,6 +1952,9 @@ class GameLoopView:
             "open_options": OptionsMenuView(state),
             "open_controls": ControlsMenuView(state),
             "open_statistics": StatisticsMenuView(state),
+            "open_weapon_database": UnlockedWeaponsDatabaseView(state),
+            "open_perk_database": UnlockedPerksDatabaseView(state),
+            "open_credits": CreditsView(state),
             "open_mods": ModsMenuView(state),
             "open_other_games": PanelMenuView(
                 state,
@@ -2052,6 +2010,7 @@ class GameLoopView:
         if self._front_active is not None:
             action = self._front_active.take_action()
             if action == "back_to_menu":
+                self._state.pause_background = None
                 self._front_active.close()
                 self._front_active = None
                 while self._front_stack:
@@ -2064,14 +2023,44 @@ class GameLoopView:
                 if self._front_stack:
                     self._front_active.close()
                     self._front_active = self._front_stack.pop()
+                    if self._front_active in self._gameplay_views:
+                        self._state.pause_background = None
                     self._active = self._front_active
                     return
                 self._front_active.close()
                 self._front_active = None
+                self._state.pause_background = None
                 self._menu.open()
                 self._active = self._menu
                 self._menu_active = True
                 return
+            if action == "open_pause_menu":
+                pause_view = self._front_views.get("open_pause_menu")
+                if pause_view is None:
+                    return
+                if self._front_active in self._gameplay_views:
+                    self._state.pause_background = self._front_active
+                    self._front_stack.append(self._front_active)
+                    pause_view.open()
+                    self._front_active = pause_view
+                    self._active = pause_view
+                    return
+                if self._state.pause_background is None:
+                    # Options panel uses open_pause_menu as back_action; when no game is
+                    # running, treat it like back_to_menu.
+                    self._front_active.close()
+                    self._front_active = None
+                    while self._front_stack:
+                        self._front_stack.pop().close()
+                    self._menu.open()
+                    self._active = self._menu
+                    self._menu_active = True
+                    return
+                self._front_active.close()
+                pause_view.open()
+                self._front_active = pause_view
+                self._active = pause_view
+                return
             if action in {"start_survival", "start_rush", "start_typo"}:
                 # Temporary: bump the counter on mode start so the Play Game overlay (F1)
                 # and Statistics screen reflect activity.
@@ -2085,9 +2074,26 @@ class GameLoopView:
             if action is not None:
                 view = self._front_views.get(action)
                 if view is not None:
-                    if action == "open_high_scores":
+                    if action in {"open_high_scores", "open_weapon_database", "open_perk_database", "open_credits"}:
+                        if (self._front_active in self._gameplay_views) and (self._state.pause_background is None):
+                            self._state.pause_background = self._front_active
+                        self._front_stack.append(self._front_active)
+                    elif action in {"quest_results", "quest_failed"} and (self._front_active in self._gameplay_views):
+                        self._state.pause_background = self._front_active
                         self._front_stack.append(self._front_active)
                     else:
+                        if action in {
+                            "start_survival",
+                            "start_rush",
+                            "start_typo",
+                            "start_tutorial",
+                            "start_quest",
+                            "open_play_game",
+                            "open_quests",
+                        }:
+                            self._state.pause_background = None
+                            while self._front_stack:
+                                self._front_stack.pop().close()
                         self._front_active.close()
                     view.open()
                     self._front_active = view
@@ -2524,6 +2530,7 @@ def run_game(config: GameConfig) -> None:
             title="Crimsonland",
             fps=config.fps,
             config_flags=config_flags,
+            exit_key=rl.KeyboardKey.KEY_NULL,
         )
         if state is not None:
             state.status.save_if_dirty()