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

crimson/sim/world_state.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 import math
+from typing import Callable
 
 from ..bonuses import BonusId
 from ..creatures.damage import creature_apply_damage
@@ -35,6 +36,107 @@ class WorldEvents:
     sfx: list[str]
 
 
+@dataclass(slots=True)
+class _WorldDtCtx:
+    dt: float
+    players: list[PlayerState]
+
+
+_WorldDtStep = Callable[[_WorldDtCtx], None]
+
+
+def _world_dt_reflex_boosted(ctx: _WorldDtCtx) -> None:
+    if ctx.dt > 0.0 and ctx.players and perk_active(ctx.players[0], PerkId.REFLEX_BOOSTED):
+        ctx.dt *= 0.9
+
+
+_WORLD_DT_STEPS: tuple[_WorldDtStep, ...] = (_world_dt_reflex_boosted,)
+
+
+@dataclass(slots=True)
+class _PlayerDeathCtx:
+    state: GameplayState
+    creatures: CreaturePool
+    players: list[PlayerState]
+    player_index: int
+    player: PlayerState
+    dt: float
+    world_size: float
+    detail_preset: int
+    fx_queue: FxQueue
+    deaths: list[object]
+
+
+_PlayerDeathHook = Callable[[_PlayerDeathCtx], None]
+
+
+def _player_death_final_revenge(ctx: _PlayerDeathCtx) -> None:
+    player = ctx.player
+    if not perk_active(player, PerkId.FINAL_REVENGE):
+        return
+
+    px = float(player.pos_x)
+    py = float(player.pos_y)
+    rand = ctx.state.rng.rand
+    ctx.state.effects.spawn_explosion_burst(
+        pos_x=px,
+        pos_y=py,
+        scale=1.8,
+        rand=rand,
+        detail_preset=int(ctx.detail_preset),
+    )
+
+    prev_guard = bool(ctx.state.bonus_spawn_guard)
+    ctx.state.bonus_spawn_guard = True
+    for creature_idx, creature in enumerate(ctx.creatures.entries):
+        if not creature.active:
+            continue
+        if float(creature.hp) <= 0.0:
+            continue
+
+        dx = float(creature.x) - px
+        dy = float(creature.y) - py
+        if abs(dx) > 512.0 or abs(dy) > 512.0:
+            continue
+
+        remaining = 512.0 - math.hypot(dx, dy)
+        if remaining <= 0.0:
+            continue
+
+        damage = remaining * 5.0
+        death_start_needed = float(creature.hp) > 0.0 and float(creature.hitbox_size) == CREATURE_HITBOX_ALIVE
+        killed = creature_apply_damage(
+            creature,
+            damage_amount=damage,
+            damage_type=3,
+            impulse_x=0.0,
+            impulse_y=0.0,
+            owner_id=-1 - int(player.index),
+            dt=float(ctx.dt),
+            players=ctx.players,
+            rand=rand,
+        )
+        if killed and death_start_needed:
+            ctx.deaths.append(
+                ctx.creatures.handle_death(
+                    int(creature_idx),
+                    state=ctx.state,
+                    players=ctx.players,
+                    rand=rand,
+                    detail_preset=int(ctx.detail_preset),
+                    world_width=float(ctx.world_size),
+                    world_height=float(ctx.world_size),
+                    fx_queue=ctx.fx_queue,
+                )
+            )
+    ctx.state.bonus_spawn_guard = prev_guard
+    ctx.state.sfx_queue.append("sfx_explosion_large")
+    ctx.state.sfx_queue.append("sfx_shockwave")
+
+
+_PLAYER_DEATH_HOOKS: tuple[_PlayerDeathHook, ...] = (_player_death_final_revenge,)
+
+
 @dataclass(slots=True)
 class WorldState:
     spawn_env: SpawnEnv
@@ -84,9 +186,10 @@ class WorldState:
         game_mode: int,
         perk_progression_enabled: bool,
     ) -> WorldEvents:
