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

crimson/ui/hud.py

@@ -8,6 +8,7 @@ import pyray as rl
 
 from grim.assets import TextureLoader
 from grim.fonts.small import SmallFontData, draw_small_text
+from ..game_modes import GameMode
 from ..gameplay import BonusHudState, PlayerState, survival_level_threshold
 from ..weapons import WEAPON_BY_ID
 
@@ -53,6 +54,7 @@ HUD_BONUS_TEXT_OFFSET = (36.0, 6.0)
 HUD_BONUS_SPACING = 52.0
 HUD_BONUS_PANEL_OFFSET_Y = -11.0
 HUD_XP_BAR_RGBA = (0.1, 0.3, 0.6, 1.0)
+HUD_QUEST_LEFT_Y_SHIFT = 80.0
 
 _SURVIVAL_XP_SMOOTHED = 0
 
@@ -74,6 +76,60 @@ class HudAssets:
     missing: list[str] = field(default_factory=list)
 
 
+@dataclass(frozen=True, slots=True)
+class HudRenderFlags:
+    show_health: bool
+    show_weapon: bool
+    show_xp: bool
+    show_time: bool
+    show_quest_hud: bool
+
+
+def hud_flags_for_game_mode(game_mode_id: int) -> HudRenderFlags:
+    """Match `hud_update_and_render` (0x0041ca90) flag mapping."""
+
+    mode = int(game_mode_id)
+    if mode == int(GameMode.QUESTS):
+        return HudRenderFlags(
+            show_health=True,
+            show_weapon=True,
+            show_xp=True,
+            show_time=False,
+            show_quest_hud=True,
+        )
+    if mode == int(GameMode.SURVIVAL):
+        return HudRenderFlags(
+            show_health=True,
+            show_weapon=True,
+            show_xp=True,
+            show_time=False,
+            show_quest_hud=False,
+        )
+    if mode == int(GameMode.RUSH):
+        return HudRenderFlags(
+            show_health=True,
+            show_weapon=False,
+            show_xp=False,
+            show_time=True,
+            show_quest_hud=False,
+        )
+    if mode == int(GameMode.TYPO):
+        return HudRenderFlags(
+            show_health=True,
+            show_weapon=False,
+            show_xp=True,
+            show_time=True,
+            show_quest_hud=False,
+        )
+    return HudRenderFlags(
+        show_health=False,
+        show_weapon=False,
+        show_xp=False,
+        show_time=False,
+        show_quest_hud=False,
+    )
+
+
 def hud_ui_scale(screen_w: float, screen_h: float) -> float:
     scale = min(screen_w / HUD_BASE_WIDTH, screen_h / HUD_BASE_HEIGHT)
     if scale < 0.75:
@@ -171,6 +227,18 @@ def _draw_progress_bar(x: float, y: float, width: float, ratio: float, rgba: tup
     rl.draw_rectangle(int(x + scale), int(y + scale), int(inner_w), int(inner_h), fg_color)
 
 
+def draw_target_health_bar(*, x: float, y: float, width: float, ratio: float, alpha: float = 1.0, scale: float = 1.0) -> None:
+    ratio = max(0.0, min(1.0, float(ratio)))
+    alpha = max(0.0, min(1.0, float(alpha)))
+    scale = max(0.1, float(scale))
+
+    # Matches `hud_update_and_render` (0x0041ca90): color shifts from red->green as ratio increases.
+    r = (1.0 - ratio) * 0.9 + 0.1
+    g = ratio * 0.9 + 0.1
+    rgba = (r, g, 0.7, 0.2 * alpha)
+    _draw_progress_bar(float(x), float(y), float(width), ratio, rgba, scale)
+
+
 def _weapon_icon_index(weapon_id: int) -> int | None:
     entry = WEAPON_BY_ID.get(int(weapon_id))
     icon_index = entry.icon_index if entry is not None else None
@@ -215,9 +283,13 @@ def draw_hud_overlay(
     font: SmallFontData | None = None,
     alpha: float = 1.0,
     frame_dt_ms: float | None = None,
+    show_health: bool = True,
     show_weapon: bool = True,
     show_xp: bool = True,
     show_time: bool = False,
+    show_quest_hud: bool = False,
+    quest_progress_ratio: float | None = None,
+    small_indicators: bool = False,
 ) -> float:
     if frame_dt_ms is None:
         frame_dt_ms = max(0.0, float(rl.get_frame_time()) * 1000.0)
@@ -241,8 +313,8 @@ def draw_hud_overlay(
     max_y = 0.0
     alpha = max(0.0, min(1.0, float(alpha)))
     text_color = _with_alpha(HUD_TEXT_COLOR, alpha)
-    accent_color = _with_alpha(HUD_ACCENT_COLOR, alpha)
     panel_text_color = _with_alpha(HUD_TEXT_COLOR, alpha * HUD_PANEL_ALPHA)
+    hud_y_shift = HUD_QUEST_LEFT_Y_SHIFT if show_quest_hud else 0.0
 
     # Top bar background.
     if assets.game_top is not None:
@@ -265,7 +337,7 @@ def draw_hud_overlay(
         max_y = max(max_y, dst.y + dst.height)
 
     # Pulsing heart.
-    if assets.life_heart is not None:
+    if show_health and assets.life_heart is not None:
         t = max(0.0, elapsed_ms) / 1000.0
         src = rl.Rectangle(0.0, 0.0, float(assets.life_heart.width), float(assets.life_heart.height))
         if player_count == 1:
@@ -301,7 +373,7 @@ def draw_hud_overlay(
             max_y = max(max_y, dst.y + dst.height)
 
     # Health bar.
-    if assets.ind_life is not None:
+    if show_health and assets.ind_life is not None:
         bar_x, bar_y = HUD_HEALTH_BAR_POS
         bar_w, bar_h = HUD_HEALTH_BAR_SIZE
         bg_src = rl.Rectangle(0.0, 0.0, float(assets.ind_life.width), float(assets.ind_life.height))
@@ -427,11 +499,91 @@ def draw_hud_overlay(
                 text_y = base_y + HUD_AMMO_TEXT_OFFSET[1]
                 _draw_text(font, f"+ {extra}", sx(text_x), sy(text_y), text_scale, text_color)
 
+    # Quest HUD panels (mm:ss timer + progress).
+    if show_quest_hud:
+        time_ms = max(0.0, float(elapsed_ms))
+        slide_x = 0.0
+        if time_ms < 1000.0:
+            slide_x = (1000.0 - time_ms) * -0.128
+
+        quest_panel_alpha = alpha * 0.7
+        quest_text_color = _with_alpha(HUD_TEXT_COLOR, quest_panel_alpha)
+
+        if assets.ind_panel is not None:
+            src = rl.Rectangle(0.0, 0.0, float(assets.ind_panel.width), float(assets.ind_panel.height))
+
+            # Sliding top panel (first second).
+            dst = rl.Rectangle(sx(slide_x - 90.0), sy(67.0), sx(182.0), sy(53.0))
+            rl.draw_texture_pro(
+                assets.ind_panel,
+                src,
+                dst,
+                rl.Vector2(0.0, 0.0),
+                0.0,
+                rl.Color(255, 255, 255, int(255 * quest_panel_alpha)),
+            )
+            max_y = max(max_y, dst.y + dst.height)
+
+            # Static progress panel.
+            dst = rl.Rectangle(sx(-80.0), sy(107.0), sx(182.0), sy(53.0))
+            rl.draw_texture_pro(
+                assets.ind_panel,
+                src,
+                dst,
+                rl.Vector2(0.0, 0.0),
+                0.0,
+                rl.Color(255, 255, 255, int(255 * quest_panel_alpha)),
+            )
+            max_y = max(max_y, dst.y + dst.height)
+
+        # Clock table + pointer inside the sliding panel.
+        clock_alpha = alpha * HUD_CLOCK_ALPHA
+        if assets.clock_table is not None:
+            dst = rl.Rectangle(sx(slide_x + 2.0), sy(78.0), sx(32.0), sy(32.0))
+            src = rl.Rectangle(0.0, 0.0, float(assets.clock_table.width), float(assets.clock_table.height))
+            rl.draw_texture_pro(
+                assets.clock_table,
+                src,
+                dst,
+                rl.Vector2(0.0, 0.0),
+                0.0,
+                rl.Color(255, 255, 255, int(255 * clock_alpha)),
+            )
+
+        if assets.clock_pointer is not None:
+            # NOTE: Raylib's draw_texture_pro uses dst.x/y as the rotation origin position;
+            # offset by half-size so the 32x32 quad stays aligned with the table.
+            dst = rl.Rectangle(sx(slide_x + 2.0 + 16.0), sy(78.0 + 16.0), sx(32.0), sy(32.0))
+            src = rl.Rectangle(0.0, 0.0, float(assets.clock_pointer.width), float(assets.clock_pointer.height))
+            rotation = time_ms / 1000.0 * 6.0
+            origin = rl.Vector2(sx(16.0), sy(16.0))
+            rl.draw_texture_pro(
+                assets.clock_pointer,
+                src,
+                dst,
+                origin,
+                rotation,
+                rl.Color(255, 255, 255, int(255 * clock_alpha)),
+            )
+
+        total_seconds = max(0, int(time_ms) // 1000)
+        minutes = total_seconds // 60
+        seconds = total_seconds % 60
+        _draw_text(font, f"{minutes}:{seconds:02d}", sx(slide_x + 32.0), sy(86.0), text_scale, quest_text_color)
+
+        _draw_text(font, "Progress", sx(18.0), sy(122.0), text_scale, quest_text_color)
+
+        if quest_progress_ratio is not None:
+            ratio = max(0.0, min(1.0, float(quest_progress_ratio)))
+            quest_bar_rgba = (0.2, 0.8, 0.3, alpha * 0.8)
+            _draw_progress_bar(sx(10.0), sy(139.0), sx(70.0), ratio, quest_bar_rgba, scale)
+
     # Survival XP panel.
     xp_target = int(player.experience if score is None else score)
     xp_display = _smooth_xp(xp_target, frame_dt_ms) if show_xp else xp_target
     if show_xp and assets.ind_panel is not None:
         panel_x, panel_y = HUD_SURV_PANEL_POS
+        panel_y += hud_y_shift
         panel_w, panel_h = HUD_SURV_PANEL_SIZE
         dst = rl.Rectangle(sx(panel_x), sy(panel_y), sx(panel_w), sy(panel_h))
         src = rl.Rectangle(0.0, 0.0, float(assets.ind_panel.width), float(assets.ind_panel.height))
@@ -450,7 +602,7 @@ def draw_hud_overlay(
             font,
             "Xp",
             sx(HUD_SURV_XP_LABEL_POS[0]),
-            sy(HUD_SURV_XP_LABEL_POS[1]),
+            sy(HUD_SURV_XP_LABEL_POS[1] + hud_y_shift),
             text_scale,
             panel_text_color,
         )
@@ -458,7 +610,7 @@ def draw_hud_overlay(
             font,
             f"{xp_display}",
             sx(HUD_SURV_XP_VALUE_POS[0]),
-            sy(HUD_SURV_XP_VALUE_POS[1]),
+            sy(HUD_SURV_XP_VALUE_POS[1] + hud_y_shift),
             text_scale,
             panel_text_color,
         )
@@ -466,7 +618,7 @@ def draw_hud_overlay(
             font,
             f"{int(player.level)}",
             sx(HUD_SURV_LVL_VALUE_POS[0]),
-            sy(HUD_SURV_LVL_VALUE_POS[1]),
+            sy(HUD_SURV_LVL_VALUE_POS[1] + hud_y_shift),
             text_scale,
             panel_text_color,
         )
@@ -478,6 +630,7 @@ def draw_hud_overlay(
         if next_threshold > prev_threshold:
             progress_ratio = (xp_target - prev_threshold) / float(next_threshold - prev_threshold)
         bar_x, bar_y = HUD_SURV_PROGRESS_POS
+        bar_y += hud_y_shift
         bar_w = HUD_SURV_PROGRESS_WIDTH
         bar_rgba = (HUD_XP_BAR_RGBA[0], HUD_XP_BAR_RGBA[1], HUD_XP_BAR_RGBA[2], HUD_XP_BAR_RGBA[3] * alpha)
         _draw_progress_bar(sx(bar_x), sy(bar_y), sx(bar_w), progress_ratio, bar_rgba, scale)
@@ -528,35 +681,61 @@ def draw_hud_overlay(
         _draw_text(font, time_text, sx(255.0), sy(10.0), text_scale, text_color)
         max_y = max(max_y, sy(10.0 + line_h))
 
-    # Bonus HUD slots (text + icons), anchored below the survival panel.
-    slots = [slot for slot in bonus_hud.slots if slot.active] if bonus_hud is not None else []
-    if slots:
-        bonus_x = sx(4.0)
-        bonus_y = sy(HUD_BONUS_BASE_Y)
-        for slot in slots[:16]:
+    # Bonus HUD slots (icon + timers), slide in/out from the left.
+    bonus_bottom_y = float(HUD_BONUS_BASE_Y + hud_y_shift)
+    if bonus_hud is not None:
+        bonus_y = float(HUD_BONUS_BASE_Y + hud_y_shift)
+        bonus_panel_alpha = alpha * 0.7
+        bonus_text_color = _with_alpha(HUD_TEXT_COLOR, bonus_panel_alpha)
+        bar_rgba = (HUD_XP_BAR_RGBA[0], HUD_XP_BAR_RGBA[1], HUD_XP_BAR_RGBA[2], bonus_panel_alpha)
+
+        slots = bonus_hud.slots[:16]
+        for slot in slots:
+            if not slot.active:
+                continue
+
+            if slot.slide_x < -184.0:
+                bonus_y += HUD_BONUS_SPACING
+                continue
+
+            has_alt = slot.timer_ref_alt is not None and player_count > 1
+            timer = float(slot.timer_value)
+            timer_alt = float(slot.timer_value_alt) if has_alt else 0.0
+
+            # Slot panel.
             if assets.ind_panel is not None:
-                panel_x, panel_y = HUD_SURV_PANEL_POS
-                dst = rl.Rectangle(
-                    sx(panel_x),
-                    bonus_y + sy(HUD_BONUS_PANEL_OFFSET_Y),
-                    sx(HUD_SURV_PANEL_SIZE[0]),
-                    sy(HUD_SURV_PANEL_SIZE[1]),
-                )
+                if not small_indicators:
+                    panel_x = slot.slide_x
+                    panel_y = bonus_y + HUD_BONUS_PANEL_OFFSET_Y
+                    panel_w = 182.0
+                    panel_h = 53.0
+                else:
+                    panel_x = (slot.slide_x - 100.0) + 4.0
+                    panel_y = bonus_y + 5.0
+                    panel_w = 182.0
+                    panel_h = 26.5
+
                 src = rl.Rectangle(0.0, 0.0, float(assets.ind_panel.width), float(assets.ind_panel.height))
+                dst = rl.Rectangle(sx(panel_x), sy(panel_y), sx(panel_w), sy(panel_h))
                 rl.draw_texture_pro(
                     assets.ind_panel,
                     src,
                     dst,
                     rl.Vector2(0.0, 0.0),
                     0.0,
-                    rl.Color(255, 255, 255, int(255 * alpha * HUD_TOP_BAR_ALPHA)),
+                    rl.Color(255, 255, 255, int(255 * bonus_panel_alpha)),
                 )
                 max_y = max(max_y, dst.y + dst.height)
 
-            icon_drawn = False
+            # Slot icon.
             if assets.bonuses is not None and slot.icon_id >= 0:
                 src = _bonus_icon_src(assets.bonuses, slot.icon_id)
-                dst = rl.Rectangle(bonus_x, bonus_y, sx(HUD_BONUS_ICON_SIZE), sy(HUD_BONUS_ICON_SIZE))
+                dst = rl.Rectangle(
+                    sx(slot.slide_x - 1.0),
+                    sy(bonus_y),
+                    sx(HUD_BONUS_ICON_SIZE),
+                    sy(HUD_BONUS_ICON_SIZE),
+                )
                 rl.draw_texture_pro(
                     assets.bonuses,
                     src,
@@ -565,37 +744,81 @@ def draw_hud_overlay(
                     0.0,
                     rl.Color(255, 255, 255, int(255 * alpha)),
                 )
-                label_x = bonus_x + sx(HUD_BONUS_TEXT_OFFSET[0])
-                icon_drawn = True
                 max_y = max(max_y, dst.y + dst.height)
+
+            # Slot timer bars.
+            if not small_indicators:
+                if not has_alt:
+                    _draw_progress_bar(sx(slot.slide_x + 36.0), sy(bonus_y + 21.0), sx(100.0), timer * 0.05, bar_rgba, scale)
+                    _draw_text(font, slot.label, sx(slot.slide_x + 36.0), sy(bonus_y + 6.0), text_scale, bonus_text_color)
+                else:
+                    _draw_progress_bar(sx(slot.slide_x + 36.0), sy(bonus_y + 17.0), sx(100.0), timer * 0.05, bar_rgba, scale)
+                    _draw_progress_bar(sx(slot.slide_x + 36.0), sy(bonus_y + 23.0), sx(100.0), timer_alt * 0.05, bar_rgba, scale)
+                    _draw_text(font, slot.label, sx(slot.slide_x + 36.0), sy(bonus_y + 2.0), text_scale, bonus_text_color)
             else:
-                label_x = bonus_x
-
-            if not icon_drawn and assets.wicons is not None:
-                alt_icon_index = _weapon_icon_index(player.weapon_id)
-                if alt_icon_index is not None:
-                    src = _weapon_icon_src(assets.wicons, alt_icon_index)
-                    dst = rl.Rectangle(bonus_x, bonus_y, sx(HUD_BONUS_ICON_SIZE), sy(HUD_BONUS_ICON_SIZE))
-                    rl.draw_texture_pro(
-                        assets.wicons,
-                        src,
-                        dst,
-                        rl.Vector2(0.0, 0.0),
-                        0.0,
-                        rl.Color(255, 255, 255, int(255 * alpha)),
-                    )
-                    label_x = bonus_x + sx(HUD_BONUS_TEXT_OFFSET[0])
-                    max_y = max(max_y, dst.y + dst.height)
-
-            _draw_text(
-                font,
-                slot.label,
-                label_x,
-                bonus_y + sy(HUD_BONUS_TEXT_OFFSET[1]),
-                text_scale,
-                accent_color,
+                if not has_alt:
+                    _draw_progress_bar(sx(slot.slide_x + 36.0), sy(bonus_y + 17.0), sx(32.0), timer * 0.05, bar_rgba, scale)
+                else:
+                    _draw_progress_bar(sx(slot.slide_x + 36.0), sy(bonus_y + 13.0), sx(32.0), timer * 0.05, bar_rgba, scale)
+                    _draw_progress_bar(sx(slot.slide_x + 36.0), sy(bonus_y + 19.0), sx(32.0), timer_alt * 0.05, bar_rgba, scale)
+
+            bonus_y += HUD_BONUS_SPACING
+            max_y = max(max_y, sy(bonus_y))
+        bonus_bottom_y = bonus_y
+
+    # Weapon aux timer overlay (weapon name popup).
+    if assets.ind_panel is not None and assets.wicons is not None:
+        aux_base_y = float(bonus_bottom_y)
+        aux_step_y = 32.0
+        for idx, hud_player in enumerate(hud_players):
+            aux_timer = float(hud_player.aux_timer)
+            if aux_timer <= 0.0:
+                continue
+
+            fade = 2.0 - aux_timer if aux_timer > 1.0 else aux_timer
+            fade = max(0.0, min(1.0, fade)) * alpha
+            if fade <= 1e-3:
+                continue
+
+            panel_alpha = fade * 0.8
+            text_alpha = fade
+
+            panel_x = -12.0
+            panel_y = (aux_base_y - 17.0) + float(idx) * aux_step_y
+            panel_w = 182.0
+            panel_h = 53.0
+
+            src = rl.Rectangle(0.0, 0.0, float(assets.ind_panel.width), float(assets.ind_panel.height))
+            dst = rl.Rectangle(sx(panel_x), sy(panel_y), sx(panel_w), sy(panel_h))
+            rl.draw_texture_pro(
+                assets.ind_panel,
+                src,
+                dst,
+                rl.Vector2(0.0, 0.0),
+                0.0,
+                rl.Color(255, 255, 255, int(255 * panel_alpha)),
             )
-            bonus_y += sy(HUD_BONUS_SPACING)
-            max_y = max(max_y, bonus_y)
+            max_y = max(max_y, dst.y + dst.height)
+
+            icon_index = _weapon_icon_index(hud_player.weapon_id)
+            if icon_index is not None:
+                src = _weapon_icon_src(assets.wicons, icon_index)
+                icon_x = 105.0
+                icon_y = (aux_base_y - 5.0) + float(idx) * aux_step_y
+                dst = rl.Rectangle(sx(icon_x), sy(icon_y), sx(60.0), sy(30.0))
+                rl.draw_texture_pro(
+                    assets.wicons,
+                    src,
+                    dst,
+                    rl.Vector2(0.0, 0.0),
+                    0.0,
+                    rl.Color(255, 255, 255, int(255 * panel_alpha)),
+                )
+                max_y = max(max_y, dst.y + dst.height)
+
+            weapon_entry = WEAPON_BY_ID.get(int(hud_player.weapon_id))
+            weapon_name = weapon_entry.name if weapon_entry is not None else f"weapon_{int(hud_player.weapon_id)}"
+            weapon_color = _with_alpha(HUD_TEXT_COLOR, text_alpha)
+            _draw_text(font, weapon_name, sx(8.0), sy((aux_base_y + 1.0) + float(idx) * aux_step_y), text_scale, weapon_color)
 
     return max_y

crimson/views/arsenal_debug.py

@@ -6,9 +6,11 @@ import random
 import pyray as rl
 
 from grim.audio import AudioState, shutdown_audio, update_audio
+from grim.console import ConsoleState
 from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
 from grim.view import View, ViewContext
 
+from ..bonuses import BONUS_TABLE, BonusId
 from ..creatures.spawn import SpawnId
 from ..game_modes import GameMode
 from ..game_world import GameWorld
@@ -36,6 +38,7 @@ UI_ERROR = rl.Color(240, 80, 80, 255)
 
 ARSENAL_PLAYER_MOVE_SPEED_MULTIPLIER = 6.0
 ARSENAL_PLAYER_INVULNERABLE_SHIELD_TIMER = 1e-3
+ARSENAL_BONUS_RING_RADIUS = 140.0
 
 DEFAULT_SPAWN_IDS = (
     SpawnId.ZOMBIE_CONST_GREY_42,
@@ -192,6 +195,45 @@ class ArsenalDebugView:
                 rand=self._world.state.rng.rand,
             )
 
+    def _spawn_all_bonuses(self) -> None:
+        player = self._player
+        if player is None:
+            return
+
+        bonus_pool = self._world.state.bonus_pool
+        bonus_pool.reset()
+
+        bonus_ids = [int(entry.bonus_id) for entry in BONUS_TABLE if int(entry.bonus_id) != int(BonusId.UNUSED)]
+        count = max(1, len(bonus_ids))
+
+        base_x = float(player.pos_x)
+        base_y = float(player.pos_y)
+        rng = self._world.state.rng.rand
+        current_weapon_id = int(player.weapon_id)
+
+        for idx, bonus_id in enumerate(bonus_ids):
+            angle = float(idx) / float(count) * math.tau
+            x = base_x + math.cos(angle) * float(ARSENAL_BONUS_RING_RADIUS)
+            y = base_y + math.sin(angle) * float(ARSENAL_BONUS_RING_RADIUS)
+
+            amount_override = -1
+            if bonus_id == int(BonusId.WEAPON) and self._weapon_ids:
+                weapon_id = int(current_weapon_id)
+                for _ in range(8):
+                    weapon_id = int(self._weapon_ids[int(rng()) % len(self._weapon_ids)])
+                    if weapon_id != current_weapon_id:
+                        break
+                amount_override = int(weapon_id)
+
+            bonus_pool.spawn_at(
+                x,
+                y,
+                bonus_id,
+                duration_override=int(amount_override),
+                world_width=float(WORLD_SIZE),
+                world_height=float(WORLD_SIZE),
+            )
+
     def _handle_debug_input(self) -> None:
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
             self.close_requested = True
@@ -209,6 +251,9 @@ class ArsenalDebugView:
         if rl.is_key_pressed(rl.KeyboardKey.KEY_T):
             self._reset_creatures()
 
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_B):
+            self._spawn_all_bonuses()
+
         if rl.is_key_pressed(rl.KeyboardKey.KEY_BACKSPACE):
             self._reset_scene()
 
@@ -387,7 +432,7 @@ class ArsenalDebugView:
 
         y += 6.0
         self._draw_ui_text(
-            "WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  T respawn  Backspace reset  Esc quit",
+            "WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  T respawn  B spawn all bonuses  Backspace reset  Esc quit",
             x,
             y,
             UI_HINT,

crimson/views/player.py

@@ -206,7 +206,7 @@ class PlayerSandboxView:
             self._player.shield_timer = 0.0
             self._player.speed_bonus_timer = 0.0
             self._player.fire_bullets_timer = 0.0
-            bonus_hud_update(self._state, [self._player])
+            bonus_hud_update(self._state, [self._player], dt=0.0)
 
     def _camera_world_to_screen(self, x: float, y: float) -> tuple[float, float]:
         return self._camera_x + x, self._camera_y + y
@@ -308,7 +308,7 @@ class PlayerSandboxView:
         input_state = self._build_input()
         player_update(self._player, input_state, dt, self._state, world_size=WORLD_SIZE)
 
-        bonus_hud_update(self._state, [self._player])
+        bonus_hud_update(self._state, [self._player], dt=dt)
         self._update_camera(dt)
 
     def draw(self) -> None:

{crimsonland-0.1.0.dev5.dist-info → crimsonland-0.1.0.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: crimsonland
-Version: 0.1.0.dev5
+Version: 0.1.0.dev11
 Requires-Dist: construct>=2.10.70
 Requires-Dist: pillow>=12.1.0
 Requires-Dist: platformdirs>=4.5.1