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

crimson/ui/perk_menu.py

@@ -8,13 +8,11 @@ import pyray as rl
 
 from grim.assets import TextureLoader
 from grim.fonts.small import SmallFontData, draw_small_text, measure_small_text_width
+from grim.math import clamp
 
+from .layout import menu_widescreen_y_shift, ui_origin, ui_scale
 from .menu_panel import draw_classic_menu_panel
 
-
-UI_BASE_WIDTH = 640.0
-UI_BASE_HEIGHT = 480.0
-
 # Perk selection screen panel uses ui_element-style timeline animation:
 # - fully hidden until end_ms
 # - slides in over (end_ms..start_ms)
@@ -71,21 +69,6 @@ class PerkMenuComputedLayout:
     cancel_x: float
     cancel_y: float
 
-
-def ui_scale(screen_w: float, screen_h: float) -> float:
-    # Classic UI renders in backbuffer pixels; keep menu scale fixed.
-    return 1.0
-
-
-def ui_origin(screen_w: float, screen_h: float, scale: float) -> tuple[float, float]:
-    return 0.0, 0.0
-
-
-def _menu_widescreen_y_shift(layout_w: float) -> float:
-    # ui_menu_layout_init: pos_y += (screen_width / 640.0) * 150.0 - 150.0
-    return (layout_w / UI_BASE_WIDTH) * 150.0 - 150.0
-
-
 def perk_menu_compute_layout(
     layout: PerkMenuLayout,
     *,
@@ -99,7 +82,7 @@ def perk_menu_compute_layout(
     panel_slide_x: float = 0.0,
 ) -> PerkMenuComputedLayout:
     layout_w = screen_w / scale if scale else screen_w
-    widescreen_shift_y = _menu_widescreen_y_shift(layout_w)
+    widescreen_shift_y = menu_widescreen_y_shift(layout_w)
     panel_x = layout.panel_x + panel_slide_x
     panel_y = layout.panel_y + widescreen_shift_y
     panel = rl.Rectangle(
@@ -358,10 +341,10 @@ def button_update(
         state.hovered = rl.check_collision_point_rec(mouse, button_hit_rect(x=x, y=y, width=width))
 
     delta = 6 if (state.enabled and state.hovered) else -4
-    state.hover_t = int(_clamp(float(state.hover_t + int(dt_ms) * delta), 0.0, 1000.0))
+    state.hover_t = int(clamp(float(state.hover_t + int(dt_ms) * delta), 0.0, 1000.0))
 
     if state.press_t > 0:
-        state.press_t = int(_clamp(float(state.press_t - int(dt_ms) * 6), 0.0, 1000.0))
+        state.press_t = int(clamp(float(state.press_t - int(dt_ms) * 6), 0.0, 1000.0))
 
     state.activated = bool(state.enabled and state.hovered and click)
     if state.activated:
@@ -369,14 +352,6 @@ def button_update(
     return state.activated
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 def button_draw(
     assets: UiButtonTextures,
     font: SmallFontData | None,
@@ -409,7 +384,7 @@ def button_draw(
             int(255 * r),
             int(255 * g),
             int(255 * b),
-            int(255 * _clamp(a, 0.0, 1.0)),
+            int(255 * clamp(a, 0.0, 1.0)),
         )
         rl.draw_rectangle(
             int(x + 12.0 * scale),
@@ -419,14 +394,14 @@ def button_draw(
             hl,
         )
 
-    plate_tint = rl.Color(255, 255, 255, int(255 * _clamp(state.alpha, 0.0, 1.0)))
+    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, 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_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
@@ -437,7 +412,7 @@ def cursor_draw(assets: PerkMenuAssets, *, mouse: rl.Vector2, scale: float, alph
     tex = assets.cursor
     if tex is None:
         return
-    a = int(255 * _clamp(alpha, 0.0, 1.0))
+    a = int(255 * clamp(alpha, 0.0, 1.0))
     tint = rl.Color(255, 255, 255, a)
     size = 32.0 * scale
     src = rl.Rectangle(0.0, 0.0, float(tex.width), float(tex.height))

crimson/ui/quest_results.py

@@ -21,6 +21,8 @@ from ..persistence.highscores import (
     upsert_highscore_record,
 )
 from ..quests.results import QuestFinalTime, QuestResultsBreakdownAnim, tick_quest_results_breakdown_anim
+from .formatting import format_ordinal, format_time_mm_ss
+from .layout import menu_widescreen_y_shift, ui_origin, ui_scale
 from .menu_panel import draw_classic_menu_panel
 from .perk_menu import (
     PerkMenuAssets,
@@ -32,25 +34,7 @@ from .perk_menu import (
     draw_ui_text,
     load_perk_menu_assets,
 )
-
-
-UI_BASE_WIDTH = 640.0
-UI_BASE_HEIGHT = 480.0
-
-
-def ui_scale(screen_w: float, screen_h: float) -> float:
-    # Classic UI-space: draw in backbuffer pixels.
-    return 1.0
-
-
-def ui_origin(screen_w: float, screen_h: float, scale: float) -> tuple[float, float]:
-    return 0.0, 0.0
-
-
-def _menu_widescreen_y_shift(layout_w: float) -> float:
-    # ui_menu_layout_init: pos_y += (screen_width / 640.0) * 150.0 - 150.0
-    return (layout_w / UI_BASE_WIDTH) * 150.0 - 150.0
-
+from .text_input import poll_text_input
 
 # `quest_results_screen_update` base layout (Crimsonland classic UI panel).
 # Values are derived from `ui_menu_assets_init` + `ui_menu_layout_init` and how
@@ -96,44 +80,6 @@ COLOR_TEXT_SUBTLE = rl.Color(255, 255, 255, int(255 * 0.7))
 COLOR_GREEN = rl.Color(25, 200, 25, 255)
 
 
-def _poll_text_input(max_len: int, *, allow_space: bool = True) -> str:
-    out = ""
-    while True:
-        value = rl.get_char_pressed()
-        if value == 0:
-            break
-        if value < 0x20 or value > 0xFF:
-            continue
-        if not allow_space and value == 0x20:
-            continue
-        if len(out) >= max_len:
-            continue
-        out += chr(int(value))
-    return out
-
-
-def _format_ordinal(value_1_based: int) -> str:
-    value = int(value_1_based)
-    if value % 100 in (11, 12, 13):
-        suffix = "th"
-    elif value % 10 == 1:
-        suffix = "st"
-    elif value % 10 == 2:
-        suffix = "nd"
-    elif value % 10 == 3:
-        suffix = "rd"
-    else:
-        suffix = "th"
-    return f"{value}{suffix}"
-
-
-def _format_time_mm_ss(ms: int) -> str:
-    total_s = max(0, int(ms)) // 1000
-    minutes = total_s // 60
-    seconds = total_s % 60
-    return f"{minutes}:{seconds:02d}"
-
-
 @dataclass(slots=True)
 class QuestResultsAssets:
     menu_panel: rl.Texture | None
@@ -308,7 +254,7 @@ class QuestResultsUi:
 
         left = (QUEST_RESULTS_PANEL_GEOM_X0 + QUEST_RESULTS_PANEL_POS_X + panel_slide_x) * scale
         layout_w = screen_w / scale if scale else screen_w
-        widescreen_shift_y = _menu_widescreen_y_shift(layout_w)
+        widescreen_shift_y = menu_widescreen_y_shift(layout_w)
         top = (QUEST_RESULTS_PANEL_GEOM_Y0 + QUEST_RESULTS_PANEL_POS_Y + widescreen_shift_y) * scale
         panel = rl.Rectangle(float(left), float(top), QUEST_RESULTS_PANEL_W * scale, QUEST_RESULTS_PANEL_H * scale)
         return panel, left, top
@@ -382,7 +328,7 @@ class QuestResultsUi:
 
         if self.phase == 1:
             click = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
-            typed = _poll_text_input(NAME_MAX_EDIT - len(self.input_text), allow_space=True)
+            typed = poll_text_input(NAME_MAX_EDIT - len(self.input_text), allow_space=True)
             if typed:
                 self.input_text = (self.input_text[: self.input_caret] + typed + self.input_text[self.input_caret :])[:NAME_MAX_EDIT]
                 self.input_caret = min(len(self.input_text), self.input_caret + len(typed))
@@ -429,6 +375,8 @@ class QuestResultsUi:
                         except Exception:
                             self.highlight_rank = None
                         self._saved = True
+                    self.config.set_player_name(self.input_text)
+                    self.config.save()
                     self.phase = 2
                     return None
                 if play_sfx is not None:
@@ -570,10 +518,10 @@ class QuestResultsUi:
                 return rl.Color(rgb[0], rgb[1], rgb[2], int(255 * max(0.0, min(1.0, alpha))))
 
             y = top + 156.0 * scale
-            base_value = _format_time_mm_ss(base_time_ms)
-            life_value = _format_time_mm_ss(life_bonus_ms)
-            perk_value = _format_time_mm_ss(perk_bonus_ms)
-            final_value = _format_time_mm_ss(final_time_ms)
+            base_value = format_time_mm_ss(base_time_ms)
+            life_value = format_time_mm_ss(life_bonus_ms)
+            perk_value = format_time_mm_ss(perk_bonus_ms)
+            final_value = format_time_mm_ss(final_time_ms)
 
             self._draw_small("Base Time:", label_x, y, 1.0 * scale, _row_color(0))
             self._draw_small(base_value, value_x, y, 1.0 * scale, _row_color(0))
@@ -639,7 +587,7 @@ class QuestResultsUi:
             seconds = float(int(self.record.survival_elapsed_ms)) * 0.001
             score_value = f"{seconds:.2f} secs"
             xp_value = f"{int(self.record.score_xp)}"
-            rank_text = _format_ordinal(int(self.rank) + 1) if qualifies else "--"
+            rank_text = format_ordinal(int(self.rank) + 1) if qualifies else "--"
 
             col_label = rl.Color(230, 230, 230, 255)
             col_value = rl.Color(230, 230, 255, 255)

crimson/ui/text_input.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import pyray as rl
+
+
+def poll_text_input(max_len: int, *, allow_space: bool = True) -> str:
+    out = ""
+    while True:
+        value = rl.get_char_pressed()
+        if value == 0:
+            break
+        if value < 0x20 or value > 0xFF:
+            continue
+        if not allow_space and value == 0x20:
+            continue
+        if len(out) >= max_len:
+            continue
+        out += chr(int(value))
+    return out
+

crimson/views/_ui_helpers.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import pyray as rl
+
+from grim.fonts.small import SmallFontData, draw_small_text
+
+
+def ui_line_height(font: SmallFontData | None, *, scale: float = 1.0) -> int:
+    if font is not None:
+        return int(font.cell_size * float(scale))
+    return int(20 * float(scale))
+
+
+def draw_ui_text(
+    font: SmallFontData | None,
+    text: str,
+    x: float,
+    y: float,
+    *,
+    color: rl.Color,
+    scale: float = 1.0,
+) -> None:
+    if font is not None:
+        draw_small_text(font, text, x, y, float(scale), color)
+    else:
+        rl.draw_text(text, int(x), int(y), int(20 * float(scale)), color)
+

crimson/views/aim_debug.py

@@ -5,13 +5,15 @@ import math
 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 ..game_world import GameWorld
 from ..gameplay import PlayerInput
 from ..paths import default_runtime_dir
 from ..ui.cursor import draw_cursor_glow
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 WORLD_SIZE = 1024.0
@@ -22,14 +24,6 @@ UI_HINT_COLOR = rl.Color(140, 140, 140, 255)
 UI_ERROR_COLOR = rl.Color(240, 80, 80, 255)
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 class AimDebugView:
     def __init__(self, ctx: ViewContext) -> None:
         self._assets_root = ctx.assets_dir
@@ -61,30 +55,12 @@ class AimDebugView:
         self._forced_heat = 0.18
         self._test_circle_radius = 96.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 _update_ui_mouse(self) -> None:
         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 _draw_cursor_glow(self, *, x: float, y: float) -> None:
         draw_cursor_glow(self._world.particles_texture, x=x, y=y)
@@ -264,11 +240,18 @@ class AimDebugView:
             ]
             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 < 6 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 < 6 else UI_HINT_COLOR,
+                )
         elif self._draw_expected_overlay and self._player is None:
-            self._draw_ui_text("Aim debug view: missing player", 16.0, 16.0, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "Aim debug view: missing player", 16.0, 16.0, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
 
 
 @register_view("aim-debug", "Aim indicator debug")

crimson/views/animations.py

@@ -6,8 +6,9 @@ import pyray as rl
 
 from ..creatures.anim import creature_anim_advance_phase, creature_anim_select_frame
 from ..creatures.spawn import CreatureFlags, CreatureTypeId, SPAWN_TEMPLATES, SpawnTemplate, resolve_tint
+from ._ui_helpers import draw_ui_text, ui_line_height
 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.view import View, ViewContext
 
 UI_TEXT_SCALE = 1.0
@@ -52,24 +53,6 @@ class CreatureAnimationView:
         self._last_step = 0.0
         self._apply_template_defaults()
 
-    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._textures.clear()
@@ -163,24 +146,24 @@ class CreatureAnimationView:
         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 not self._templates:
-            self._draw_ui_text("No spawn templates loaded.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "No spawn templates loaded.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
 
         self._handle_input()
         template = self._current_template()
         if template is None or template.type_id is None or template.creature is None:
-            self._draw_ui_text("Invalid template.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "Invalid template.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
         texture = self._textures.get(template.creature)
         if texture is None:
-            self._draw_ui_text("Missing texture for creature.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "Missing texture for creature.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
         info = TYPE_ANIM.get(template.type_id)
         if info is None:
-            self._draw_ui_text("Missing anim info.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "Missing anim info.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
 
         frame, mirror_applied, mode = creature_anim_select_frame(
@@ -196,12 +179,19 @@ class CreatureAnimationView:
 
         margin = 24
         title = f"{template.creature} (spawn 0x{template.spawn_id:02x})"
-        self._draw_ui_text(title, margin, margin, UI_TEXT_COLOR)
+        draw_ui_text(self._small, title, margin, margin, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
         hint = (
             "Left/Right: spawn template  Up/Down: move_speed  PgUp/PgDn: size  "
             "[/]: local scale  Space: pause  R: reset"
         )
-        self._draw_ui_text(hint, margin, margin + self._ui_line_height() + 6, UI_HINT_COLOR)
+        draw_ui_text(
+            self._small,
+            hint,
+            margin,
+            margin + ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
+        )
 
         sheet_scale = min(
             1.0,
@@ -265,8 +255,8 @@ class CreatureAnimationView:
         ]
         y = int(preview_y + preview_size + 16)
         for line in info_lines:
-            self._draw_ui_text(line, preview_x, y, UI_TEXT_COLOR)
-            y += self._ui_line_height() + 4
+            draw_ui_text(self._small, line, preview_x, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+            y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 4
 
 
 @register_view("animations", "Creature animation preview")

crimson/views/arsenal_debug.py

@@ -7,7 +7,8 @@ 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.fonts.small import SmallFontData, load_small_font
+from grim.math import clamp
 from grim.view import View, ViewContext
 
 from ..bonuses import BONUS_TABLE, BonusId
@@ -24,6 +25,7 @@ from ..weapons import (
     Weapon,
     projectile_type_id_from_weapon_id,
 )
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .audio_bootstrap import init_view_audio
 from .registry import register_view
 
@@ -65,14 +67,6 @@ SPECIAL_PROJECTILES: dict[int, str] = {
 }
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 def _fmt_float(value: float | None, *, digits: int = 3) -> str:
     if value is None:
         return "—"
@@ -135,17 +129,6 @@ class ArsenalDebugView:
         player.speed_multiplier = float(ARSENAL_PLAYER_MOVE_SPEED_MULTIPLIER)
         player.shield_timer = float(ARSENAL_PLAYER_INVULNERABLE_SHIELD_TIMER)
 
-    def _ui_line_height(self, scale: float = 1.0) -> 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 = 1.0) -> 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 _selected_weapon_id(self) -> int:
         if not self._weapon_ids:
             return 0
@@ -181,11 +164,14 @@ class ArsenalDebugView:
         count = max(1, len(self._spawn_ids))
         base_x = float(player.pos_x)
         base_y = float(player.pos_y)
+        detail_preset = 5
+        if self._world.config is not None:
+            detail_preset = int(self._world.config.data.get("detail_preset", 5) or 5)
         for idx in range(count):
             spawn_id = int(self._spawn_ids[idx % len(self._spawn_ids)])
             angle = float(idx) / float(count) * math.tau
-            x = _clamp(base_x + math.cos(angle) * self._spawn_ring_radius, 48.0, WORLD_SIZE - 48.0)
-            y = _clamp(base_y + math.sin(angle) * self._spawn_ring_radius, 48.0, WORLD_SIZE - 48.0)
+            x = clamp(base_x + math.cos(angle) * self._spawn_ring_radius, 48.0, WORLD_SIZE - 48.0)
+            y = clamp(base_y + math.sin(angle) * self._spawn_ring_radius, 48.0, WORLD_SIZE - 48.0)
             heading = angle + math.pi
             self._world.creatures.spawn_template(
                 spawn_id,
@@ -193,6 +179,8 @@ class ArsenalDebugView:
                 heading,
                 self._world.state.rng,
                 rand=self._world.state.rng.rand,
+                state=self._world.state,
+                detail_preset=detail_preset,
             )
 
     def _spawn_all_bonuses(self) -> None:
@@ -402,43 +390,45 @@ class ArsenalDebugView:
 
         warn_x = 24.0
         warn_y = 24.0
-        warn_line = float(self._ui_line_height())
+        warn_line = float(ui_line_height(self._small))
         if self._missing_assets:
-            self._draw_ui_text("Missing assets (ui): " + ", ".join(self._missing_assets), warn_x, warn_y, UI_ERROR)
+            draw_ui_text(self._small, "Missing assets (ui): " + ", ".join(self._missing_assets), warn_x, warn_y, color=UI_ERROR)
             warn_y += warn_line
         if self._world.missing_assets:
-            self._draw_ui_text(
+            draw_ui_text(
+                self._small,
                 "Missing assets (world): " + ", ".join(self._world.missing_assets),
                 warn_x,
                 warn_y,
-                UI_ERROR,
+                color=UI_ERROR,
             )
             warn_y += warn_line
 
         x = 16.0
         y = 12.0
-        line = float(self._ui_line_height())
+        line = float(ui_line_height(self._small))
 
         weapon = WEAPON_BY_ID.get(int(self._player.weapon_id)) if self._player is not None else None
         for text in self._weapon_debug_lines(weapon):
-            self._draw_ui_text(text, x, y, UI_TEXT)
+            draw_ui_text(self._small, text, x, y, color=UI_TEXT)
             y += line
 
         if self._player is not None:
             alive = sum(1 for c in self._world.creatures.entries if c.active and c.hp > 0.0)
             total = sum(1 for c in self._world.creatures.entries if c.active)
-            self._draw_ui_text(f"creatures alive {alive}/{total}", x, y, UI_TEXT)
+            draw_ui_text(self._small, f"creatures alive {alive}/{total}", x, y, color=UI_TEXT)
             y += line
 
         y += 6.0
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             "WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  T respawn  B spawn all bonuses  Backspace reset  Esc quit",
             x,
             y,
-            UI_HINT,
+            color=UI_HINT,
         )
         y += line
-        self._draw_ui_text("P screenshot", x, y, UI_HINT)
+        draw_ui_text(self._small, "P screenshot", x, y, color=UI_HINT)
 
         mouse = rl.get_mouse_position()
         draw_aim_cursor(self._world.particles_texture, self._aim_texture, x=float(mouse.x), y=float(mouse.y))