-        dt = float(dt)
-        if dt > 0.0 and self.players and perk_active(self.players[0], PerkId.REFLEX_BOOSTED):
-            dt *= 0.9
+        dt_ctx = _WorldDtCtx(dt=float(dt), players=self.players)
+        for step in _WORLD_DT_STEPS:
+            step(dt_ctx)
+        dt = float(dt_ctx.dt)
 
         if inputs is None:
             inputs = [PlayerInput() for _ in self.players]
@@ -194,66 +297,20 @@ class WorldState:
                 continue
             if float(player.health) >= 0.0:
                 continue
-            if not perk_active(player, PerkId.FINAL_REVENGE):
-                continue
-
-            px = float(player.pos_x)
-            py = float(player.pos_y)
-            rand = self.state.rng.rand
-            self.state.effects.spawn_explosion_burst(
-                pos_x=px,
-                pos_y=py,
-                scale=1.8,
-                rand=rand,
+            death_ctx = _PlayerDeathCtx(
+                state=self.state,
+                creatures=self.creatures,
+                players=self.players,
+                player_index=int(idx),
+                player=player,
+                dt=float(dt),
+                world_size=float(world_size),
                 detail_preset=int(detail_preset),
+                fx_queue=fx_queue,
+                deaths=deaths,
             )
-
-            prev_guard = bool(self.state.bonus_spawn_guard)
-            self.state.bonus_spawn_guard = True
-            for creature_idx, creature in enumerate(self.creatures.entries):
-                if not creature.active:
-                    continue
-                if float(creature.hp) <= 0.0:
-                    continue
-
-                dx = float(creature.x) - px
-                dy = float(creature.y) - py
-                if abs(dx) > 512.0 or abs(dy) > 512.0:
-                    continue
-
-                remaining = 512.0 - math.hypot(dx, dy)
-                if remaining <= 0.0:
-                    continue
-
-                damage = remaining * 5.0
-                death_start_needed = float(creature.hp) > 0.0 and float(creature.hitbox_size) == CREATURE_HITBOX_ALIVE
-                killed = creature_apply_damage(
-                    creature,
-                    damage_amount=damage,
-                    damage_type=3,
-                    impulse_x=0.0,
-                    impulse_y=0.0,
-                    owner_id=-1 - int(player.index),
-                    dt=float(dt),
-                    players=self.players,
-                    rand=rand,
-                )
-                if killed and death_start_needed:
-                    deaths.append(
-                        self.creatures.handle_death(
-                            int(creature_idx),
-                            state=self.state,
-                            players=self.players,
-                            rand=rand,
-                            detail_preset=int(detail_preset),
-                            world_width=float(world_size),
-                            world_height=float(world_size),
-                            fx_queue=fx_queue,
-                        )
-                    )
-            self.state.bonus_spawn_guard = prev_guard
-            self.state.sfx_queue.append("sfx_explosion_large")
-            self.state.sfx_queue.append("sfx_shockwave")
+            for hook in _PLAYER_DEATH_HOOKS:
+                hook(death_ctx)
 
         def _kill_creature_no_corpse(creature_index: int, owner_id: int) -> None:
             idx = int(creature_index)

crimson/typo/spawns.py

@@ -3,16 +3,9 @@ from __future__ import annotations
 from dataclasses import dataclass
 import math
 
-from ..creatures.spawn import CreatureTypeId
-
-
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
+from grim.math import clamp
 
+from ..creatures.spawn import CreatureTypeId
 
 @dataclass(frozen=True, slots=True)
 class TypoSpawnCall:
@@ -47,9 +40,9 @@ def tick_typo_spawns(
         y = math.cos(t) * 256.0 + float(world_height) * 0.5
 
         tint_t = float(elapsed_ms + 1)
-        tint_r = _clamp(tint_t * 0.0000083333334 + 0.3, 0.0, 1.0)
-        tint_g = _clamp(tint_t * 10000.0 + 0.3, 0.0, 1.0)
-        tint_b = _clamp(math.sin(tint_t * 0.0001) + 0.3, 0.0, 1.0)
+        tint_r = clamp(tint_t * 0.0000083333334 + 0.3, 0.0, 1.0)
+        tint_g = clamp(tint_t * 10000.0 + 0.3, 0.0, 1.0)
+        tint_b = clamp(math.sin(tint_t * 0.0001) + 0.3, 0.0, 1.0)
         tint = (tint_r, tint_g, tint_b, 1.0)
 
         spawns.append(

crimson/ui/demo_trial_overlay.py

@@ -6,6 +6,7 @@ import pyray as rl
 
 from grim.assets import PaqTextureCache
 from grim.fonts.small import SmallFontData, draw_small_text, load_small_font, measure_small_text_width
+from grim.math import clamp
 
 from ..demo_trial import DemoTrialOverlayInfo
 from .perk_menu import (
@@ -20,15 +21,6 @@ from .perk_menu import (
 
 DEMO_PURCHASE_URL = "http://buy.crimsonland.com"
 
-
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 class DemoTrialOverlayUi:
     def __init__(self, assets_root: Path) -> None:
         self._assets_root = assets_root
@@ -94,8 +86,8 @@ class DemoTrialOverlayUi:
         mouse = rl.get_mouse_position()
         screen_w = float(rl.get_screen_width())
         screen_h = float(rl.get_screen_height())
-        mouse.x = _clamp(float(mouse.x), 0.0, max(0.0, screen_w - 1.0))
-        mouse.y = _clamp(float(mouse.y), 0.0, max(0.0, screen_h - 1.0))
+        mouse.x = clamp(float(mouse.x), 0.0, max(0.0, screen_w - 1.0))
+        mouse.y = clamp(float(mouse.y), 0.0, max(0.0, screen_h - 1.0))
 
         click = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
         panel_x, panel_y = self._panel_xy(screen_w=screen_w, screen_h=screen_h)

crimson/ui/formatting.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+
+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}"
+

crimson/ui/game_over.py

@@ -8,6 +8,7 @@ from pathlib import Path
 import pyray as rl
 
 from grim.assets import TextureLoader
+from grim.config import CrimsonConfig
 from grim.fonts.small import SmallFontData, draw_small_text, load_small_font, measure_small_text_width
 
 from ..persistence.highscores import (
@@ -20,7 +21,9 @@ from ..persistence.highscores import (
     upsert_highscore_record,
 )
 from ..weapons import WEAPON_BY_ID
+from .formatting import format_ordinal, format_time_mm_ss
 from .hud import HudAssets
+from .layout import ui_origin, ui_scale
 from .perk_menu import (
     PerkMenuAssets,
     UiButtonState,
@@ -32,20 +35,7 @@ from .perk_menu import (
     load_perk_menu_assets,
 )
 from .shadow import UI_SHADOW_OFFSET, draw_ui_quad_shadow
-
-
-UI_BASE_WIDTH = 640.0
-UI_BASE_HEIGHT = 480.0
-
-
-def ui_scale(screen_w: float, screen_h: float) -> float:
-    # Matches the classic UI-space helpers we use elsewhere: render in 640x480 pixel space.
-    return 1.0
-
-
-def ui_origin(screen_w: float, screen_h: float, scale: float) -> tuple[float, float]:
-    return 0.0, 0.0
-
+from .text_input import poll_text_input
 
 GAME_OVER_PANEL_X = -45.0
 GAME_OVER_PANEL_Y = 210.0
@@ -69,28 +59,6 @@ COLOR_SCORE_LABEL = rl.Color(230, 230, 230, 255)
 COLOR_SCORE_VALUE = rl.Color(230, 230, 255, 255)
 
 
-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}"
-
-
 def _weapon_icon_src(texture: rl.Texture, weapon_id_native: int) -> rl.Rectangle | None:
     weapon_id = int(weapon_id_native)
     entry = WEAPON_BY_ID.get(int(weapon_id))
@@ -143,22 +111,6 @@ def _draw_texture_centered(tex: rl.Texture, x: float, y: float, w: float, h: flo
     rl.draw_texture_pro(tex, src, dst, rl.Vector2(0.0, 0.0), 0.0, tint)
 
 
-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 _ease_out_cubic(t: float) -> float:
     t = max(0.0, min(1.0, float(t)))
     return 1.0 - (1.0 - t) ** 3
@@ -169,7 +121,7 @@ class GameOverUi:
     assets_root: Path
     base_dir: Path
 
-    config: object  # CrimsonConfig-like
+    config: CrimsonConfig
 
     assets: GameOverAssets | None = None
     font: SmallFontData | None = None
@@ -309,7 +261,7 @@ class GameOverUi:
             rl.is_key_pressed(rl.KeyboardKey.KEY_ENTER)
         if self.phase == -1:
             # If in the top 100, prompt for a name. Otherwise show score-too-low message and buttons.
-            game_mode_id = int(getattr(self.config, "data", {}).get("game_mode", 1))
+            game_mode_id = int(self.config.data.get("game_mode", 1))
             candidate = record.copy()
             candidate.game_mode_id = game_mode_id
             self._candidate_record = candidate
@@ -328,7 +280,7 @@ class GameOverUi:
         # Basic text input behavior for the name-entry phase.
         if self.phase == 0:
             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))
@@ -369,6 +321,8 @@ class GameOverUi:
                         play_sfx("sfx_ui_typeenter")
                     candidate = (self._candidate_record or record).copy()
                     candidate.set_name(self.input_text)
+                    self.config.set_player_name(self.input_text)
+                    self.config.save()
                     path = scores_path_for_config(self.base_dir, self.config)
                     if not self._saved:
                         upsert_highscore_record(path, candidate)
@@ -449,7 +403,7 @@ class GameOverUi:
         score_value_w = self._text_width(score_value, 1.0 * scale)
         self._draw_small(score_value, base_x + 32.0 * scale - score_value_w * 0.5, base_y + 15.0 * scale, 1.0 * scale, value_color)
 
-        rank_value = _format_ordinal(int(self.rank) + 1)
+        rank_value = format_ordinal(int(self.rank) + 1)
         rank_text = f"Rank: {rank_value}"
         rank_w = self._text_width(rank_text, 1.0 * scale)
         self._draw_small(rank_text, base_x + 32.0 * scale - rank_w * 0.5, base_y + 30.0 * scale, 1.0 * scale, label_color)
@@ -487,7 +441,7 @@ class GameOverUi:
                 origin = rl.Vector2(16.0 * scale, 16.0 * scale)
                 rl.draw_texture_pro(hud_assets.clock_pointer, src, dst, origin, rotation, rl.Color(255, 255, 255, int(255 * alpha)))
 
-            time_text = _format_time_mm_ss(elapsed_ms)
+            time_text = format_time_mm_ss(elapsed_ms)
             self._draw_small(time_text, col2_x + 40.0 * scale, base_y + 19.0 * scale, 1.0 * scale, label_color)
 
         # Second row: weapon icon + frags + hit ratio (suppressed while entering the name).
@@ -572,7 +526,7 @@ class GameOverUi:
             panel_tex = self.assets.menu_panel
             src = rl.Rectangle(0.0, 0.0, float(panel_tex.width), float(panel_tex.height))
             dst = rl.Rectangle(panel.x, panel.y, panel.width, panel.height)
-            fx_detail = bool(int(getattr(self.config, "data", {}).get("fx_detail_0", 0) or 0))
+            fx_detail = bool(int(self.config.data.get("fx_detail_0", 0) or 0))
             if fx_detail:
                 draw_ui_quad_shadow(
                     texture=panel_tex,

crimson/ui/hud.py

@@ -56,8 +56,6 @@ HUD_BONUS_PANEL_OFFSET_Y = -11.0
 HUD_XP_BAR_RGBA = (0.1, 0.3, 0.6, 1.0)
 HUD_QUEST_LEFT_Y_SHIFT = 80.0
 
-_SURVIVAL_XP_SMOOTHED = 0
-
 
 @dataclass(slots=True)
 class HudAssets:
@@ -85,6 +83,46 @@ class HudRenderFlags:
     show_quest_hud: bool
 
 
+@dataclass(slots=True)
+class HudState:
+    survival_xp_smoothed: int = 0
+
+    def smooth_xp(self, target: int, frame_dt_ms: float) -> int:
+        target = int(target)
+        if target <= 0:
+            self.survival_xp_smoothed = 0
+            return 0
+
+        smoothed = int(self.survival_xp_smoothed)
+        if smoothed == target:
+            return smoothed
+
+        step = max(1, int(frame_dt_ms) // 2)
+        diff = abs(smoothed - target)
+        if diff > 1000:
+            step *= diff // 100
+
+        if smoothed < target:
+            smoothed += step
+            if smoothed > target:
+                smoothed = target
+        else:
+            smoothed -= step
+            if smoothed < target:
+                smoothed = target
+
+        self.survival_xp_smoothed = smoothed
+        return smoothed
+
+
+@dataclass(frozen=True, slots=True)
+class HudLayout:
+    scale: float
+    text_scale: float
+    line_h: float
+    hud_y_shift: float
+
+
 def hud_flags_for_game_mode(game_mode_id: int) -> HudRenderFlags:
     """Match `hud_update_and_render` (0x0041ca90) flag mapping."""
 
@@ -139,6 +177,14 @@ def hud_ui_scale(screen_w: float, screen_h: float) -> float:
     return float(scale)
 
 
+def hud_layout(screen_w: float, screen_h: float, *, font: SmallFontData | None, show_quest_hud: bool) -> HudLayout:
+    scale = hud_ui_scale(float(screen_w), float(screen_h))
+    text_scale = 1.0 * scale
+    line_h = float(font.cell_size) * text_scale if font is not None else 18.0 * text_scale
+    hud_y_shift = HUD_QUEST_LEFT_Y_SHIFT if show_quest_hud else 0.0
+    return HudLayout(scale=scale, text_scale=text_scale, line_h=line_h, hud_y_shift=hud_y_shift)
+
+
 def load_hud_assets(assets_root: Path) -> HudAssets:
     loader = TextureLoader.from_assets_root(assets_root)
     return HudAssets(
@@ -178,29 +224,20 @@ def _with_alpha(color: rl.Color, alpha: float) -> rl.Color:
     return rl.Color(color.r, color.g, color.b, int(color.a * alpha))
 
 
-def _smooth_xp(target: int, frame_dt_ms: float) -> int:
-    global _SURVIVAL_XP_SMOOTHED
-    target = int(target)
-    if target <= 0:
-        _SURVIVAL_XP_SMOOTHED = 0
-        return 0
-    smoothed = int(_SURVIVAL_XP_SMOOTHED)
-    if smoothed == target:
-        return smoothed
-    step = max(1, int(frame_dt_ms) // 2)
-    diff = abs(smoothed - target)
-    if diff > 1000:
-        step *= diff // 100
-    if smoothed < target:
-        smoothed += step
-        if smoothed > target:
-            smoothed = target
-    else:
-        smoothed -= step
-        if smoothed < target:
-            smoothed = target
-    _SURVIVAL_XP_SMOOTHED = smoothed
-    return smoothed
+def _quest_panel_slide_x(time_ms: float) -> float:
+    time_ms = float(time_ms)
+    if time_ms < 1000.0:
+        return (1000.0 - time_ms) * -0.128
+    return 0.0
+
+
+def _survival_xp_progress_ratio(*, xp: int, level: int) -> float:
+    level = max(1, int(level))
+    prev_threshold = 0 if level <= 1 else survival_level_threshold(level - 1)
+    next_threshold = survival_level_threshold(level)
+    if next_threshold <= prev_threshold:
+        return 0.0
+    return (int(xp) - prev_threshold) / float(next_threshold - prev_threshold)
 
 
 def _draw_progress_bar(x: float, y: float, width: float, ratio: float, rgba: tuple[float, float, float, float], scale: float) -> None:
@@ -275,6 +312,7 @@ def _bonus_icon_src(texture: rl.Texture, icon_id: int) -> rl.Rectangle:
 def draw_hud_overlay(
     assets: HudAssets,
     *,
+    state: HudState,
     player: PlayerState,
     players: list[PlayerState] | None = None,
     bonus_hud: BonusHudState | None = None,
@@ -293,6 +331,7 @@ def draw_hud_overlay(
 ) -> float:
     if frame_dt_ms is None:
         frame_dt_ms = max(0.0, float(rl.get_frame_time()) * 1000.0)
+    state = state or HudState()
     hud_players = list(players) if players is not None else [player]
     if not hud_players:
         hud_players = [player]
@@ -300,9 +339,10 @@ def draw_hud_overlay(
 
     screen_w = float(rl.get_screen_width())
     screen_h = float(rl.get_screen_height())
-    scale = hud_ui_scale(screen_w, screen_h)
-    text_scale = 1.0 * scale
-    line_h = float(font.cell_size) * text_scale if font is not None else 18.0 * text_scale
+    layout = hud_layout(screen_w, screen_h, font=font, show_quest_hud=show_quest_hud)
+    scale = layout.scale
+    text_scale = layout.text_scale
+    line_h = layout.line_h
 
     def sx(value: float) -> float:
         return value * scale
@@ -314,7 +354,7 @@ def draw_hud_overlay(
     alpha = max(0.0, min(1.0, float(alpha)))
     text_color = _with_alpha(HUD_TEXT_COLOR, alpha)
     panel_text_color = _with_alpha(HUD_TEXT_COLOR, alpha * HUD_PANEL_ALPHA)
-    hud_y_shift = HUD_QUEST_LEFT_Y_SHIFT if show_quest_hud else 0.0
+    hud_y_shift = layout.hud_y_shift
 
     # Top bar background.
     if assets.game_top is not None:
@@ -502,9 +542,7 @@ def draw_hud_overlay(
     # Quest HUD panels (mm:ss timer + progress).
     if show_quest_hud:
         time_ms = max(0.0, float(elapsed_ms))
-        slide_x = 0.0
-        if time_ms < 1000.0:
-            slide_x = (1000.0 - time_ms) * -0.128
+        slide_x = _quest_panel_slide_x(time_ms)
 
         quest_panel_alpha = alpha * 0.7
         quest_text_color = _with_alpha(HUD_TEXT_COLOR, quest_panel_alpha)
@@ -580,7 +618,7 @@ def draw_hud_overlay(
 
     # Survival XP panel.
     xp_target = int(player.experience if score is None else score)
-    xp_display = _smooth_xp(xp_target, frame_dt_ms) if show_xp else xp_target
+    xp_display = state.smooth_xp(xp_target, frame_dt_ms) if show_xp else xp_target
     if show_xp and assets.ind_panel is not None:
         panel_x, panel_y = HUD_SURV_PANEL_POS
         panel_y += hud_y_shift
@@ -623,12 +661,7 @@ def draw_hud_overlay(
             panel_text_color,
         )
 
-        level = max(1, int(player.level))
-        prev_threshold = 0 if level <= 1 else survival_level_threshold(level - 1)
-        next_threshold = survival_level_threshold(level)
-        progress_ratio = 0.0
-        if next_threshold > prev_threshold:
-            progress_ratio = (xp_target - prev_threshold) / float(next_threshold - prev_threshold)
+        progress_ratio = _survival_xp_progress_ratio(xp=xp_target, level=int(player.level))
         bar_x, bar_y = HUD_SURV_PROGRESS_POS
         bar_y += hud_y_shift
         bar_w = HUD_SURV_PROGRESS_WIDTH

crimson/ui/layout.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+
+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
+