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

crimson/ui/menu_panel.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import pyray as rl
+
+from .shadow import UI_SHADOW_OFFSET, draw_ui_quad_shadow
+
+
+# Classic menu panel is rendered from the *inset* inner region of ui_menuPanel:
+#   - X inset: 1px on each side (uv 1/512 .. 511/512) => 510px wide
+#   - Y inset: 1px on each side (uv 1/256 .. 255/256) => 254px tall
+#
+# When a panel is taller than the base height, the original stretches it using a
+# 3-slice: [top][mid][bottom]. The source slice boundaries are at y=130 and y=150
+# in the texture (see grim UVs in ui_render_trace).
+MENU_PANEL_INSET = 1.0
+MENU_PANEL_SRC_SLICE_Y1 = 130.0
+MENU_PANEL_SRC_SLICE_Y2 = 150.0
+
+# Destination slice heights observed in the original at scale=1.0 (1024x768).
+MENU_PANEL_DST_TOP_H = 138.0
+MENU_PANEL_DST_BOTTOM_H = 116.0
+
+
+def draw_classic_menu_panel(
+    texture: rl.Texture2D,
+    *,
+    dst: rl.Rectangle,
+    tint: rl.Color = rl.WHITE,
+    shadow: bool = False,
+) -> None:
+    """
+    Draw a classic menu panel (ui_menuPanel) with the same slicing behavior as the original.
+
+    - Uses inset source rect (1px border skipped) to match the vertex/UV inset.
+    - Uses 3-slice only when dst is taller than (top + bottom); otherwise draws a single quad.
+    """
+
+    tex_w = float(texture.width)
+    tex_h = float(texture.height)
+    if tex_w <= 0.0 or tex_h <= 0.0:
+        return
+
+    inset = MENU_PANEL_INSET
+    src_x = inset
+    src_y = inset
+    src_w = max(0.0, tex_w - inset * 2.0)
+    src_h = max(0.0, tex_h - inset * 2.0)
+
+    # Scale slice heights with the panel width (menu panel uses the same scale factor).
+    # dst.width is already in our "inset" width space (510 at scale=1.0).
+    scale = (float(dst.width) / 510.0) if float(dst.width) != 0.0 else 1.0
+    top_h = MENU_PANEL_DST_TOP_H * scale
+    bottom_h = MENU_PANEL_DST_BOTTOM_H * scale
+    mid_h = float(dst.height) - top_h - bottom_h
+
+    origin = rl.Vector2(0.0, 0.0)
+
+    if mid_h <= 0.0:
+        src = rl.Rectangle(src_x, src_y, src_w, src_h)
+        if shadow:
+            draw_ui_quad_shadow(
+                texture=texture,
+                src=src,
+                dst=rl.Rectangle(
+                    float(dst.x + UI_SHADOW_OFFSET),
+                    float(dst.y + UI_SHADOW_OFFSET),
+                    float(dst.width),
+                    float(dst.height),
+                ),
+                origin=origin,
+                rotation_deg=0.0,
+            )
+        rl.draw_texture_pro(texture, src, dst, origin, 0.0, tint)
+        return
+
+    # Source slice rects (in texture pixels, with 1px inset).
+    src_top = rl.Rectangle(src_x, src_y, src_w, max(0.0, MENU_PANEL_SRC_SLICE_Y1 - inset))
+    src_mid = rl.Rectangle(src_x, MENU_PANEL_SRC_SLICE_Y1, src_w, max(0.0, MENU_PANEL_SRC_SLICE_Y2 - MENU_PANEL_SRC_SLICE_Y1))
+    src_bot = rl.Rectangle(src_x, MENU_PANEL_SRC_SLICE_Y2, src_w, max(0.0, (tex_h - inset) - MENU_PANEL_SRC_SLICE_Y2))
+
+    # Destination slices.
+    dst_top = rl.Rectangle(float(dst.x), float(dst.y), float(dst.width), float(top_h))
+    dst_mid = rl.Rectangle(float(dst.x), float(dst.y) + float(top_h), float(dst.width), float(mid_h))
+    dst_bot = rl.Rectangle(float(dst.x), float(dst.y) + float(top_h) + float(mid_h), float(dst.width), float(bottom_h))
+
+    if shadow:
+        draw_ui_quad_shadow(
+            texture=texture,
+            src=src_top,
+            dst=rl.Rectangle(
+                float(dst_top.x + UI_SHADOW_OFFSET),
+                float(dst_top.y + UI_SHADOW_OFFSET),
+                float(dst_top.width),
+                float(dst_top.height),
+            ),
+            origin=origin,
+            rotation_deg=0.0,
+        )
+        draw_ui_quad_shadow(
+            texture=texture,
+            src=src_mid,
+            dst=rl.Rectangle(
+                float(dst_mid.x + UI_SHADOW_OFFSET),
+                float(dst_mid.y + UI_SHADOW_OFFSET),
+                float(dst_mid.width),
+                float(dst_mid.height),
+            ),
+            origin=origin,
+            rotation_deg=0.0,
+        )
+        draw_ui_quad_shadow(
+            texture=texture,
+            src=src_bot,
+            dst=rl.Rectangle(
+                float(dst_bot.x + UI_SHADOW_OFFSET),
+                float(dst_bot.y + UI_SHADOW_OFFSET),
+                float(dst_bot.width),
+                float(dst_bot.height),
+            ),
+            origin=origin,
+            rotation_deg=0.0,
+        )
+
+    rl.draw_texture_pro(texture, src_top, dst_top, origin, 0.0, tint)
+    rl.draw_texture_pro(texture, src_mid, dst_mid, origin, 0.0, tint)
+    rl.draw_texture_pro(texture, src_bot, dst_bot, origin, 0.0, tint)
+

crimson/ui/perk_menu.py

@@ -2,19 +2,26 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Protocol
 
 import pyray as rl
 
 from grim.assets import TextureLoader
 from grim.fonts.small import SmallFontData, draw_small_text, measure_small_text_width
 
+from .menu_panel import draw_classic_menu_panel
+
 
 UI_BASE_WIDTH = 640.0
 UI_BASE_HEIGHT = 480.0
 
-
-MENU_PANEL_SLICE_Y1 = 130.0
-MENU_PANEL_SLICE_Y2 = 150.0
+# Perk selection screen panel uses ui_element-style timeline animation:
+# - fully hidden until end_ms
+# - slides in over (end_ms..start_ms)
+# - fully visible at start_ms
+PERK_MENU_ANIM_START_MS = 400.0
+PERK_MENU_ANIM_END_MS = 100.0
+PERK_MENU_TRANSITION_MS = PERK_MENU_ANIM_START_MS
 
 # Layout offsets from the classic game (perk selection screen), derived from
 # `perk_selection_screen_update` (see analysis/ghidra + BN).
@@ -42,11 +49,13 @@ MENU_DESC_RIGHT_X = 480.0
 @dataclass(slots=True)
 class PerkMenuLayout:
     # Coordinates live in the original 640x480 UI space.
-    # Matches the classic menu panel: pos (-45, 110) + offset (20, -82).
-    panel_x: float = -25.0
-    panel_y: float = 28.0
-    panel_w: float = 512.0
-    panel_h: float = 379.0
+    # Capture (1024x768) shows the perk menu panel uses the 3-slice variant:
+    #   open bbox (-108,119) -> (402,497)
+    # which corresponds to ui_element pos (-45,110) + geom (-63,-81) and size 510x378.
+    panel_x: float = -108.0
+    panel_y: float = 29.0
+    panel_w: float = 510.0
+    panel_h: float = 378.0
 
 
 @dataclass(slots=True)
@@ -142,32 +151,47 @@ def perk_menu_compute_layout(
         cancel_y=float(cancel_y),
     )
 
+def ui_element_slide_x(
+    t_ms: float,
+    *,
+    start_ms: float,
+    end_ms: float,
+    width: float,
+    direction_flag: int = 0,
+) -> float:
+    """
+    Slide offset helper matching ui_element_update semantics (see MenuView._ui_element_anim).
+
+    direction_flag=0: slide from left  (-width -> 0)
+    direction_flag=1: slide from right (+width -> 0)
+    """
+
+    if start_ms <= end_ms or width <= 0.0:
+        return 0.0
+
+    width = abs(float(width))
+    t = float(t_ms)
+    if t < float(end_ms):
+        slide = width
+    elif t < float(start_ms):
+        elapsed = t - float(end_ms)
+        span = float(start_ms) - float(end_ms)
+        p = elapsed / span if span > 1e-6 else 1.0
+        slide = (1.0 - p) * width
+    else:
+        slide = 0.0
 
-def draw_menu_panel(texture: rl.Texture, *, dst: rl.Rectangle, tint: rl.Color = rl.WHITE) -> None:
-    scale = float(dst.width) / float(texture.width)
-    top_h = MENU_PANEL_SLICE_Y1 * scale
-    bottom_h = (float(texture.height) - MENU_PANEL_SLICE_Y2) * scale
-    mid_h = float(dst.height) - top_h - bottom_h
-    if mid_h < 0.0:
-        src = rl.Rectangle(0.0, 0.0, float(texture.width), float(texture.height))
-        rl.draw_texture_pro(texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, tint)
-        return
-
-    src_w = float(texture.width)
-    src_h = float(texture.height)
-
-    src_top = rl.Rectangle(0.0, 0.0, src_w, MENU_PANEL_SLICE_Y1)
-    src_mid = rl.Rectangle(0.0, MENU_PANEL_SLICE_Y1, src_w, MENU_PANEL_SLICE_Y2 - MENU_PANEL_SLICE_Y1)
-    src_bot = rl.Rectangle(0.0, MENU_PANEL_SLICE_Y2, src_w, src_h - MENU_PANEL_SLICE_Y2)
+    return slide if int(direction_flag) else -slide
 
-    dst_top = rl.Rectangle(float(dst.x), float(dst.y), float(dst.width), top_h)
-    dst_mid = rl.Rectangle(float(dst.x), float(dst.y) + top_h, float(dst.width), mid_h)
-    dst_bot = rl.Rectangle(float(dst.x), float(dst.y) + top_h + mid_h, float(dst.width), bottom_h)
 
-    origin = rl.Vector2(0.0, 0.0)
-    rl.draw_texture_pro(texture, src_top, dst_top, origin, 0.0, tint)
-    rl.draw_texture_pro(texture, src_mid, dst_mid, origin, 0.0, tint)
-    rl.draw_texture_pro(texture, src_bot, dst_bot, origin, 0.0, tint)
+def perk_menu_panel_slide_x(t_ms: float, *, width: float) -> float:
+    return ui_element_slide_x(
+        t_ms,
+        start_ms=PERK_MENU_ANIM_START_MS,
+        end_ms=PERK_MENU_ANIM_END_MS,
+        width=width,
+        direction_flag=0,
+    )
 
 
 @dataclass(slots=True)
@@ -198,11 +222,11 @@ def load_perk_menu_assets(assets_root: Path) -> PerkMenuAssets:
             fs_rel="ui/ui_textLevelUp.png",
         ),
         menu_item=loader.get(name="ui_menuItem", paq_rel="ui/ui_menuItem.jaz", fs_rel="ui/ui_menuItem.png"),
-        button_sm=loader.get(name="ui_buttonSm", paq_rel="ui/ui_button_82x32.jaz", fs_rel="ui/ui_button_82x32.png"),
+        button_sm=loader.get(name="ui_buttonSm", paq_rel="ui/ui_button_64x32.jaz", fs_rel="ui/ui_button_64x32.png"),
         button_md=loader.get(
             name="ui_buttonMd",
-            paq_rel="ui/ui_button_145x32.jaz",
-            fs_rel="ui/ui_button_145x32.png",
+            paq_rel="ui/ui_button_128x32.jaz",
+            fs_rel="ui/ui_button_128x32.png",
         ),
         cursor=loader.get(name="ui_cursor", paq_rel="ui/ui_cursor.jaz", fs_rel="ui/ui_cursor.png"),
         aim=loader.get(name="ui_aim", paq_rel="ui/ui_aim.jaz", fs_rel="ui/ui_aim.png"),
@@ -281,6 +305,17 @@ def draw_menu_item(
     return float(width)
 
 
+class UiButtonTextures(Protocol):
+    button_sm: rl.Texture | None
+    button_md: rl.Texture | None
+
+
+@dataclass(slots=True)
+class UiButtonTextureSet:
+    button_sm: rl.Texture | None
+    button_md: rl.Texture | None
+
+
 @dataclass(slots=True)
 class UiButtonState:
     label: str
@@ -343,7 +378,7 @@ def _clamp(value: float, lo: float, hi: float) -> float:
 
 
 def button_draw(
-    assets: PerkMenuAssets,
+    assets: UiButtonTextures,
     font: SmallFontData | None,
     state: UiButtonState,
     *,
@@ -357,23 +392,45 @@ def button_draw(
         return
 
     if state.hover_t > 0:
-        alpha = 0.5
+        # ui_button_update: highlight fill uses a hover-scaled alpha and click-biased blue tint.
+        # - base: (0.5, 0.5, 0.7)
+        # - click_anim: +0.0005 / +0.0007, clamped to 1.0 (towards white)
+        # - alpha: hover_anim * 0.001 * button.alpha
+        r = 0.5
+        g = 0.5
+        b = 0.7
         if state.press_t > 0:
-            alpha = min(1.0, 0.5 + (float(state.press_t) * 0.0005))
-        hl = rl.Color(255, 255, 255, int(255 * alpha * 0.25 * state.alpha))
-        rl.draw_rectangle(int(x + 12.0 * scale), int(y + 5.0 * scale), int(width - 24.0 * scale), int(22.0 * scale), hl)
-
-    tint_a = state.alpha if state.hovered else state.alpha * 0.7
-    tint = rl.Color(255, 255, 255, int(255 * _clamp(tint_a, 0.0, 1.0)))
+            click_t = float(state.press_t)
+            g = min(1.0, 0.5 + click_t * 0.0005)
+            r = g
+            b = min(1.0, 0.7 + click_t * 0.0007)
+        a = float(state.hover_t) * 0.001 * state.alpha
+        hl = rl.Color(
+            int(255 * r),
+            int(255 * g),
+            int(255 * b),
+            int(255 * _clamp(a, 0.0, 1.0)),
+        )
+        rl.draw_rectangle(
+            int(x + 12.0 * scale),
+            int(y + 5.0 * scale),
+            int(width - 24.0 * scale),
+            int(22.0 * scale),
+            hl,
+        )
+
+    plate_tint = rl.Color(255, 255, 255, int(255 * _clamp(state.alpha, 0.0, 1.0)))
 
     src = rl.Rectangle(0.0, 0.0, float(texture.width), float(texture.height))
     dst = rl.Rectangle(float(x), float(y), float(width), float(32.0 * scale))
-    rl.draw_texture_pro(texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, tint)
+    rl.draw_texture_pro(texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, plate_tint)
 
+    text_a = state.alpha if state.hovered else state.alpha * 0.7
+    text_tint = rl.Color(255, 255, 255, int(255 * _clamp(text_a, 0.0, 1.0)))
     text_w = _ui_text_width(font, state.label, scale)
     text_x = x + width * 0.5 - text_w * 0.5 + 1.0 * scale
     text_y = y + 10.0 * scale
-    draw_ui_text(font, state.label, text_x, text_y, scale=scale, color=tint)
+    draw_ui_text(font, state.label, text_x, text_y, scale=scale, color=text_tint)
 
 
 def cursor_draw(assets: PerkMenuAssets, *, mouse: rl.Vector2, scale: float, alpha: float = 1.0) -> None: