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

crimson/views/player_sprite_debug.py

@@ -7,8 +7,9 @@ from pathlib import Path
 import pyray as rl
 
 from grim.assets import resolve_asset_path
-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 ._ui_helpers import draw_ui_text, ui_line_height
 from .registry import register_view
 
 
@@ -54,24 +55,6 @@ class PlayerSpriteDebugView:
         self._show_shadow = True
         self._use_torso_offset = True
 
-    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 _frame_src(self, texture: rl.Texture, frame_index: int) -> rl.Rectangle:
         cell = float(texture.width) / float(SPRITE_GRID)
         pad = SPRITE_PAD_PX
@@ -204,7 +187,7 @@ class PlayerSpriteDebugView:
     def draw(self) -> None:
         rl.clear_background(rl.Color(10, 10, 12, 255))
         if self._assets is None:
-            self._draw_ui_text("Trooper sprite not loaded.", 16, 16, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "Trooper sprite not loaded.", 16, 16, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
 
         cam_x = float(rl.get_screen_width()) * 0.5 - self._player_x
@@ -271,41 +254,51 @@ class PlayerSpriteDebugView:
 
         hud_x = 16.0
         hud_y = 16.0
-        line = self._ui_line_height()
-        self._draw_ui_text(
+        line = ui_line_height(self._small, scale=UI_TEXT_SCALE)
+        draw_ui_text(
+            self._small,
             f"legs frame={leg_frame} (base {self._leg_base}, count {self._frame_count})",
             hud_x,
             hud_y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         hud_y += line
         torso_label = "offset" if self._use_torso_offset else "match"
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"torso frame={torso_frame} (base {self._torso_base}, mode {torso_label})",
             hud_x,
             hud_y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         hud_y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"move_heading={self._move_heading:.2f}  aim_heading={self._aim_heading:.2f}",
             hud_x,
             hud_y,
-            UI_TEXT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_TEXT_COLOR,
         )
         hud_y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             "WASD move, mouse aim, LMB recoil, F1 grid, F2 shadow, F3 torso mode",
             hud_x,
             hud_y,
-            UI_HINT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
         )
         hud_y += line
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             "[/] torso base, ;/' legs base, ,/. frame count, R reset",
             hud_x,
             hud_y,
-            UI_HINT_COLOR,
+            scale=UI_TEXT_SCALE,
+            color=UI_HINT_COLOR,
         )
 
 

crimson/views/projectile_fx.py

@@ -5,8 +5,8 @@ import math
 
 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
@@ -18,6 +18,8 @@ from ..weapons import (
     WEAPON_TABLE,
     weapon_entry_for_projectile_type_id,
 )
+from ._ui_helpers import draw_ui_text, ui_line_height
+from .registry import register_view
 
 WORLD_SIZE = 1024.0
 
@@ -34,7 +36,7 @@ class DummyCreature:
     y: float
     hp: float
     size: float = 42.0
-    collision_flag: int = 0
+    plague_infected: bool = False
 
 
 @dataclass(slots=True)
@@ -81,14 +83,6 @@ _BEAM_TYPES = frozenset(
 )
 
 
-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
 
@@ -134,24 +128,6 @@ class ProjectileFxView:
         self._beams: list[BeamFx] = []
         self._effects: list[EffectFx] = []
 
-    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 _camera_world_to_screen(self, x: float, y: float) -> tuple[float, float]:
         return self._camera_x + x, self._camera_y + y
 
@@ -180,7 +156,7 @@ class ProjectileFxView:
         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)
 
@@ -319,8 +295,8 @@ class ProjectileFxView:
         angle = _angle_to_target(self._origin_x, self._origin_y, aim_x, aim_y)
 
         if rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_RIGHT):
-            self._origin_x = _clamp(aim_x, 0.0, WORLD_SIZE)
-            self._origin_y = _clamp(aim_y, 0.0, WORLD_SIZE)
+            self._origin_x = clamp(aim_x, 0.0, WORLD_SIZE)
+            self._origin_y = clamp(aim_y, 0.0, WORLD_SIZE)
 
         if rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
             self._spawn_projectile(type_id=self._selected_type_id(), angle=angle, owner_id=-1)
@@ -467,7 +443,7 @@ class ProjectileFxView:
                     )
                 return
 
-        alpha = int(_clamp(life / 0.4, 0.0, 1.0) * 255)
+        alpha = int(clamp(life / 0.4, 0.0, 1.0) * 255)
         tint = rl.Color(color.r, color.g, color.b, alpha)
         self._draw_atlas_sprite(texture, grid=grid, frame=frame, x=sx, y=sy, scale=0.6, rotation_rad=angle, tint=tint)
 
@@ -475,7 +451,7 @@ class ProjectileFxView:
         rl.clear_background(rl.Color(10, 10, 12, 255))
         if self._missing_assets and self._projs is None:
             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.
@@ -491,7 +467,11 @@ class ProjectileFxView:
         # Creatures.
         for creature in self._creatures:
             cx, cy = self._camera_world_to_screen(creature.x, creature.y)
-            color = rl.Color(220, 90, 90, 255) if creature.collision_flag == 0 else rl.Color(240, 180, 90, 255)
+            color = (
+                rl.Color(220, 90, 90, 255)
+                if not creature.plague_infected
+                else rl.Color(240, 180, 90, 255)
+            )
             rl.draw_circle(int(cx), int(cy), float(creature.size * 0.5), color)
             rl.draw_circle_lines(int(cx), int(cy), float(creature.size * 0.5), rl.Color(40, 40, 55, 255))
 
@@ -517,7 +497,7 @@ class ProjectileFxView:
 
         # Beam flashes from hit events.
         for beam in self._beams:
-            t = _clamp(beam.life / 0.08, 0.0, 1.0)
+            t = clamp(beam.life / 0.08, 0.0, 1.0)
             alpha = int(200 * t)
             x0s, y0s = self._camera_world_to_screen(beam.x0, beam.y0)
             x1s, y1s = self._camera_world_to_screen(beam.x1, beam.y1)
@@ -539,10 +519,10 @@ class ProjectileFxView:
                 if src is None:
                     continue
                 life = max(0.0, fx.life)
-                alpha = int(_clamp(life / 0.35, 0.0, 1.0) * 220)
+                alpha = int(clamp(life / 0.35, 0.0, 1.0) * 220)
                 tint = rl.Color(255, 255, 255, alpha)
                 sx, sy = self._camera_world_to_screen(fx.x, fx.y)
-                dst_scale = fx.scale * (1.0 + (0.7 - _clamp(life, 0.0, 0.7)) * 0.6)
+                dst_scale = fx.scale * (1.0 + (0.7 - clamp(life, 0.0, 0.7)) * 0.6)
                 dst = rl.Rectangle(float(sx), float(sy), src[2] * dst_scale, src[3] * dst_scale)
                 origin = rl.Vector2(dst.width * 0.5, dst.height * 0.5)
                 rl.draw_texture_pro(
@@ -562,46 +542,71 @@ class ProjectileFxView:
         margin = 18
         x = float(margin)
         y = float(margin)
-        line = self._ui_line_height()
+        line = ui_line_height(self._small, scale=UI_TEXT_SCALE)
 
         type_id = self._selected_type_id()
         weapon = WEAPON_BY_ID.get(int(type_id))
         label = weapon.name if weapon is not None and weapon.name else f"type_{type_id}"
-        self._draw_ui_text(f"{label} (type_id {type_id} / 0x{type_id:02x})", x, y, UI_TEXT_COLOR)
+        draw_ui_text(
+            self._small, f"{label} (type_id {type_id} / 0x{type_id:02x})", x, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR
+        )
         y += line + 4
 
         if self._show_debug:
             meta = self._projectile_meta_for(type_id)
             dmg = self._damage_scale_by_type.get(type_id, 1.0)
             pellets = int(weapon.pellet_count) if weapon is not None and weapon.pellet_count is not None else 1
-            self._draw_ui_text(f"meta {meta:.1f}  dmg_scale {dmg:.2f}  pellet_count {pellets}", x, y, UI_HINT_COLOR)
+            draw_ui_text(
+                self._small,
+                f"meta {meta:.1f}  dmg_scale {dmg:.2f}  pellet_count {pellets}",
+                x,
+                y,
+                scale=UI_TEXT_SCALE,
+                color=UI_HINT_COLOR,
+            )
             y += line + 4
-            self._draw_ui_text(
+            draw_ui_text(
+                self._small,
                 f"shock_chain links {self._state.shock_chain_links_left}  proj {self._state.shock_chain_projectile_id}",
                 x,
                 y,
-                UI_HINT_COLOR,
+                scale=UI_TEXT_SCALE,
+                color=UI_HINT_COLOR,
             )
             y += line + 8
 
         if self._show_help:
-            self._draw_ui_text("controls:", x, y, UI_ACCENT_COLOR)
+            draw_ui_text(self._small, "controls:", x, y, scale=UI_TEXT_SCALE, color=UI_ACCENT_COLOR)
             y += line + 2
-            self._draw_ui_text("- left/right: select projectile type", x, y, UI_HINT_COLOR)
+            draw_ui_text(self._small, "- left/right: select projectile type", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line + 2
-            self._draw_ui_text("- mouse wheel: select type", x, y, UI_HINT_COLOR)
+            draw_ui_text(self._small, "- mouse wheel: select type", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line + 2
-            self._draw_ui_text("- LMB: spawn projectile toward mouse", x, y, UI_HINT_COLOR)
+            draw_ui_text(self._small, "- LMB: spawn projectile toward mouse", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line + 2
-            self._draw_ui_text("- RMB: move spawn origin", x, y, UI_HINT_COLOR)
+            draw_ui_text(self._small, "- RMB: move spawn origin", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line + 2
-            self._draw_ui_text("- space: spawn ring", x, y, UI_HINT_COLOR)
+            draw_ui_text(self._small, "- space: spawn ring", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line + 2
-            self._draw_ui_text("- F: fire-bullets volley (uses pellet_count)", x, y, UI_HINT_COLOR)
+            draw_ui_text(
+                self._small,
+                "- F: fire-bullets volley (uses pellet_count)",
+                x,
+                y,
+                scale=UI_TEXT_SCALE,
+                color=UI_HINT_COLOR,
+            )
             y += line + 2
-            self._draw_ui_text("- S: apply Shock Chain bonus", x, y, UI_HINT_COLOR)
+            draw_ui_text(self._small, "- S: apply Shock Chain bonus", x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line + 2
-            self._draw_ui_text("- R: reset  Tab: pause  H: hide help  F3: toggle debug", x, y, UI_HINT_COLOR, scale=0.9)
+            draw_ui_text(
+                self._small,
+                "- R: reset  Tab: pause  H: hide help  F3: toggle debug",
+                x,
+                y,
+                scale=0.9,
+                color=UI_HINT_COLOR,
+            )
 
 
 @register_view("projectile_fx", "Projectile FX lab")

crimson/views/projectile_render_debug.py

@@ -7,13 +7,15 @@ import random
 import pyray as rl
 
 from grim.audio import AudioState, shutdown_audio
-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 ..game_world import GameWorld
 from ..gameplay import PlayerInput, player_update, weapon_assign_player
 from ..ui.cursor import draw_aim_cursor
 from ..weapons import WEAPON_TABLE
+from ._ui_helpers import draw_ui_text, ui_line_height
 from .audio_bootstrap import init_view_audio
 from .registry import register_view
 
@@ -39,14 +41,6 @@ class TargetDummy:
     size: float = 56.0
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 class ProjectileRenderDebugView:
     def __init__(self, ctx: ViewContext) -> None:
         self._assets_root = ctx.assets_dir
@@ -75,17 +69,6 @@ class ProjectileRenderDebugView:
         self._paused = False
         self._screenshot_requested = False
 
-    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
@@ -103,8 +86,8 @@ class ProjectileRenderDebugView:
         ring = 260.0
         for idx in range(10):
             angle = float(idx) / 10.0 * math.tau
-            x = _clamp(base_x + math.cos(angle) * ring, 40.0, WORLD_SIZE - 40.0)
-            y = _clamp(base_y + math.sin(angle) * ring, 40.0, WORLD_SIZE - 40.0)
+            x = clamp(base_x + math.cos(angle) * ring, 40.0, WORLD_SIZE - 40.0)
+            y = clamp(base_y + math.sin(angle) * ring, 40.0, WORLD_SIZE - 40.0)
             self._targets.append(TargetDummy(x=x, y=y, hp=260.0, size=64.0))
 
     def _reset_scene(self) -> None:
@@ -301,16 +284,17 @@ class ProjectileRenderDebugView:
 
         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
 
@@ -363,26 +347,33 @@ class ProjectileRenderDebugView:
         # UI.
         x = 16.0
         y = 12.0
-        line = float(self._ui_line_height())
+        line = float(ui_line_height(self._small))
 
         weapon_id = int(player.weapon_id) if player is not None else 0
         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("Projectile render debug", x, y, UI_TEXT)
+        draw_ui_text(self._small, "Projectile render debug", x, y, color=UI_TEXT)
         y += line
-        self._draw_ui_text(f"{weapon_name} (weapon_id={weapon_id})", x, y, UI_TEXT)
+        draw_ui_text(self._small, f"{weapon_name} (weapon_id={weapon_id})", x, y, color=UI_TEXT)
         y += line
         if player is not None:
-            self._draw_ui_text(
+            draw_ui_text(
+                self._small,
                 f"ammo {player.ammo}/{player.clip_size}  reload {player.reload_timer:.2f}/{player.reload_timer_max:.2f}",
                 x,
                 y,
-                UI_TEXT,
+                color=UI_TEXT,
             )
             y += line
         y += 6.0
-        self._draw_ui_text("WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  P screenshot", x, y, UI_HINT)
+        draw_ui_text(
+            self._small,
+            "WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  P screenshot",
+            x,
+            y,
+            color=UI_HINT,
+        )
         y += line
-        self._draw_ui_text("T reset targets  Backspace reset scene  Esc quit", x, y, UI_HINT)
+        draw_ui_text(self._small, "T reset targets  Backspace reset scene  Esc quit", 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))

crimson/views/projectiles.py

@@ -4,8 +4,9 @@ from dataclasses import dataclass
 
 import pyray as rl
 
+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
@@ -55,24 +56,6 @@ class ProjectileView:
         self._small: SmallFontData | None = None
         self._grid = 4
 
-    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)
@@ -105,10 +88,10 @@ class ProjectileView:
         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 projectile texture loaded.", 24, 24, UI_TEXT_COLOR)
+            draw_ui_text(self._small, "No projectile texture loaded.", 24, 24, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
             return
 
         self._handle_input()
@@ -179,41 +162,45 @@ class ProjectileView:
 
         info_x = x + draw_w + panel_gap
         info_y = margin
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"projs.png (grid {self._grid}x{self._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("2/4: grid  G: toggle", info_x, info_y, UI_HINT_COLOR)
-        info_y += self._ui_line_height() + 12
+        info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 6
+        draw_ui_text(self._small, "2/4: grid  G: toggle", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
+        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:
-                    self._draw_ui_text(
+                    draw_ui_text(
+                        self._small,
                         f"0x{entry.type_id:02x} {entry.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("Known frames", info_x, info_y, UI_TEXT_COLOR)
-        info_y += self._ui_line_height() + 6
+        draw_ui_text(self._small, "Known frames", 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 frame_index in sorted(known_frames.keys()):
             entries = known_frames[frame_index]
             labels = ", ".join(f"0x{entry.type_id:02x} {entry.label}" for entry in entries)
-            self._draw_ui_text(f"{frame_index:02d}: {labels}", info_x, info_y, UI_HINT_COLOR)
-            info_y += self._ui_line_height() + 4
+            draw_ui_text(self._small, f"{frame_index:02d}: {labels}", info_x, info_y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
+            info_y += ui_line_height(self._small, scale=UI_TEXT_SCALE) + 4
 
 
 @register_view("projectiles", "Projectile atlas preview")

crimson/views/spawn_plan.py

@@ -15,8 +15,9 @@ from ..creatures.spawn import (
     spawn_id_label,
     tick_spawn_slot,
 )
+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, measure_small_text_width
+from grim.fonts.small import SmallFontData, load_small_font, measure_small_text_width
 from grim.view import View, ViewContext
 
 
@@ -93,29 +94,11 @@ class SpawnPlanView:
             rl.unload_texture(self._small.texture)
             self._small = 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 _draw_ui_label(self, label: str, value: str, x: float, y: float) -> None:
         label_text = f"{label}: "
-        self._draw_ui_text(label_text, x, y, UI_HINT_COLOR)
+        draw_ui_text(self._small, label_text, x, y, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
         label_w = measure_small_text_width(self._small, label_text, UI_TEXT_SCALE) if self._small else 0.0
-        self._draw_ui_text(value, x + label_w, y, UI_TEXT_COLOR)
+        draw_ui_text(self._small, value, x + label_w, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
 
     def _rebuild_plan(self) -> None:
         spawn_id = self._template_ids[self._index]
@@ -261,18 +244,19 @@ class SpawnPlanView:
         self._draw_grid()
 
         margin = 16.0
-        line_h = float(self._ui_line_height())
+        line_h = float(ui_line_height(self._small, scale=UI_TEXT_SCALE))
 
         spawn_id = self._template_ids[self._index] if self._template_ids else 0
-        self._draw_ui_text(
+        draw_ui_text(
+            self._small,
             f"spawn-plan view  (template 0x{spawn_id:02x})",
             margin,
             margin,
-            UI_TEXT_COLOR,
             scale=0.8,
+            color=UI_TEXT_COLOR,
         )
         hints = "Left/Right: id  Up/Down: seed  R: random seed  [,]: scale  H: hardcore  D: demo-mode  ,/.: difficulty  Space: sim  Backspace: reset"
-        self._draw_ui_text(hints, margin, margin + line_h, UI_HINT_COLOR)
+        draw_ui_text(self._small, hints, margin, margin + line_h, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
 
         y = margin + line_h * 2.0 + 4.0
         self._draw_ui_label("seed", f"0x{self._seed:08x}", margin, y)
@@ -287,10 +271,10 @@ class SpawnPlanView:
         y += line_h
 
         if self._error is not None:
-            self._draw_ui_text(self._error, margin, y + 6.0, UI_ERROR_COLOR)
+            draw_ui_text(self._small, self._error, margin, y + 6.0, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
         if self._plan is None or self._plan_summary is None:
-            self._draw_ui_text("No plan.", margin, y + 6.0, UI_ERROR_COLOR)
+            draw_ui_text(self._small, "No plan.", margin, y + 6.0, scale=UI_TEXT_SCALE, color=UI_ERROR_COLOR)
             return
 
         summary = self._plan_summary
@@ -313,10 +297,10 @@ class SpawnPlanView:
             )
             y += line_h
         if self._sim_events:
-            self._draw_ui_text("events:", margin, y + 2.0, UI_HINT_COLOR)
+            draw_ui_text(self._small, "events:", margin, y + 2.0, scale=UI_TEXT_SCALE, color=UI_HINT_COLOR)
             y += line_h
             for ev in self._sim_events[-5:]:
-                self._draw_ui_text(ev, margin, y, UI_TEXT_COLOR)
+                draw_ui_text(self._small, ev, margin, y, scale=UI_TEXT_SCALE, color=UI_TEXT_COLOR)
                 y += line_h
 
         # Link lines.