crimsonland 0.1.0.dev10__py3-none-any.whl → 0.1.0.dev12__py3-none-any.whl

crimson/gameplay.py

@@ -472,7 +472,7 @@ class BonusPool:
                         player,
                         BonusId(entry.bonus_id),
                         amount=entry.amount,
-                        origin=player,
+                        origin=entry,
                         creatures=creatures,
                         players=players,
                         apply_creature_damage=apply_creature_damage,
@@ -585,7 +585,7 @@ def _creature_find_in_radius(creatures: list[_CreatureForPerks], *, pos_x: float
             continue
 
         dist = math.hypot(float(creature.x) - pos_x, float(creature.y) - pos_y) - radius
-        threshold = float(creature.size) * 0.142857149 + 3.0
+        threshold = float(creature.size) * 0.14285715 + 3.0
         if threshold < dist:
             continue
         if float(creature.hitbox_size) < 5.0:
@@ -1511,9 +1511,9 @@ def player_start_reload(player: PlayerState, state: GameplayState) -> None:
         player.reload_active = True
 
     if perk_active(player, PerkId.FASTLOADER):
-        reload_time *= 0.69999999
+        reload_time *= 0.7
     if state.bonuses.weapon_power_up > 0.0:
-        reload_time *= 0.60000002
+        reload_time *= 0.6
 
     player.reload_timer = max(0.0, reload_time)
     player.reload_timer_max = player.reload_timer
@@ -1618,7 +1618,14 @@ def _perk_update_fire_cough(player: PlayerState, dt: float, state: GameplayState
     state.perk_intervals.fire_cough = float(state.rng.rand() % 4) + 2.0
 
 
-def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float, state: GameplayState) -> None:
+def player_fire_weapon(
+    player: PlayerState,
+    input_state: PlayerInput,
+    dt: float,
+    state: GameplayState,
+    *,
+    detail_preset: int = 5,
+) -> None:
     dt = float(dt)
 
     weapon_id = int(player.weapon_id)
@@ -1689,6 +1696,20 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
     aim_y = float(input_state.aim_y)
     dx = aim_x - float(player.pos_x)
     dy = aim_y - float(player.pos_y)
+    aim_heading = math.atan2(dy, dx) + math.pi / 2.0
+
+    muzzle_dir = (aim_heading - math.pi / 2.0) - 0.150915
+    muzzle_shell_x = player.pos_x + math.cos(muzzle_dir) * 16.0
+    muzzle_shell_y = player.pos_y + math.sin(muzzle_dir) * 16.0
+    state.effects.spawn_shell_casing(
+        pos_x=muzzle_shell_x,
+        pos_y=muzzle_shell_y,
+        aim_heading=aim_heading,
+        weapon_flags=int(weapon.flags or 0),
+        rand=state.rng.rand,
+        detail_preset=int(detail_preset),
+    )
+
     dist = math.hypot(dx, dy)
     max_offset = dist * float(player.spread_heat) * 0.5
     dir_angle = float(int(state.rng.rand()) & 0x1FF) * (math.tau / 512.0)
@@ -1885,7 +1906,15 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
         player_start_reload(player, state)
 
 
-def player_update(player: PlayerState, input_state: PlayerInput, dt: float, state: GameplayState, *, world_size: float = 1024.0) -> None:
+def player_update(
+    player: PlayerState,
+    input_state: PlayerInput,
+    dt: float,
+    state: GameplayState,
+    *,
+    detail_preset: int = 5,
+    world_size: float = 1024.0,
+) -> None:
     """Port of `player_update` (0x004136b0) for the rewrite runtime."""
 
     if dt <= 0.0:
@@ -2048,7 +2077,7 @@ def player_update(player: PlayerState, input_state: PlayerInput, dt: float, stat
         elif player.reload_timer == 0.0:
             player_start_reload(player, state)
 
-    player_fire_weapon(player, input_state, dt, state)
+    player_fire_weapon(player, input_state, dt, state, detail_preset=int(detail_preset))
 
     while player.move_phase > 14.0:
         player.move_phase -= 14.0
@@ -2458,7 +2487,7 @@ def bonus_telekinetic_update(
             player,
             BonusId(int(entry.bonus_id)),
             amount=int(entry.amount),
-            origin=player,
+            origin=entry,
             creatures=creatures,
             players=players,
             apply_creature_damage=apply_creature_damage,

crimson/modes/base_gameplay_mode.py

@@ -283,6 +283,9 @@ class BaseGameplayMode:
         self._action = None
         return action
 
+    def draw_pause_background(self) -> None:
+        self._world.draw(draw_aim_indicators=False)
+
     def _draw_screen_fade(self) -> None:
         fade_alpha = 0.0
         if self._screen_fade is not None:

crimson/modes/quest_mode.py

@@ -306,7 +306,8 @@ class QuestMode(BaseGameplayMode):
             self._paused = not self._paused
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
-            self.close_requested = True
+            self._action = "open_pause_menu"
+            return
 
     def _build_input(self):
         keybinds = config_keybinds(self._config)
@@ -517,6 +518,42 @@ class QuestMode(BaseGameplayMode):
                 self._world.audio_router.play_sfx("sfx_ui_bonus")
             self._close_perk_menu()
 
+    def _close_failed_run(self) -> None:
+        if self._outcome is None:
+            fired = 0
+            hit = 0
+            try:
+                fired = int(self._state.shots_fired[int(self._player.index)])
+                hit = int(self._state.shots_hit[int(self._player.index)])
+            except Exception:
+                fired = 0
+                hit = 0
+            fired = max(0, int(fired))
+            hit = max(0, min(int(hit), fired))
+            most_used_weapon_id = most_used_weapon_id_for_player(
+                self._state,
+                player_index=int(self._player.index),
+                fallback_weapon_id=int(self._player.weapon_id),
+            )
+            player2_health = None
+            if len(self._world.players) >= 2:
+                player2_health = float(self._world.players[1].health)
+            self._outcome = QuestRunOutcome(
+                kind="failed",
+                level=str(self._quest.level),
+                base_time_ms=int(self._quest.spawn_timeline_ms),
+                player_health=float(self._player.health),
+                player2_health=player2_health,
+                pending_perk_count=int(self._state.perk_selection.pending_count),
+                experience=int(self._player.experience),
+                kill_count=int(self._creatures.kill_count),
+                weapon_id=int(self._player.weapon_id),
+                shots_fired=fired,
+                shots_hit=hit,
+                most_used_weapon_id=int(most_used_weapon_id),
+            )
+        self.close_requested = True
+
     def _draw_perk_prompt(self) -> None:
         if self._perk_menu_open or self._perk_menu_timeline_ms > 1e-3:
             return
@@ -614,7 +651,8 @@ class QuestMode(BaseGameplayMode):
 
         panel_tex = self._perk_menu_assets.menu_panel
         if panel_tex is not None:
-            draw_menu_panel(panel_tex, dst=computed.panel)
+            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)
 
         title_tex = self._perk_menu_assets.title_pick_perk
         if title_tex is not None:
@@ -665,6 +703,8 @@ class QuestMode(BaseGameplayMode):
 
         dt_frame, dt_ui_ms = self._tick_frame(dt)
         self._handle_input()
+        if self._action == "open_pause_menu":
+            return
 
         if self.close_requested:
             return
@@ -719,6 +759,8 @@ class QuestMode(BaseGameplayMode):
 
         dt_world = 0.0 if self._paused or (not any_alive) or perk_menu_active else dt_frame
         if dt_world <= 0.0:
+            if not any(player.health > 0.0 for player in self._world.players):
+                self._close_failed_run()
             return
 
         self._quest.quest_name_timer_ms += dt_world * 1000.0
@@ -734,40 +776,7 @@ class QuestMode(BaseGameplayMode):
 
         any_alive_after = any(player.health > 0.0 for player in self._world.players)
         if not any_alive_after:
-            if self._outcome is None:
-                fired = 0
-                hit = 0
-                try:
-                    fired = int(self._state.shots_fired[int(self._player.index)])
-                    hit = int(self._state.shots_hit[int(self._player.index)])
-                except Exception:
-                    fired = 0
-                    hit = 0
-                fired = max(0, int(fired))
-                hit = max(0, min(int(hit), fired))
-                most_used_weapon_id = most_used_weapon_id_for_player(
-                    self._state,
-                    player_index=int(self._player.index),
-                    fallback_weapon_id=int(self._player.weapon_id),
-                )
-                player2_health = None
-                if len(self._world.players) >= 2:
-                    player2_health = float(self._world.players[1].health)
-                self._outcome = QuestRunOutcome(
-                    kind="failed",
-                    level=str(self._quest.level),
-                    base_time_ms=int(self._quest.spawn_timeline_ms),
-                    player_health=float(self._player.health),
-                    player2_health=player2_health,
-                    pending_perk_count=int(self._state.perk_selection.pending_count),
-                    experience=int(self._player.experience),
-                    kill_count=int(self._creatures.kill_count),
-                    weapon_id=int(self._player.weapon_id),
-                    shots_fired=fired,
-                    shots_hit=hit,
-                    most_used_weapon_id=int(most_used_weapon_id),
-                )
-            self.close_requested = True
+            self._close_failed_run()
             return
 
         creatures_none_active = not bool(self._creatures.iter_active())

crimson/modes/rush_mode.py

@@ -95,7 +95,8 @@ class RushMode(BaseGameplayMode):
             self._paused = not self._paused
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
-            self.close_requested = True
+            self._action = "open_pause_menu"
+            return
 
     def _build_input(self) -> PlayerInput:
         keybinds = config_keybinds(self._config)
@@ -174,6 +175,8 @@ class RushMode(BaseGameplayMode):
 
         dt_frame = self._tick_frame(dt)[0]
         self._handle_input()
+        if self._action == "open_pause_menu":
+            return
 
         if self._game_over_active:
             record = self._game_over_record

crimson/modes/survival_mode.py

@@ -186,7 +186,8 @@ class SurvivalMode(BaseGameplayMode):
             survival_check_level_up(self._player, self._state.perk_selection)
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
-            self.close_requested = True
+            self._action = "open_pause_menu"
+            return
 
     def _build_input(self) -> PlayerInput:
         keybinds = config_keybinds(self._config)
@@ -441,6 +442,8 @@ class SurvivalMode(BaseGameplayMode):
         dt_frame, dt_ui_ms = self._tick_frame(dt)
         self._cursor_time += dt_frame
         self._handle_input()
+        if self._action == "open_pause_menu":
+            return
 
         if self._game_over_active:
             record = self._game_over_record
@@ -668,7 +671,8 @@ class SurvivalMode(BaseGameplayMode):
 
         panel_tex = self._perk_menu_assets.menu_panel
         if panel_tex is not None:
-            draw_menu_panel(panel_tex, dst=computed.panel)
+            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)
 
         title_tex = self._perk_menu_assets.title_pick_perk
         if title_tex is not None:

crimson/modes/tutorial_mode.py

@@ -143,7 +143,8 @@ class TutorialMode(BaseGameplayMode):
             self._paused = not self._paused
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
-            self.close_requested = True
+            self._action = "open_pause_menu"
+            return
 
     def _build_input(self) -> PlayerInput:
         keybinds = config_keybinds(self._config)
@@ -346,6 +347,8 @@ class TutorialMode(BaseGameplayMode):
         dt_frame, dt_ui_ms = self._tick_frame(dt, clamp_cursor_pulse=True)
 
         self._handle_input()
+        if self._action == "open_pause_menu":
+            return
         if self.close_requested:
             return
 
@@ -605,7 +608,8 @@ class TutorialMode(BaseGameplayMode):
 
         panel_tex = assets.menu_panel
         if panel_tex is not None:
-            draw_menu_panel(panel_tex, dst=computed.panel)
+            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)
 
         title_tex = assets.title_pick_perk
         if title_tex is not None:

crimson/modes/typo_mode.py

@@ -120,7 +120,8 @@ class TypoShooterMode(BaseGameplayMode):
             self._paused = not self._paused
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
-            self.close_requested = True
+            self._action = "open_pause_menu"
+            return
 
     def _active_mask(self) -> list[bool]:
         return [bool(entry.active) for entry in self._creatures.entries]
@@ -257,6 +258,8 @@ class TypoShooterMode(BaseGameplayMode):
 
         dt_frame = self._tick_frame(dt)[0]
         self._handle_input()
+        if self._action == "open_pause_menu":
+            return
 
         if self._game_over_active:
             self._update_game_over_ui(dt)

crimson/persistence/highscores.py

@@ -239,7 +239,9 @@ def scores_path_for_mode(
         # Native `highscore_build_path` uses `questhc*.hi` when hardcore is OFF,
         # and `quest*.hi` when hardcore is ON.
         prefix = "quest" if hardcore else "questhc"
-        return root / f"{prefix}{int(quest_stage_major)}_{int(quest_stage_minor)}.hi"
+        major = int(quest_stage_major)
+        minor = int(quest_stage_minor)
+        return root / f"{prefix}{major}_{minor}.hi"
     return root / "unknown.hi"
 
 
@@ -272,7 +274,9 @@ def scores_path_for_config(base_dir: Path, config: CrimsonConfig, *, quest_stage
         # Native `highscore_build_path` uses `questhc*.hi` when hardcore is OFF,
         # and `quest*.hi` when hardcore is ON.
         prefix = "quest" if hardcore else "questhc"
-        return root / f"{prefix}{int(quest_stage_major)}_{int(quest_stage_minor)}.hi"
+        major = int(quest_stage_major)
+        minor = int(quest_stage_minor)
+        return root / f"{prefix}{major}_{minor}.hi"
     return root / "unknown.hi"
 
 

crimson/render/world_renderer.py

@@ -947,7 +947,7 @@ class WorldRenderer:
                         if float(getattr(creature, "hitbox_size", 0.0)) <= 5.0:
                             continue
                         d = math.hypot(float(creature.x) - pos_x, float(creature.y) - pos_y)
-                        threshold = float(creature.size) * 0.142857149 + 3.0
+                        threshold = float(creature.size) * 0.14285715 + 3.0
                         if d - radius < threshold:
                             targets.append(creature)
 

crimson/sim/world_state.py

@@ -290,7 +290,14 @@ class WorldState:
 
         for idx, player in enumerate(self.players):
             input_state = inputs[idx] if idx < len(inputs) else PlayerInput()
-            player_update(player, input_state, dt, self.state, world_size=float(world_size))
+            player_update(
+                player,
+                input_state,
+                dt,
+                self.state,
+                detail_preset=int(detail_preset),
+                world_size=float(world_size),
+            )
 
         if dt > 0.0:
             self._advance_creature_anim(dt)

crimson/typo/spawns.py

@@ -47,9 +47,9 @@ def tick_typo_spawns(
         y = math.cos(t) * 256.0 + float(world_height) * 0.5
 
         tint_t = float(elapsed_ms + 1)
-        tint_r = _clamp(tint_t * 0.0000083333334 + 0.30000001, 0.0, 1.0)
-        tint_g = _clamp(tint_t * 10000.0 + 0.30000001, 0.0, 1.0)
-        tint_b = _clamp(math.sin(tint_t * 0.0001) + 0.30000001, 0.0, 1.0)
+        tint_r = _clamp(tint_t * 0.0000083333334 + 0.3, 0.0, 1.0)
+        tint_g = _clamp(tint_t * 10000.0 + 0.3, 0.0, 1.0)
+        tint_b = _clamp(math.sin(tint_t * 0.0001) + 0.3, 0.0, 1.0)
         tint = (tint_r, tint_g, tint_b, 1.0)
 
         spawns.append(
@@ -70,4 +70,3 @@ def tick_typo_spawns(
         )
 
     return cooldown, spawns
-

crimson/ui/demo_trial_overlay.py

@@ -66,13 +66,14 @@ class DemoTrialOverlayUi:
 
         if self._assets is None:
             cursor = cache.get_or_load("ui_cursor", "ui/ui_cursor.jaz").texture
-            button_md = cache.get_or_load("ui_button_md", "ui/ui_button_145x32.jaz").texture
+            button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
+            button_md = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
             self._assets = PerkMenuAssets(
                 menu_panel=None,
                 title_pick_perk=None,
                 title_level_up=None,
                 menu_item=None,
-                button_sm=None,
+                button_sm=button_sm,
                 button_md=button_md,
                 cursor=cursor,
                 aim=None,
@@ -232,4 +233,3 @@ class DemoTrialOverlayUi:
                 scale=float(scale),
             )
             cursor_draw(assets, mouse=rl.get_mouse_position(), scale=1.0, alpha=1.0)
-

crimson/ui/game_over.py

@@ -31,6 +31,7 @@ from .perk_menu import (
     draw_ui_text,
     load_perk_menu_assets,
 )
+from .shadow import UI_SHADOW_OFFSET, draw_ui_quad_shadow
 
 
 UI_BASE_WIDTH = 640.0
@@ -568,9 +569,24 @@ class GameOverUi:
 
         # Panel background
         if self.assets.menu_panel is not None:
-            src = rl.Rectangle(0.0, 0.0, float(self.assets.menu_panel.width), float(self.assets.menu_panel.height))
+            panel_tex = self.assets.menu_panel
+            src = rl.Rectangle(0.0, 0.0, float(panel_tex.width), float(panel_tex.height))
             dst = rl.Rectangle(panel.x, panel.y, panel.width, panel.height)
-            rl.draw_texture_pro(self.assets.menu_panel, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+            fx_detail = bool(int(getattr(self.config, "data", {}).get("fx_detail_0", 0) or 0))
+            if fx_detail:
+                draw_ui_quad_shadow(
+                    texture=panel_tex,
+                    src=src,
+                    dst=rl.Rectangle(
+                        float(dst.x + UI_SHADOW_OFFSET),
+                        float(dst.y + UI_SHADOW_OFFSET),
+                        float(dst.width),
+                        float(dst.height),
+                    ),
+                    origin=rl.Vector2(0.0, 0.0),
+                    rotation_deg=0.0,
+                )
+            rl.draw_texture_pro(panel_tex, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
 
         # Banner (Reaper / Well done)
         banner = self.assets.text_reaper if banner_kind == "reaper" else self.assets.text_well_done

crimson/ui/perk_menu.py

@@ -2,12 +2,15 @@ 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 .shadow import UI_SHADOW_OFFSET, draw_ui_quad_shadow
+
 
 UI_BASE_WIDTH = 640.0
 UI_BASE_HEIGHT = 480.0
@@ -143,13 +146,32 @@ def perk_menu_compute_layout(
     )
 
 
-def draw_menu_panel(texture: rl.Texture, *, dst: rl.Rectangle, tint: rl.Color = rl.WHITE) -> None:
+def draw_menu_panel(
+    texture: rl.Texture,
+    *,
+    dst: rl.Rectangle,
+    tint: rl.Color = rl.WHITE,
+    shadow: bool = False,
+) -> 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))
+        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=rl.Vector2(0.0, 0.0),
+                rotation_deg=0.0,
+            )
         rl.draw_texture_pro(texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, tint)
         return
 
@@ -165,6 +187,43 @@ def draw_menu_panel(texture: rl.Texture, *, dst: rl.Rectangle, tint: rl.Color =
     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)
+    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)
@@ -198,11 +257,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 +340,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 +413,7 @@ def _clamp(value: float, lo: float, hi: float) -> float:
 
 
 def button_draw(
-    assets: PerkMenuAssets,
+    assets: UiButtonTextures,
     font: SmallFontData | None,
     state: UiButtonState,
     *,
@@ -357,23 +427,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: