crimsonland 0.1.0.dev12__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,6 +85,8 @@ 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
@@ -80,7 +95,8 @@ 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.perk_menu import UiButtonState, UiButtonTextureSet, button_draw, button_update, button_width, draw_menu_panel
+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
 
@@ -144,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
@@ -171,7 +188,7 @@ QUEST_HARDCORE_LIST_Y_SHIFT = 10.0
 
 QUEST_BACK_BUTTON_X_OFFSET = 138.0
 QUEST_BACK_BUTTON_Y_OFFSET = 212.0
-QUEST_PANEL_HEIGHT = 379.0
+QUEST_PANEL_HEIGHT = 378.0
 
 
 class QuestsMenuView:
@@ -719,10 +736,10 @@ class QuestsMenuView:
         if panel is None:
             return
         fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
-        draw_menu_panel(
+        draw_classic_menu_panel(
             panel,
             dst=rl.Rectangle(
-                float(QUEST_MENU_BASE_X + MENU_PANEL_OFFSET_X),
+                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),
@@ -1531,14 +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._back_button = UiButtonState("Back", force_wide=True)
-        self._main_menu_button = UiButtonState("Main menu", force_wide=True)
+        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 = []
@@ -1547,14 +1569,20 @@ 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._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._back_button = UiButtonState("Back", force_wide=True)
-        self._main_menu_button = UiButtonState("Main menu", force_wide=True)
+        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_buttonMd", "ui/ui_button_128x32.jaz").texture
@@ -1595,12 +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)
@@ -1608,62 +1642,83 @@ 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
 
         textures = self._button_textures
-        if textures is not None and (textures.button_sm is not None or textures.button_md is not None):
+        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 = button_width(None, self._back_button.label, scale=scale, force_wide=self._back_button.force_wide)
-            button_h = 32.0 * scale
-            gap_x = 18.0 * scale
-            x0 = 32.0
-            y0 = float(rl.get_screen_height()) - button_h - 52.0 * scale
+            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)
-            dt_ms = min(float(dt), 0.1) * 1000.0
-            if button_update(self._back_button, x=x0, y=y0, width=button_w, dt_ms=dt_ms, mouse=mouse, click=click):
+            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
+            w = button_width(None, self._play_button.label, scale=scale, force_wide=self._play_button.force_wide)
             if button_update(
-                self._main_menu_button,
-                x=x0 + button_w + gap_x,
-                y=y0,
-                width=button_w,
+                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)
@@ -1674,6 +1729,10 @@ class HighScoresView:
             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)
@@ -1681,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]
@@ -1714,44 +1811,82 @@ 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
 
         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 = button_width(None, self._back_button.label, scale=scale, force_wide=self._back_button.force_wide)
-            button_h = 32.0 * 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
-            button_draw(textures, font, self._back_button, x=x0, y=y0, width=button_w, scale=scale)
-            button_draw(textures, font, self._main_menu_button, x=x1, y=y0, width=button_w, scale=scale)
+            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,
+            )
 
-        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),
-        )
+        self._draw_sign(assets)
         _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
 
+    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,
+        )
+
+    @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
         self._action = None
@@ -1817,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,
@@ -1936,7 +2074,7 @@ 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)

crimson/modes/quest_mode.py

@@ -24,7 +24,9 @@ from ..quests.types import QuestContext, QuestDefinition, SpawnEntry
 from ..terrain_assets import terrain_texture_by_id
 from ..ui.cursor import draw_aim_cursor, draw_menu_cursor
 from ..ui.hud import draw_hud_overlay, hud_flags_for_game_mode
+from ..ui.menu_panel import draw_classic_menu_panel
 from ..ui.perk_menu import (
+    PERK_MENU_TRANSITION_MS,
     PerkMenuAssets,
     PerkMenuLayout,
     UiButtonState,
@@ -32,10 +34,10 @@ from ..ui.perk_menu import (
     button_update,
     button_width,
     draw_menu_item,
-    draw_menu_panel,
     draw_ui_text,
     load_perk_menu_assets,
     menu_item_hit_rect,
+    perk_menu_panel_slide_x,
     perk_menu_compute_layout,
     ui_origin,
     ui_scale,
@@ -78,8 +80,6 @@ PERK_PROMPT_LEVEL_UP_SHIFT_Y = -4.0
 PERK_PROMPT_TEXT_MARGIN_X = 16.0
 PERK_PROMPT_TEXT_OFFSET_Y = 8.0
 
-PERK_MENU_TRANSITION_MS = 500.0
-
 
 @dataclass(slots=True)
 class _QuestRunState:
@@ -440,8 +440,7 @@ class QuestMode(BaseGameplayMode):
         screen_h = float(rl.get_screen_height())
         scale = ui_scale(screen_w, screen_h)
         origin_x, origin_y = ui_origin(screen_w, screen_h, scale)
-        menu_t = _clamp(self._perk_menu_timeline_ms / PERK_MENU_TRANSITION_MS, 0.0, 1.0)
-        slide_x = (menu_t - 1.0) * (self._perk_ui_layout.panel_w * scale)
+        slide_x = perk_menu_panel_slide_x(self._perk_menu_timeline_ms, width=self._perk_ui_layout.panel_w)
 
         mouse = self._ui_mouse_pos()
         click = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
@@ -451,12 +450,13 @@ class QuestMode(BaseGameplayMode):
         computed = perk_menu_compute_layout(
             self._perk_ui_layout,
             screen_w=screen_w,
-            origin_x=origin_x + slide_x,
+            origin_x=origin_x,
             origin_y=origin_y,
             scale=scale,
             choice_count=len(choices),
             expert_owned=expert_owned,
             master_owned=master_owned,
+            panel_slide_x=slide_x,
         )
 
         fx_toggle = int(self._config.data.get("fx_toggle", 0) or 0) if self._config is not None else 0
@@ -634,25 +634,26 @@ class QuestMode(BaseGameplayMode):
         screen_h = float(rl.get_screen_height())
         scale = ui_scale(screen_w, screen_h)
         origin_x, origin_y = ui_origin(screen_w, screen_h, scale)
-        slide_x = (menu_t - 1.0) * (self._perk_ui_layout.panel_w * scale)
+        slide_x = perk_menu_panel_slide_x(self._perk_menu_timeline_ms, width=self._perk_ui_layout.panel_w)
 
         master_owned = int(self._player.perk_counts[int(PerkId.PERK_MASTER)]) > 0
         expert_owned = int(self._player.perk_counts[int(PerkId.PERK_EXPERT)]) > 0
         computed = perk_menu_compute_layout(
             self._perk_ui_layout,
             screen_w=screen_w,
-            origin_x=origin_x + slide_x,
+            origin_x=origin_x,
             origin_y=origin_y,
             scale=scale,
             choice_count=len(choices),
             expert_owned=expert_owned,
             master_owned=master_owned,
+            panel_slide_x=slide_x,
         )
 
         panel_tex = self._perk_menu_assets.menu_panel
         if panel_tex is not None:
             fx_detail = bool(int(self._config.data.get("fx_detail_0", 0) or 0)) if self._config is not None else False
-            draw_menu_panel(panel_tex, dst=computed.panel, shadow=fx_detail)
+            draw_classic_menu_panel(panel_tex, dst=computed.panel, shadow=fx_detail)
 
         title_tex = self._perk_menu_assets.title_pick_perk
         if title_tex is not None:

crimson/modes/survival_mode.py

@@ -19,18 +19,20 @@ from ..persistence.highscores import HighScoreRecord
 from ..perks import PerkId, perk_display_description, perk_display_name
 from ..ui.cursor import draw_aim_cursor, draw_menu_cursor
 from ..ui.hud import draw_hud_overlay, hud_flags_for_game_mode
+from ..ui.menu_panel import draw_classic_menu_panel
 from ..input_codes import config_keybinds, input_code_is_down, input_code_is_pressed, player_move_fire_binds
 from ..ui.perk_menu import (
+    PERK_MENU_TRANSITION_MS,
     PerkMenuLayout,
     UiButtonState,
     button_draw,
     button_update,
     button_width,
-    draw_menu_panel,
     draw_menu_item,
     draw_ui_text,
     load_perk_menu_assets,
     menu_item_hit_rect,
+    perk_menu_panel_slide_x,
     perk_menu_compute_layout,
     ui_origin,
     ui_scale,
@@ -69,8 +71,6 @@ PERK_PROMPT_LEVEL_UP_SHIFT_Y = -4.0
 PERK_PROMPT_TEXT_MARGIN_X = 16.0
 PERK_PROMPT_TEXT_OFFSET_Y = 8.0
 
-PERK_MENU_TRANSITION_MS = 500.0
-
 
 @dataclass(slots=True)
 class _SurvivalState:
@@ -358,8 +358,7 @@ class SurvivalMode(BaseGameplayMode):
         screen_h = float(rl.get_screen_height())
         scale = ui_scale(screen_w, screen_h)
         origin_x, origin_y = ui_origin(screen_w, screen_h, scale)
-        menu_t = _clamp(self._perk_menu_timeline_ms / PERK_MENU_TRANSITION_MS, 0.0, 1.0)
-        slide_x = (menu_t - 1.0) * (self._perk_ui_layout.panel_w * scale)
+        slide_x = perk_menu_panel_slide_x(self._perk_menu_timeline_ms, width=self._perk_ui_layout.panel_w)
 
         mouse = self._ui_mouse_pos()
         click = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
@@ -369,12 +368,13 @@ class SurvivalMode(BaseGameplayMode):
         computed = perk_menu_compute_layout(
             self._perk_ui_layout,
             screen_w=screen_w,
-            origin_x=origin_x + slide_x,
+            origin_x=origin_x,
             origin_y=origin_y,
             scale=scale,
             choice_count=len(choices),
             expert_owned=expert_owned,
             master_owned=master_owned,
+            panel_slide_x=slide_x,
         )
 
         fx_toggle = int(self._config.data.get("fx_toggle", 0) or 0) if self._config is not None else 0
@@ -654,25 +654,26 @@ class SurvivalMode(BaseGameplayMode):
         screen_h = float(rl.get_screen_height())
         scale = ui_scale(screen_w, screen_h)
         origin_x, origin_y = ui_origin(screen_w, screen_h, scale)
-        slide_x = (menu_t - 1.0) * (self._perk_ui_layout.panel_w * scale)
+        slide_x = perk_menu_panel_slide_x(self._perk_menu_timeline_ms, width=self._perk_ui_layout.panel_w)
 
         master_owned = int(self._player.perk_counts[int(PerkId.PERK_MASTER)]) > 0
         expert_owned = int(self._player.perk_counts[int(PerkId.PERK_EXPERT)]) > 0
         computed = perk_menu_compute_layout(
             self._perk_ui_layout,
             screen_w=screen_w,
-            origin_x=origin_x + slide_x,
+            origin_x=origin_x,
             origin_y=origin_y,
             scale=scale,
             choice_count=len(choices),
             expert_owned=expert_owned,
             master_owned=master_owned,
+            panel_slide_x=slide_x,
         )
 
         panel_tex = self._perk_menu_assets.menu_panel
         if panel_tex is not None:
             fx_detail = bool(int(self._config.data.get("fx_detail_0", 0) or 0)) if self._config is not None else False
-            draw_menu_panel(panel_tex, dst=computed.panel, shadow=fx_detail)
+            draw_classic_menu_panel(panel_tex, dst=computed.panel, shadow=fx_detail)
 
         title_tex = self._perk_menu_assets.title_pick_perk
         if title_tex is not None: