crimsonland 0.1.0.dev14__py3-none-any.whl → 0.1.0.dev16__py3-none-any.whl

crimson/views/lighting_debug.py

@@ -10,13 +10,15 @@ from dataclasses import dataclass
 import pyray as rl
 
 from grim.config import ensure_crimson_cfg
-from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.fonts.small import SmallFontData, load_small_font
+from grim.math import clamp
 from grim.view import ViewContext
 
 from ..creatures.spawn import CreatureInit, CreatureTypeId
 from ..game_world import GameWorld
 from ..gameplay import PlayerInput
 from ..paths import default_runtime_dir
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 WORLD_SIZE = 1024.0
@@ -200,14 +202,6 @@ void main()
 """
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 @dataclass
 class _EmissiveProjectile:
     x: float
@@ -308,9 +302,9 @@ class LightingDebugView:
         base = self._ambient_base
         m = max(0.0, float(self._ambient_mul))
         self._ambient = rl.Color(
-            int(_clamp(float(base.r) * m, 0.0, 255.0)),
-            int(_clamp(float(base.g) * m, 0.0, 255.0)),
-            int(_clamp(float(base.b) * m, 0.0, 255.0)),
+            int(clamp(float(base.r) * m, 0.0, 255.0)),
+            int(clamp(float(base.g) * m, 0.0, 255.0)),
+            int(clamp(float(base.b) * m, 0.0, 255.0)),
             255,
         )
 
@@ -336,8 +330,8 @@ class LightingDebugView:
             c = palette[i % len(palette)]
             if rng.random() < 0.5:
                 c = palette[int(rng.random() * len(palette)) % len(palette)]
-            x = _clamp(px + math.cos(angle) * radius, 0.0, WORLD_SIZE)
-            y = _clamp(py + math.sin(angle) * radius, 0.0, WORLD_SIZE)
+            x = clamp(px + math.cos(angle) * radius, 0.0, WORLD_SIZE)
+            y = clamp(py + math.sin(angle) * radius, 0.0, WORLD_SIZE)
             r = float(self._fly_light_range) * (0.8 + rng.random() * 0.5)
             sr = float(self._fly_light_source_radius) * (0.7 + rng.random() * 0.7)
             self._fly_lights.append(
@@ -353,25 +347,14 @@ class LightingDebugView:
                 )
             )
 
-    def _ui_line_height(self, scale: float = UI_TEXT_SCALE) -> int:
-        if self._small is not None:
-            return int(self._small.cell_size * scale)
-        return int(20 * scale)
-
-    def _draw_ui_text(self, text: str, x: float, y: float, color: rl.Color, scale: float = UI_TEXT_SCALE) -> None:
-        if self._small is not None:
-            draw_small_text(self._small, text, x, y, scale, color)
-        else:
-            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
-
     def _update_ui_mouse(self) -> None:
         if self._debug_auto_dump:
             return
         mouse = rl.get_mouse_position()
         screen_w = float(rl.get_screen_width())
         screen_h = float(rl.get_screen_height())
-        self._ui_mouse_x = _clamp(float(mouse.x), 0.0, max(0.0, screen_w - 1.0))
-        self._ui_mouse_y = _clamp(float(mouse.y), 0.0, max(0.0, screen_h - 1.0))
+        self._ui_mouse_x = clamp(float(mouse.x), 0.0, max(0.0, screen_w - 1.0))
+        self._ui_mouse_y = clamp(float(mouse.y), 0.0, max(0.0, screen_h - 1.0))
 
     def _handle_debug_input(self) -> None:
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
@@ -401,18 +384,18 @@ class LightingDebugView:
         occ_mul_step = 0.05 if not shift else 0.10
         occ_pad_step = 1.0 if not shift else 4.0
         if rl.is_key_pressed(rl.KeyboardKey.KEY_O):
-            self._occluder_radius_mul = _clamp(self._occluder_radius_mul - occ_mul_step, 0.25, 2.50)
+            self._occluder_radius_mul = clamp(self._occluder_radius_mul - occ_mul_step, 0.25, 2.50)
         if rl.is_key_pressed(rl.KeyboardKey.KEY_P):
-            self._occluder_radius_mul = _clamp(self._occluder_radius_mul + occ_mul_step, 0.25, 2.50)
+            self._occluder_radius_mul = clamp(self._occluder_radius_mul + occ_mul_step, 0.25, 2.50)
         if rl.is_key_pressed(rl.KeyboardKey.KEY_K):
-            self._occluder_radius_pad_px = _clamp(self._occluder_radius_pad_px - occ_pad_step, -20.0, 60.0)
+            self._occluder_radius_pad_px = clamp(self._occluder_radius_pad_px - occ_pad_step, -20.0, 60.0)
         if rl.is_key_pressed(rl.KeyboardKey.KEY_L):
-            self._occluder_radius_pad_px = _clamp(self._occluder_radius_pad_px + occ_pad_step, -20.0, 60.0)
+            self._occluder_radius_pad_px = clamp(self._occluder_radius_pad_px + occ_pad_step, -20.0, 60.0)
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_MINUS) or rl.is_key_pressed(rl.KeyboardKey.KEY_KP_SUBTRACT):
-            self._sdf_shadow_floor = _clamp(self._sdf_shadow_floor - 0.05, 0.0, 0.9)
+            self._sdf_shadow_floor = clamp(self._sdf_shadow_floor - 0.05, 0.0, 0.9)
         if rl.is_key_pressed(rl.KeyboardKey.KEY_EQUAL) or rl.is_key_pressed(rl.KeyboardKey.KEY_KP_ADD):
-            self._sdf_shadow_floor = _clamp(self._sdf_shadow_floor + 0.05, 0.0, 0.9)
+            self._sdf_shadow_floor = clamp(self._sdf_shadow_floor + 0.05, 0.0, 0.9)
 
         if rl.is_key_pressed(rl.KeyboardKey.KEY_LEFT_BRACKET):
             if shift:
@@ -435,10 +418,10 @@ class LightingDebugView:
 
         amb_step = 0.10 if not shift else 0.25
         if rl.is_key_pressed(rl.KeyboardKey.KEY_N):
-            self._ambient_mul = _clamp(self._ambient_mul - amb_step, 0.0, 8.0)
+            self._ambient_mul = clamp(self._ambient_mul - amb_step, 0.0, 8.0)
             self._update_ambient()
         if rl.is_key_pressed(rl.KeyboardKey.KEY_M):
-            self._ambient_mul = _clamp(self._ambient_mul + amb_step, 0.0, 8.0)
+            self._ambient_mul = clamp(self._ambient_mul + amb_step, 0.0, 8.0)
             self._update_ambient()
 
     def _ensure_sdf_shader(self) -> rl.Shader | None:
@@ -534,8 +517,8 @@ class LightingDebugView:
             radius = 120.0 + rng.random() * 260.0
             x = center_x + math.cos(angle) * radius
             y = center_y + math.sin(angle) * radius
-            x = _clamp(x, 40.0, WORLD_SIZE - 40.0)
-            y = _clamp(y, 40.0, WORLD_SIZE - 40.0)
+            x = clamp(x, 40.0, WORLD_SIZE - 40.0)
+            y = clamp(y, 40.0, WORLD_SIZE - 40.0)
             init = CreatureInit(
                 origin_template_id=0,
                 pos_x=float(x),
@@ -656,8 +639,8 @@ class LightingDebugView:
                     fl.angle += fl.omega * dt_world
                     wobble = 1.0 + 0.10 * math.sin(fl.angle * 0.7)
                     r = fl.radius * wobble
-                    fl.x = _clamp(px + math.cos(fl.angle) * r, 0.0, WORLD_SIZE)
-                    fl.y = _clamp(py + math.sin(fl.angle) * r, 0.0, WORLD_SIZE)
+                    fl.x = clamp(px + math.cos(fl.angle) * r, 0.0, WORLD_SIZE)
+                    fl.y = clamp(py + math.sin(fl.angle) * r, 0.0, WORLD_SIZE)
 
             keep: list[_EmissiveProjectile] = []
             margin = 80.0
@@ -941,7 +924,7 @@ class LightingDebugView:
 
         def proj_light(proj: _EmissiveProjectile) -> tuple[float, float, float, float, float, float, float]:
             sx, sy = self._world.world_to_screen(float(proj.x), float(proj.y))
-            fade = _clamp(1.0 - float(proj.age) / max(0.001, float(proj.ttl)), 0.0, 1.0)
+            fade = clamp(1.0 - float(proj.age) / max(0.001, float(proj.ttl)), 0.0, 1.0)
             pr = self._proj_light_tint
             return (
                 float(sx),
@@ -1026,13 +1009,20 @@ class LightingDebugView:
     def draw(self) -> None:
         if self._player is None:
             rl.clear_background(rl.Color(10, 10, 12, 255))
-            self._draw_ui_text("Lighting debug view: missing player", 16.0, 16.0, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "Lighting debug view: missing player", 16.0, 16.0, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
 
         self._ensure_render_targets()
         if self._light_rt is None:
             rl.clear_background(rl.Color(10, 10, 12, 255))
-            self._draw_ui_text("Lighting debug view: missing render targets", 16.0, 16.0, UI_ERROR_COLOR)
+            draw_ui_text(
+                self._small,
+                "Lighting debug view: missing render targets",
+                16.0,
+                16.0,
+                scale=UI_TEXT_SCALE,
+                color=UI_ERROR_COLOR,
+            )
             return
 
         light_x = float(self._ui_mouse_x)
@@ -1057,7 +1047,7 @@ class LightingDebugView:
             rl.begin_blend_mode(rl.BLEND_ADDITIVE)
             for proj in self._projectiles:
                 sx, sy = self._world.world_to_screen(float(proj.x), float(proj.y))
-                fade = _clamp(1.0 - float(proj.age) / max(0.001, float(proj.ttl)), 0.0, 1.0)
+                fade = clamp(1.0 - float(proj.age) / max(0.001, float(proj.ttl)), 0.0, 1.0)
                 c = self._proj_light_tint
                 rl.draw_circle(
                     int(sx),
@@ -1156,9 +1146,16 @@ class LightingDebugView:
                 lines.append("SDF uniforms missing: " + ", ".join(self._sdf_shader_missing))
             x0 = 16.0
             y0 = 16.0
-            lh = float(self._ui_line_height())
+            lh = float(ui_line_height(self._small, scale=UI_TEXT_SCALE))
             for idx, line in enumerate(lines):
-                self._draw_ui_text(line, x0, y0 + lh * float(idx), UI_TEXT_COLOR if idx < 5 else UI_HINT_COLOR)
+                draw_ui_text(
+                    self._small,
+                    line,
+                    x0,
+                    y0 + lh * float(idx),
+                    scale=UI_TEXT_SCALE,
+                    color=UI_TEXT_COLOR if idx < 5 else UI_HINT_COLOR,
+                )
 
 
 @register_view("lighting-debug", "Lighting (SDF)")

crimson/views/particles.py

@@ -4,9 +4,10 @@ from dataclasses import dataclass
 
 import pyray as rl
 
-from .registry import register_view
 from ..effects_atlas import EFFECT_ID_ATLAS_TABLE, SIZE_CODE_GRID
-from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from ._ui_helpers import draw_ui_text, ui_line_height
+from .registry import register_view
+from grim.fonts.small import SmallFontData, load_small_font
 from grim.view import View, ViewContext
 
 UI_TEXT_SCALE = 1.0
@@ -77,24 +78,6 @@ class ParticleView:
         self._grid = 8
         self._show_uv_clamp = False
 
-    def _ui_line_height(self, scale: float = UI_TEXT_SCALE) -> int:
-        if self._small is not None:
-            return int(self._small.cell_size * scale)
-        return int(20 * scale)
-
-    def _draw_ui_text(
-        self,
-        text: str,
-        x: float,
-        y: float,
-        color: rl.Color,
-        scale: float = UI_TEXT_SCALE,
-    ) -> None:
-        if self._small is not None:
-            draw_small_text(self._small, text, x, y, scale, color)
-        else:
-            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
-
     def open(self) -> None:
         self._missing_assets.clear()
         self._small = load_small_font(self._assets_root, self._missing_assets)
@@ -139,10 +122,10 @@ class ParticleView:
         rl.clear_background(rl.Color(12, 12, 14, 255))
         if self._missing_assets:
             message = "Missing assets: " + ", ".join(self._missing_assets)
-            self._draw_ui_text(message, 24, 24, UI_ERROR_COLOR)
+            draw_ui_text(self._small, message, 24, 24, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
         if self._texture is None:
-            self._draw_ui_text("No particles texture loaded.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "No particles texture loaded.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
 
         self._handle_input()
@@ -233,59 +216,67 @@ class ParticleView:
 
         info_x = x + draw_w + panel_gap
         info_y = margin
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"particles.png (grid {grid}x{grid})",
             info_x,
             info_y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
-        info_y += self._ui_line_height() + 6
-        self._draw_ui_text(
+        info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6
+        draw_ui_text(
+            self._small,
             "Up/Down: grid  2/4/8: direct  1: grid16  U: UV clamp",
             info_x,
             info_y,
-            UI_HINT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
         )
-        info_y += self._ui_line_height() + 12
+        info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 12
         if self._show_uv_clamp:
             step_px = int(round(self._texture.width * step))
-            self._draw_ui_text(
+            draw_ui_text(
+                self._small,
                 f"UV clamp: {step_px}px of {int(self._texture.width / grid)}px",
                 info_x,
                 info_y,
-                UI_HINT_COLOR,
+                scale=UI_TEXT_SCALE,
+                color=UI_HINT_COLOR,
             )
-            info_y += self._ui_line_height() + 12
+            info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 12
 
         if hovered_index is not None:
-            self._draw_ui_text(f"frame {hovered_index:02d}", info_x, info_y, UI_TEXT_COLOR)
-            info_y += self._ui_line_height() + 6
+            draw_ui_text(self._small, f"frame {hovered_index:02d}", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+            info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6
             entries = known_frames.get(hovered_index, [])
             if entries:
                 for entry in entries:
                     label = f" {entry.label}" if entry.label else ""
-                    self._draw_ui_text(
+                    draw_ui_text(
+                        self._small,
                         f"0x{entry.effect_id:02x}{label}",
                         info_x,
                         info_y,
-                        UI_TEXT_COLOR,
+                        scale=UI_TEXT_SCALE,
+                        color=UI_TEXT_COLOR,
                     )
-                    info_y += self._ui_line_height() + 4
+                    info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 4
             else:
-                self._draw_ui_text("no known mapping", info_x, info_y, UI_HINT_COLOR)
-                info_y += self._ui_line_height() + 4
+                draw_ui_text(self._small, "no known mapping", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
+                info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 4
             info_y += 8
 
-        self._draw_ui_text("Effect table", info_x, info_y, UI_TEXT_COLOR)
-        info_y += self._ui_line_height() + 6
+        draw_ui_text(self._small, "Effect table", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+        info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6
         for entry in EFFECT_ENTRIES:
             grid_label = entry.grid
             line = f"0x{entry.effect_id:02x} grid{grid_label} frame 0x{entry.frame:02x}"
             if entry.label:
                 line += f" {entry.label}"
             color = UI_TEXT_COLOR if entry.grid == grid else UI_HINT_COLOR
-            self._draw_ui_text(line, info_x, info_y, color)
-            info_y += self._ui_line_height() + 3
+            draw_ui_text(self._small, line, info_x, info_y, scale=UI_TEXT_SCALE, color=color)
+            info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 3
 
 
 @register_view("particles", "Particle atlas preview")

crimson/views/perk_menu_debug.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import pyray as rl
 
 from grim.fonts.small import SmallFontData, load_small_font, measure_small_text_width
+from grim.math import clamp
 from grim.view import View, ViewContext
 
 from ..perks import PERK_BY_ID, PerkId, perk_display_description, perk_display_name
@@ -237,7 +238,7 @@ class PerkMenuDebugView:
         if rl.is_key_down(rl.KeyboardKey.KEY_RIGHT):
             self._panel_slide_x += step
 
-        self._panel_slide_x = _clamp(self._panel_slide_x, -self._layout.panel_w, 0.0)
+        self._panel_slide_x = clamp(self._panel_slide_x, -self._layout.panel_w, 0.0)
 
         self._prompt_hover = False
         self._prompt_rect = None
@@ -250,7 +251,7 @@ class PerkMenuDebugView:
                 self._prompt_hover = rl.check_collision_point_rec(mouse, rect)
 
         pulse_delta = dt_ms * (6.0 if self._prompt_hover else -2.0)
-        self._prompt_pulse = _clamp(self._prompt_pulse + pulse_delta, 0.0, 1000.0)
+        self._prompt_pulse = clamp(self._prompt_pulse + pulse_delta, 0.0, 1000.0)
 
         if not self._show_menu or self._assets is None:
             return
@@ -411,14 +412,6 @@ class PerkMenuDebugView:
             y += line_h
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 def _ui_text_width(font: SmallFontData | None, text: str, scale: float) -> float:
     if font is None:
         return float(rl.measure_text(text, int(20 * scale)))

crimson/views/player.py

@@ -5,7 +5,8 @@ from dataclasses import dataclass
 import pyray as rl
 
 from .registry import register_view
-from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.fonts.small import SmallFontData, load_small_font
+from grim.math import clamp
 from grim.view import View, ViewContext
 
 from ..bonuses import BonusId
@@ -19,8 +20,9 @@ from ..gameplay import (
     weapon_assign_player,
 )
 from ..perks import PerkId
-from ..ui.hud import HudAssets, draw_hud_overlay, hud_ui_scale, load_hud_assets
+from ..ui.hud import HudAssets, HudState, draw_hud_overlay, hud_ui_scale, load_hud_assets
 from ..weapons import WEAPON_TABLE
+from ._ui_helpers import draw_ui_text, ui_line_height
 
 WORLD_SIZE = 1024.0
 
@@ -38,14 +40,6 @@ class DummyCreature:
     size: float = 32.0
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 def _lerp(a: float, b: float, t: float) -> float:
     return a + (b - a) * t
 
@@ -66,6 +60,7 @@ class PlayerSandboxView:
 
         self._hud_assets: HudAssets | None = None
         self._hud_missing: list[str] = []
+        self._hud_state = HudState()
         self._elapsed_ms = 0.0
         self._last_dt_ms = 0.0
 
@@ -81,24 +76,6 @@ class PlayerSandboxView:
                 continue
             self._damage_scale_by_type[int(entry.weapon_id)] = float(entry.damage_scale or 1.0)
 
-    def _ui_line_height(self, scale: float = UI_TEXT_SCALE) -> int:
-        if self._small is not None:
-            return int(self._small.cell_size * scale)
-        return int(20 * scale)
-
-    def _draw_ui_text(
-        self,
-        text: str,
-        x: float,
-        y: float,
-        color: rl.Color,
-        scale: float = UI_TEXT_SCALE,
-    ) -> None:
-        if self._small is not None:
-            draw_small_text(self._small, text, x, y, scale, color)
-        else:
-            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
-
     def _ensure_creatures(self, target_count: int) -> None:
         while len(self._creatures) < target_count:
             margin = 40.0
@@ -142,6 +119,7 @@ class PlayerSandboxView:
         self._hud_assets = load_hud_assets(self._assets_root)
         if self._hud_assets.missing:
             self._hud_missing = list(self._hud_assets.missing)
+        self._hud_state = HudState()
 
         self._state.rng.srand(0xBEEF)
         self._creatures.clear()
@@ -239,7 +217,7 @@ class PlayerSandboxView:
         if desired_y < min_y:
             desired_y = min_y
 
-        t = _clamp(dt * 6.0, 0.0, 1.0)
+        t = clamp(dt * 6.0, 0.0, 1.0)
         self._camera_x = _lerp(self._camera_x, desired_x, t)
         self._camera_y = _lerp(self._camera_y, desired_y, t)
 
@@ -315,7 +293,7 @@ class PlayerSandboxView:
         rl.clear_background(rl.Color(10, 10, 12, 255))
         if self._missing_assets:
             message = "Missing assets: " + ", ".join(self._missing_assets)
-            self._draw_ui_text(message, 24, 24, UI_ERROR_COLOR)
+            draw_ui_text(self._small, message, 24, 24, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
 
         # World bounds.
@@ -353,6 +331,7 @@ class PlayerSandboxView:
         if self._hud_assets is not None:
             hud_bottom = draw_hud_overlay(
                 self._hud_assets,
+                state=self._hud_state,
                 player=self._player,
                 bonus_hud=self._state.bonus_hud,
                 elapsed_ms=self._elapsed_ms,
@@ -363,44 +342,64 @@ class PlayerSandboxView:
 
         if self._hud_missing:
             warn = "Missing HUD assets: " + ", ".join(self._hud_missing)
-            self._draw_ui_text(warn, 24, rl.get_screen_height() - 28, UI_ERROR_COLOR, scale=0.8)
+            draw_ui_text(self._small, warn, 24, rl.get_screen_height() - 28, scale=0.8, color=UI_ERROR_COLOR)
 
         # UI.
         scale = hud_ui_scale(float(rl.get_screen_width()), float(rl.get_screen_height()))
         margin = 18
         x = float(margin)
         y = max(float(margin) + 110.0 * scale, hud_bottom + 12.0 * scale)
-        line = self._ui_line_height()
+        line = ui_line_height(self._small, scale=UI_TEXT_SCALE)
 
         weapon_id = self._player.weapon_id
         weapon_name = next((w.name for w in WEAPON_TABLE if w.weapon_id == weapon_id), None) or f"weapon_{weapon_id}"
-        self._draw_ui_text(f"{weapon_name} (id {weapon_id})", x, y, UI_TEXT_COLOR)
+        draw_ui_text(self._small, f"{weapon_name} (id {weapon_id})", x, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
         y += line + 4
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"ammo {self._player.ammo}/{self._player.clip_size}  reload {self._player.reload_timer:.2f}/{self._player.reload_timer_max:.2f}",
             x,
             y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         y += line + 4
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"cooldown {self._player.shot_cooldown:.3f}  spread {self._player.spread_heat:.3f}",
             x,
             y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         y += line + 8
 
-        self._draw_ui_text("WASD move  Mouse aim  LMB fire  R reload/swap  Q/E weapon  Tab pause", x, y, UI_HINT_COLOR)
+        draw_ui_text(
+            self._small,
+            "WASD move  Mouse aim  LMB fire  R reload/swap  Q/E weapon  Tab pause",
+            x,
+            y,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
+        )
         y += line + 4
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             "1 Sharpshooter 2 Anxious 3 Stationary 4 Angry 5 Man Bomb 6 Hot Tempered 7 Fire Cough  T Alt Weapon",
             x,
             y,
-            UI_HINT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
         )
         y += line + 4
-        self._draw_ui_text("Z PowerUp  X Shield  C Speed  V FireBullets  B Fireblast  Backspace clear bonuses", x, y, UI_HINT_COLOR)
+        draw_ui_text(
+            self._small,
+            "Z PowerUp  X Shield  C Speed  V FireBullets  B Fireblast  Backspace clear bonuses",
+            x,
+            y,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
+        )
         y += line + 10
 
         active_perks = []
@@ -416,16 +415,23 @@ class PlayerSandboxView:
         ):
             if self._player.perk_counts[int(perk)]:
                 active_perks.append(perk.name.lower())
-        self._draw_ui_text("perks: " + (", ".join(active_perks) if active_perks else "none"), x, y, UI_TEXT_COLOR)
+        draw_ui_text(
+            self._small,
+            "perks: " + (", ".join(active_perks) if active_perks else "none"),
+            x,
+            y,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
+        )
         y += line + 8
 
         # Bonus HUD slots (text-only).
         slots = [slot for slot in self._state.bonus_hud.slots if slot.active]
         if slots:
-            self._draw_ui_text("bonuses:", x, y, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "bonuses:", x, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             y += line + 4
             for slot in slots:
-                self._draw_ui_text(f"- {slot.label}", x, y, UI_HINT_COLOR)
+                draw_ui_text(self._small, f"- {slot.label}", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
                 y += line + 2