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

crimson/frontend/panels/play_game.py

@@ -9,13 +9,12 @@ from grim.audio import update_audio
 from grim.fonts.small import SmallFontData, draw_small_text, load_small_font, measure_small_text_width
 
 from ...debug import debug_enabled
+from ...ui.perk_menu import UiButtonState, UiButtonTextureSet, button_draw, button_update, button_width
 
 from ..menu import (
     MENU_LABEL_ROW_HEIGHT,
     MENU_LABEL_ROW_PLAY_GAME,
     MENU_LABEL_WIDTH,
-    MENU_PANEL_OFFSET_X,
-    MENU_PANEL_OFFSET_Y,
     MENU_PANEL_WIDTH,
     MenuView,
     _draw_menu_cursor,
@@ -49,11 +48,14 @@ class PlayGameMenuView(PanelMenuView):
         super().__init__(
             state,
             title="Play Game",
+            panel_offset_x=-63.0,
+            panel_height=278.0,
             back_pos_y=462.0,
         )
         self._small_font: SmallFontData | None = None
         self._button_sm: rl.Texture2D | None = None
         self._button_md: rl.Texture2D | None = None
+        self._button_textures: UiButtonTextureSet | None = None
         self._drop_on: rl.Texture2D | None = None
         self._drop_off: rl.Texture2D | None = None
 
@@ -62,17 +64,20 @@ class PlayGameMenuView(PanelMenuView):
 
         # Hover fade timers for tooltips (0..1000ms-ish; original uses ~0.0009 alpha scale).
         self._tooltip_ms: dict[str, int] = {}
+        self._mode_buttons: dict[str, UiButtonState] = {}
 
     def open(self) -> None:
         super().open()
         cache = self._ensure_cache()
         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._drop_on = cache.get_or_load("ui_dropOn", "ui/ui_dropDownOn.jaz").texture
         self._drop_off = cache.get_or_load("ui_dropOff", "ui/ui_dropDownOff.jaz").texture
         self._player_list_open = False
         self._dirty = False
         self._tooltip_ms.clear()
+        self._mode_buttons.clear()
 
     def update(self, dt: float) -> None:
         if self._state.audio is not None:
@@ -133,14 +138,24 @@ class PlayGameMenuView(PanelMenuView):
         if consumed_click:
             return
 
-        # Mode buttons (disabled while the player dropdown is open).
-        if self._player_list_open:
-            return
+        mouse = rl.get_mouse_position()
+        click = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
+        button_enabled = not self._player_list_open
+
         y = base_y
         entries, y_step, y_start, y_end = self._mode_entries()
         y += y_start * scale
         for mode in entries:
-            clicked, hovered = self._update_mode_button(mode, base_x, y, scale)
+            clicked, hovered = self._update_mode_button(
+                mode,
+                base_x,
+                y,
+                scale,
+                dt_ms=dt_ms,
+                mouse=mouse,
+                click=click,
+                enabled=button_enabled,
+            )
             self._update_tooltip_timer(mode.key, hovered, dt_ms)
             if clicked:
                 self._activate_mode(mode)
@@ -155,9 +170,7 @@ class PlayGameMenuView(PanelMenuView):
             self._tooltip_ms[key] = max(0, self._tooltip_ms[key] - dt_ms * 2)
 
     def draw(self) -> None:
-        rl.clear_background(rl.BLACK)
-        if self._ground is not None:
-            self._ground.draw(0.0, 0.0)
+        self._draw_background()
         _draw_screen_fade(self._state)
         assets = self._assets
         entry = self._entry
@@ -198,8 +211,8 @@ class PlayGameMenuView(PanelMenuView):
         )
         panel_x = self._panel_pos_x + slide_x
         panel_y = self._panel_pos_y + self._widescreen_y_shift
-        origin_x = -(MENU_PANEL_OFFSET_X * panel_scale)
-        origin_y = -(MENU_PANEL_OFFSET_Y * panel_scale)
+        origin_x = -(self._panel_offset_x * panel_scale)
+        origin_y = -(self._panel_offset_y * panel_scale)
         panel_left = panel_x - origin_x
         panel_top = panel_y - origin_y
 
@@ -325,31 +338,33 @@ class PlayGameMenuView(PanelMenuView):
         y_end = y_start + y_step * float(len(entries))
         return entries, y_step, y_start, y_end
 
-    def _button_tex_for_label(self, label: str, scale: float) -> rl.Texture2D | None:
-        md = self._button_md
-        sm = self._button_sm
-        if md is None:
-            return sm
-        if sm is None:
-            return md
-
-        # `ui_button_update` picks between button sizes based on rendered label width.
+    def _mode_button_state(self, mode: _PlayGameModeEntry) -> UiButtonState:
+        state = self._mode_buttons.get(mode.key)
+        if state is None:
+            state = UiButtonState(mode.label)
+            self._mode_buttons[mode.key] = state
+        else:
+            state.label = mode.label
+        return state
+
+    def _update_mode_button(
+        self,
+        mode: _PlayGameModeEntry,
+        x: float,
+        y: float,
+        scale: float,
+        *,
+        dt_ms: int,
+        mouse: rl.Vector2,
+        click: bool,
+        enabled: bool,
+    ) -> tuple[bool, bool]:
+        state = self._mode_button_state(mode)
+        state.enabled = bool(enabled)
         font = self._ensure_small_font()
-        label_w = measure_small_text_width(font, label, 1.0 * scale)
-        return sm if label_w < 40.0 * scale else md
-
-    def _mode_button_rect(self, label: str, x: float, y: float, scale: float) -> rl.Rectangle:
-        tex = self._button_tex_for_label(label, scale)
-        if tex is None:
-            return rl.Rectangle(x, y, 145.0 * scale, 32.0 * scale)
-        return rl.Rectangle(x, y, float(tex.width) * scale, float(tex.height) * scale)
-
-    def _update_mode_button(self, mode: _PlayGameModeEntry, x: float, y: float, scale: float) -> tuple[bool, bool]:
-        rect = self._mode_button_rect(mode.label, x, y, scale)
-        mouse = rl.get_mouse_position()
-        hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-        clicked = hovered and rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
-        return clicked, hovered
+        width = button_width(font, state.label, scale=scale, force_wide=state.force_wide)
+        clicked = button_update(state, x=x, y=y, width=width, dt_ms=float(dt_ms), mouse=mouse, click=bool(click))
+        return clicked, state.hovered
 
     def _activate_mode(self, mode: _PlayGameModeEntry) -> None:
         if mode.game_mode is not None:
@@ -456,19 +471,24 @@ class PlayGameMenuView(PanelMenuView):
         text_scale = 1.0 * scale
         text_color = rl.Color(255, 255, 255, int(255 * 0.8))
 
-        # Panel title label from ui_itemTexts (same as OptionsMenuView).
+        # `sub_44ed80`: title label at (xy - 64, var_1c - 8), size 128x32.
+        title_w = 128.0
+        title_h = MENU_LABEL_ROW_HEIGHT
+        title_x = base_x - 64.0 * scale
+        title_y = base_y - 8.0 * scale
+
         if labels_tex is not None:
             src = rl.Rectangle(
                 0.0,
                 float(MENU_LABEL_ROW_PLAY_GAME) * MENU_LABEL_ROW_HEIGHT,
-                MENU_LABEL_WIDTH,
-                MENU_LABEL_ROW_HEIGHT,
+                title_w,
+                title_h,
             )
             dst = rl.Rectangle(
-                panel_left + 212.0 * scale,
-                panel_top + 32.0 * scale,
-                MENU_LABEL_WIDTH * scale,
-                MENU_LABEL_ROW_HEIGHT * scale,
+                title_x,
+                title_y,
+                title_w * scale,
+                title_h * scale,
             )
             MenuView._draw_ui_quad(
                 texture=labels_tex,
@@ -479,9 +499,7 @@ class PlayGameMenuView(PanelMenuView):
                 tint=rl.WHITE,
             )
         else:
-            rl.draw_text(self._title, int(panel_left + 212.0 * scale), int(panel_top + 32.0 * scale), int(24 * scale), rl.WHITE)
-
-        self._draw_player_count(drop_x, drop_y, scale)
+            rl.draw_text(self._title, int(title_x), int(title_y), int(24 * scale), rl.WHITE)
 
         entries, y_step, y_start, y_end = self._mode_entries()
         y = base_y + y_start * scale
@@ -496,6 +514,8 @@ class PlayGameMenuView(PanelMenuView):
                 self._draw_mode_count(mode.key, base_x + 158.0 * scale, y + 8.0 * scale, text_scale, text_color)
             y += y_step * scale
 
+        # `sub_44ed80`: the list widget is drawn before tooltips, so tooltips can overlay it.
+        self._draw_player_count(drop_x, drop_y, scale)
         self._draw_tooltips(entries, base_x, base_y, y_end, scale)
 
     def _draw_player_count(self, x: float, y: float, scale: float) -> None:
@@ -518,13 +538,18 @@ class PlayGameMenuView(PanelMenuView):
 
         # `ui_list_widget_update` draws a single bordered black rect for the widget.
         widget_h = full_h if self._player_list_open else header_h
-        rl.draw_rectangle(int(x), int(y), int(w), int(widget_h), rl.BLACK)
-        rl.draw_rectangle_lines(int(x), int(y), int(w), int(widget_h), rl.WHITE)
+        rl.draw_rectangle(int(x), int(y), int(w), int(widget_h), rl.WHITE)
+        inner_w = max(0, int(w) - 2)
+        inner_h = max(0, int(widget_h) - 2)
+        rl.draw_rectangle(int(x) + 1, int(y) + 1, inner_w, inner_h, rl.BLACK)
 
         # Arrow icon (the ui_drop* assets are 16x16 icons, not the background).
         mouse = rl.get_mouse_position()
         hovered_header = x <= mouse.x <= x + w and y <= mouse.y <= y + header_h
         arrow_tex = drop_on if (self._player_list_open or hovered_header) else drop_off
+        if self._player_list_open or hovered_header:
+            line_h = max(1, int(1.0 * scale))
+            rl.draw_rectangle(int(x), int(y + 15.0 * scale), int(w), line_h, rl.Color(255, 255, 255, 128))
         if arrow_tex is not None:
             rl.draw_texture_pro(
                 arrow_tex,
@@ -541,7 +566,7 @@ class PlayGameMenuView(PanelMenuView):
         if player_count > len(self._PLAYER_COUNT_LABELS):
             player_count = len(self._PLAYER_COUNT_LABELS)
         label = self._PLAYER_COUNT_LABELS[player_count - 1]
-        header_alpha = 191 if self._player_list_open else 242  # 0x3f400000 / 0x3f733333
+        header_alpha = 242 if hovered_header else 191  # 0x3f733333 / 0x3f400000
         draw_small_text(font, label, text_x, text_y, text_scale, rl.Color(255, 255, 255, header_alpha))
 
         if not self._player_list_open:
@@ -550,7 +575,7 @@ class PlayGameMenuView(PanelMenuView):
         for idx, item in enumerate(self._PLAYER_COUNT_LABELS):
             item_y = rows_y0 + row_h * float(idx)
             hovered = x <= mouse.x <= x + w and item_y <= mouse.y <= item_y + row_h
-            alpha = 179  # 0x3f333333
+            alpha = 153  # 0x3f19999a
             if hovered:
                 alpha = 242  # 0x3f733333
             if idx == (player_count - 1):
@@ -558,32 +583,15 @@ class PlayGameMenuView(PanelMenuView):
             draw_small_text(font, item, text_x, item_y, text_scale, rl.Color(255, 255, 255, alpha))
 
     def _draw_mode_button(self, mode: _PlayGameModeEntry, x: float, y: float, scale: float) -> None:
-        tex = self._button_tex_for_label(mode.label, scale)
+        textures = self._button_textures
+        if textures is None:
+            return
+        if textures.button_sm is None and textures.button_md is None:
+            return
         font = self._ensure_small_font()
-        rect = self._mode_button_rect(mode.label, x, y, scale)
-
-        mouse = rl.get_mouse_position()
-        hovered = rect.x <= mouse.x <= rect.x + rect.width and rect.y <= mouse.y <= rect.y + rect.height
-        alpha = 255
-
-        if tex is not None:
-            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),
-            )
-        else:
-            rl.draw_rectangle_lines(int(rect.x), int(rect.y), int(rect.width), int(rect.height), rl.Color(255, 255, 255, alpha))
-
-        label_w = measure_small_text_width(font, mode.label, 1.0 * scale)
-        # `ui_button_update` uses x centered (+1) and y = y + 10 (not fully centered).
-        text_x = rect.x + (rect.width - label_w) * 0.5 + 1.0 * scale
-        text_y = rect.y + 10.0 * scale
-        text_alpha = 255 if hovered else 179  # 0x3f800000 / 0x3f333333
-        draw_small_text(font, mode.label, text_x, text_y, 1.0 * scale, rl.Color(255, 255, 255, text_alpha))
+        state = self._mode_button_state(mode)
+        width = button_width(font, state.label, scale=scale, force_wide=state.force_wide)
+        button_draw(textures, font, state, x=x, y=y, width=width, scale=scale)
 
     def _draw_mode_count(self, key: str, x: float, y: float, scale: float, color: rl.Color) -> None:
         status = self._state.status