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

crimson/views/bonuses.py

@@ -6,8 +6,9 @@ import pyray as rl
 
 from ..bonuses import BONUS_TABLE, BonusMeta
 from ..weapons import WEAPON_TABLE
+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
@@ -46,24 +47,6 @@ class BonusIconView:
         self._texture: rl.Texture | None = None
         self._small: SmallFontData | None = None
 
-    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)
@@ -88,10 +71,10 @@ class BonusIconView:
         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 bonuses texture loaded.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "No bonuses texture loaded.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
 
         margin = 24
@@ -149,41 +132,45 @@ class BonusIconView:
 
         info_x = x + draw_w + panel_gap
         info_y = margin
-        self._draw_ui_text("bonuses.png (grid 4x4)", info_x, info_y, UI_TEXT_COLOR)
-        info_y += self._ui_line_height() + 12
+        draw_ui_text(self._small, "bonuses.png (grid 4x4)", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+        info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 12
 
         if hovered_index is not None:
             group = BONUS_ICON_GROUPS.get(hovered_index)
-            self._draw_ui_text(f"icon_id {hovered_index}", info_x, info_y, UI_TEXT_COLOR)
-            info_y += self._ui_line_height() + 6
+            draw_ui_text(self._small, f"icon_id {hovered_index}", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+            info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6
             if group is None:
-                self._draw_ui_text("no bonus mapping", info_x, info_y, UI_HINT_COLOR)
-                info_y += self._ui_line_height() + 6
+                draw_ui_text(self._small, "no bonus mapping", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
+                info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6
             else:
                 for entry in group.bonuses:
                     bonus_id = int(entry.bonus_id)
                     amount = entry.default_amount
                     amount_label = f" default={amount}" if amount is not None else ""
-                    self._draw_ui_text(
+                    draw_ui_text(
+                        self._small,
                         f"id {bonus_id:02d} {entry.name}{amount_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
                     if entry.description:
-                        self._draw_ui_text(
+                        draw_ui_text(
+                            self._small,
                             entry.description,
                             info_x,
                             info_y,
-                            UI_HINT_COLOR,
+                            scale=UI_TEXT_SCALE,
+                            color=UI_HINT_COLOR,
                         )
-                        info_y += self._ui_line_height() + 4
+                        info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 4
             info_y += 8
 
         if WEAPON_BONUS is not None:
-            self._draw_ui_text("Weapon bonus icon", info_x, info_y, UI_TEXT_COLOR)
-            info_y += self._ui_line_height() + 4
+            draw_ui_text(self._small, "Weapon bonus icon", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+            info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 4
             weapon_id = WEAPON_BONUS.default_amount
             weapon_name = None
             if weapon_id is not None:
@@ -193,7 +180,7 @@ class BonusIconView:
                         break
             name_label = f" ({weapon_name})" if weapon_name else ""
             weapon_label = f"icon_id = -1 → ui_wicons (default weapon {weapon_id}{name_label})"
-            self._draw_ui_text(weapon_label, info_x, info_y, UI_HINT_COLOR)
+            draw_ui_text(self._small, weapon_label, info_x, info_y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
 
 
 @register_view("bonuses", "Bonus icon preview")

crimson/views/camera_debug.py

@@ -11,10 +11,11 @@ import pyray as rl
 from grim.assets import resolve_asset_path
 from grim.config import ensure_crimson_cfg
 from grim.terrain_render import GroundRenderer
-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
 
 from ..paths import default_runtime_dir
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 
@@ -58,24 +59,6 @@ class CameraDebugView:
         self._log_path: Path | None = None
         self._log_file = None
 
-    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 _load_runtime_config(self) -> None:
         runtime_dir = default_runtime_dir()
         if not runtime_dir.is_dir():
@@ -276,7 +259,7 @@ class CameraDebugView:
         rl.clear_background(clear_color)
 
         if self._renderer is None:
-            self._draw_ui_text("Ground renderer not initialized.", 16, 16, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "Ground renderer not initialized.", 16, 16, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
 
         cam_x, cam_y, scale_x, scale_y, screen_w, screen_h = self._world_params()
@@ -327,31 +310,35 @@ class CameraDebugView:
         # HUD
         x = 16.0
         y = 16.0
-        line = self._ui_line_height()
+        line = ui_line_height(self._small, scale=UI_TEXT_SCALE)
         mode = "config" if self._use_config_screen else "window"
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"window={int(out_w)}x{int(rl.get_screen_height())}  camera={int(screen_w)}x{int(screen_h)} ({mode})",
             x,
             y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"config={int(self._config_screen_w)}x{int(self._config_screen_h)}  "
             f"scale={scale_x:.3f},{scale_y:.3f}  tex={self._texture_scale:.2f}",
             x,
             y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         y += line
-        self._draw_ui_text(f"player={self._player_x:.1f},{self._player_y:.1f}", x, y, UI_TEXT_COLOR)
+        draw_ui_text(self._small, f"player={self._player_x:.1f},{self._player_y:.1f}", x, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
         y += line
-        self._draw_ui_text(f"camera={cam_x:.1f},{cam_y:.1f}", x, y, UI_TEXT_COLOR)
+        draw_ui_text(self._small, f"camera={cam_x:.1f},{cam_y:.1f}", x, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
         y += line
         if self._log_path is not None:
-            self._draw_ui_text(f"log: {self._log_path}", x, y, UI_HINT_COLOR, scale=0.9)
+            draw_ui_text(self._small, f"log: {self._log_path}", x, y, scale=0.9, color=UI_HINT_COLOR)
             y += line
-        self._draw_ui_text("F1: toggle camera size (config/window)", x, y, UI_HINT_COLOR)
+        draw_ui_text(self._small, "F1: toggle camera size (config/window)", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
 
 
 @register_view("camera-debug", "Camera debug")

crimson/views/camera_shake.py

@@ -6,7 +6,8 @@ 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 View, ViewContext
 
 from ..bonuses import BonusId
@@ -14,6 +15,7 @@ from ..creatures.spawn import CreatureInit, CreatureTypeId
 from ..game_world import GameWorld
 from ..gameplay import PlayerInput, bonus_apply
 from ..paths import default_runtime_dir
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 
@@ -25,14 +27,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
-
-
 @dataclass(frozen=True, slots=True)
 class _SpawnSpec:
     r: float
@@ -70,29 +64,11 @@ class CameraShakeView:
         self._reflex_boost_locked = False
         self._reset_scene()
 
-    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 _spawn_creature(self, *, world_x: float, world_y: float, type_id: CreatureTypeId, hp: float) -> None:
         init = CreatureInit(
             origin_template_id=0,
-            pos_x=_clamp(world_x, 64.0, WORLD_SIZE - 64.0),
-            pos_y=_clamp(world_y, 64.0, WORLD_SIZE - 64.0),
+            pos_x=clamp(world_x, 64.0, WORLD_SIZE - 64.0),
+            pos_y=clamp(world_y, 64.0, WORLD_SIZE - 64.0),
             heading=math.pi,
             phase_seed=0.0,
             type_id=type_id,
@@ -205,7 +181,7 @@ class CameraShakeView:
 
         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)
 
         state = self._world.state
         cam_x, cam_y, _sx, _sy = self._world._world_params()
@@ -217,11 +193,11 @@ class CameraShakeView:
             f"reflex_boost={state.bonuses.reflex_boost:.2f}  creatures_alive={len(self._world.creatures.iter_active())}",
         ]
         x = 24.0
-        y = 24.0 + float(self._ui_line_height()) + 12.0
+        y = 24.0 + float(ui_line_height(self._small, scale=UI_TEXT_SCALE)) + 12.0
         for idx, line in enumerate(lines):
             color = UI_HINT_COLOR if idx == 0 else UI_TEXT_COLOR
-            self._draw_ui_text(line, x, y, color)
-            y += float(self._ui_line_height())
+            draw_ui_text(self._small, line, x, y, scale=UI_TEXT_SCALE, color=color)
+            y += float(ui_line_height(self._small, scale=UI_TEXT_SCALE))
 
 
 @register_view("camera-shake", "Camera shake")

crimson/views/corpse_stamp_debug.py

@@ -9,11 +9,12 @@ from crimson.creatures.anim import creature_corpse_frame_for_type
 from crimson.creatures.spawn import CreatureTypeId
 from grim.assets import resolve_asset_path
 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.terrain_render import GroundCorpseDecal, GroundRenderer, _maybe_alpha_test
 from grim.view import View, ViewContext
 
 from ..paths import default_runtime_dir
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 
@@ -61,17 +62,6 @@ class CorpseStampDebugView:
         self._dump_requested = False
         self._dump_index = 0
 
-    def _ui_line_height(self) -> int:
-        if self._small is not None:
-            return int(self._small.cell_size)
-        return 20
-
-    def _draw_ui_text(self, text: str, x: float, y: float, color: rl.Color) -> None:
-        if self._small is not None:
-            draw_small_text(self._small, text, x, y, 1.0, color)
-        else:
-            rl.draw_text(text, int(x), int(y), 20, color)
-
     def _load_runtime_config(self) -> tuple[float, float | None, float | None]:
         runtime_dir = default_runtime_dir()
         if runtime_dir.is_dir():
@@ -266,12 +256,12 @@ class CorpseStampDebugView:
         rl.clear_background(BG)
 
         if self._missing_assets:
-            self._draw_ui_text("Missing assets: " + ", ".join(self._missing_assets), 24, 24, UI_ERROR)
+            draw_ui_text(self._small, "Missing assets: " + ", ".join(self._missing_assets), 24, 24, color=UI_ERROR)
             return
 
         ground = self._ground
         if ground is None:
-            self._draw_ui_text("Ground renderer not initialized.", 24, 24, UI_ERROR)
+            draw_ui_text(self._small, "Ground renderer not initialized.", 24, 24, color=UI_ERROR)
             return
 
         if self._dump_requested:
@@ -287,25 +277,27 @@ class CorpseStampDebugView:
         # UI
         x = 24.0
         y = 20.0
-        line = float(self._ui_line_height())
+        line = float(ui_line_height(self._small))
         step = _STEPS[self._step_index]
         alpha_test = bool(getattr(ground, "alpha_test", True))
-        self._draw_ui_text("Corpse stamp debug (SPIDER)", x, y, UI_TEXT)
+        draw_ui_text(self._small, "Corpse stamp debug (SPIDER)", x, y, color=UI_TEXT)
         y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             "N/Space: next step   R: reset   A: toggle alpha test   Q/E: rotate   P: screenshot   D: dump RT",
             x,
             y,
-            UI_HINT,
+            color=UI_HINT,
         )
         y += line
-        self._draw_ui_text(f"step {self._step_index + 1}/{len(_STEPS)}: {step.description}", x, y, UI_HINT)
+        draw_ui_text(self._small, f"step {self._step_index + 1}/{len(_STEPS)}: {step.description}", x, y, color=UI_HINT)
         y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"alpha_test={'on' if alpha_test else 'off'}  size={self._corpse_size:.1f}  dump_index={self._dump_index}",
             x,
             y,
-            UI_HINT,
+            color=UI_HINT,
         )
 
         # Source preview (bodyset frame) in the corner for inspection.

crimson/views/decals_debug.py

@@ -16,11 +16,12 @@ from crimson.gameplay import GameplayState, PlayerState
 from crimson.render.terrain_fx import FxQueueTextures, bake_fx_queues
 from grim.assets import resolve_asset_path
 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.terrain_render import GroundRenderer
 from grim.view import View, ViewContext
 
 from ..paths import default_runtime_dir
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 
@@ -113,17 +114,6 @@ class DecalsDebugView:
         self._fx_queue = FxQueue()
         self._fx_queue_rotated = FxQueueRotated()
 
-    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 _write_stamp_log(self, payload: dict) -> None:
         if self._stamp_log_file is None:
             return
@@ -631,11 +621,18 @@ class DecalsDebugView:
         rl.clear_background(BG_LIGHT if self._light_mode else BG_DARK)
 
         if self._missing_assets:
-            self._draw_ui_text("Missing assets: " + ", ".join(self._missing_assets), 24, 24, UI_ERROR_COLOR)
+            draw_ui_text(
+                self._small,
+                "Missing assets: " + ", ".join(self._missing_assets),
+                24,
+                24,
+                scale=UI_TEXT_SCALE,
+                color=UI_ERROR_COLOR,
+            )
             return
 
         if self._ground is None:
-            self._draw_ui_text("Ground renderer not initialized.", 24, 24, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "Ground renderer not initialized.", 24, 24, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
 
         self._ground.draw(self._camera_x, self._camera_y)
@@ -697,28 +694,44 @@ class DecalsDebugView:
         hint_color = UI_HINT_DARK if self._light_mode else UI_HINT_LIGHT
         x = 16
         y = 12
-        line = self._ui_line_height()
-        self._draw_ui_text("Decals debug", x, y, text_color)
+        line = ui_line_height(self._small, scale=UI_TEXT_SCALE)
+        draw_ui_text(self._small, "Decals debug", x, y, scale=UI_TEXT_SCALE, color=text_color)
         y += line
-        self._draw_ui_text("LMB: blood / damage enemy   RMB: spawn enemy", x, y, hint_color)
+        draw_ui_text(self._small, "LMB: blood / damage enemy   RMB: spawn enemy", x, y, scale=UI_TEXT_SCALE, color=hint_color)
         y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             "WASD: pan   R: random seed   T: random terrain   G: toggle light grid   C: clear   L: stamp log",
             x,
             y,
-            hint_color,
+            scale=UI_TEXT_SCALE,
+            color=hint_color,
         )
         y += line
-        self._draw_ui_text(f"enemies={len([c for c in self._creatures.entries if c.active])}", x, y, hint_color)
+        draw_ui_text(
+            self._small,
+            f"enemies={len([c for c in self._creatures.entries if c.active])}",
+            x,
+            y,
+            scale=UI_TEXT_SCALE,
+            color=hint_color,
+        )
         y += line
         if self._stamp_log_path is not None:
             status = "on" if self._show_stamp_log else "off"
-            self._draw_ui_text(f"stamp log ({status}): {self._stamp_log_path}", x, y, hint_color)
+            draw_ui_text(
+                self._small,
+                f"stamp log ({status}): {self._stamp_log_path}",
+                x,
+                y,
+                scale=UI_TEXT_SCALE,
+                color=hint_color,
+            )
             y += line
         if self._ground is not None and self._show_stamp_log:
             stamp_log = self._ground.debug_stamp_log()
             if stamp_log:
-                self._draw_ui_text("stamp order:", x, y, hint_color)
+                draw_ui_text(self._small, "stamp order:", x, y, scale=UI_TEXT_SCALE, color=hint_color)
                 y += line
                 for event in stamp_log[-6:]:
                     kind = str(event.get("kind", "?"))
@@ -730,7 +743,7 @@ class DecalsDebugView:
                         msg = f"{kind} draws={event.get('draws')}"
                     else:
                         msg = kind
-                    self._draw_ui_text(msg, x, y, hint_color)
+                    draw_ui_text(self._small, msg, x, y, scale=UI_TEXT_SCALE, color=hint_color)
                     y += line
 
 

crimson/views/fonts.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pyray as rl
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .quest_title_overlay import (
     draw_quest_title_overlay,
     quest_title_base_scale,
@@ -41,24 +42,6 @@ class FontView:
         self._grim_mono: GrimMonoFont | None = None
         self._sample = DEFAULT_SAMPLE
 
-    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 close(self) -> None:
         if self._small is not None:
             rl.unload_texture(self._small.texture)
@@ -83,20 +66,20 @@ class FontView:
         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
         y = 24
-        self._draw_ui_text("Small font", 24, y, UI_TEXT_COLOR)
-        y += self._ui_line_height() + 12
+        draw_ui_text(self._small, "Small font", 24, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+        y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 12
         if self._small is not None:
             draw_small_text(self._small, self._sample, 24, y, SMALL_SAMPLE_SCALE, rl.WHITE)
             y += int(measure_small_text_height(self._small, self._sample, SMALL_SAMPLE_SCALE)) + 40
 
-        self._draw_ui_text("Grim2D mono font", 24, y, UI_TEXT_COLOR)
-        y += self._ui_line_height() + 12
+        draw_ui_text(self._small, "Grim2D mono font", 24, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+        y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 12
         if self._grim_mono is not None:
-            self._draw_ui_text(f"Filter: {GRIM_MONO_FILTER_NAME}", 24, y, UI_TEXT_COLOR)
-            y += self._ui_line_height(0.9) + 6
+            draw_ui_text(self._small, f"Filter: {GRIM_MONO_FILTER_NAME}", 24, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
+            y += ui_line_height(self._small, scale=0.9) + 6
             mono_scale = quest_title_base_scale(rl.get_screen_width())
             draw_grim_mono_text(self._grim_mono, self._sample, 24, y, mono_scale, rl.WHITE)
             y += int(measure_grim_mono_text_height(self._grim_mono, self._sample, mono_scale)) + 20

crimson/views/ground.py

@@ -13,10 +13,11 @@ from grim.terrain_render import GroundRenderer
 from ..paths import default_runtime_dir
 from ..quests import all_quests
 from ..quests.types import QuestDefinition
+from ._ui_helpers import draw_ui_text
 from .quest_title_overlay import draw_quest_title_overlay
 from .registry import register_view
 from grim.fonts.grim_mono import GrimMonoFont, load_grim_mono_font
-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
 
 
@@ -60,24 +61,6 @@ class GroundView:
         self._fx_queue_rotated = FxQueueRotated()
         self._fx_textures: FxQueueTextures | None = None
 
-    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)
@@ -179,10 +162,10 @@ class GroundView:
         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._renderer is None:
-            self._draw_ui_text("Ground renderer not initialized.", 24, 24, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "Ground renderer not initialized.", 24, 24, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
         self._renderer.draw(self._camera_x, self._camera_y)
         self._draw_quest_title_overlay()