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

crimson/modes/base_gameplay_mode.py

@@ -11,6 +11,7 @@ from grim.audio import AudioState, update_audio
 from grim.console import ConsoleState
 from grim.config import CrimsonConfig
 from grim.fonts.small import SmallFontData, draw_small_text, load_small_font, measure_small_text_width
+from grim.math import clamp
 from grim.view import ViewContext
 
 from ..gameplay import _creature_find_in_radius, perk_count_get
@@ -18,20 +19,12 @@ from ..game_world import GameWorld
 from ..persistence.highscores import HighScoreRecord
 from ..perks import PerkId
 from ..ui.game_over import GameOverUi
-from ..ui.hud import HudAssets, draw_target_health_bar, load_hud_assets
+from ..ui.hud import HudAssets, HudState, draw_target_health_bar, load_hud_assets
 
 if TYPE_CHECKING:
     from ..persistence.save_status import GameStatus
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 class _ScreenFade(Protocol):
     screen_fade_alpha: float
 
@@ -57,6 +50,7 @@ class BaseGameplayMode:
         self._hud_missing: list[str] = []
         self._small: SmallFontData | None = None
         self._hud_assets: HudAssets | None = None
+        self._hud_state = HudState()
 
         self._default_game_mode_id = int(default_game_mode_id)
         self._config = config
@@ -141,7 +135,7 @@ class BaseGameplayMode:
             return
         hp = float(getattr(creature, "hp", 0.0))
         max_hp = float(getattr(creature, "max_hp", 0.0))
-        if hp <= 0.0 or max_hp <= 0.0:
+        if max_hp <= 0.0:
             return
 
         ratio = hp / max_hp
@@ -208,8 +202,8 @@ class BaseGameplayMode:
         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 _tick_frame(self, dt: float, *, clamp_cursor_pulse: bool = False) -> tuple[float, float]:
         dt_frame = float(dt)
@@ -248,6 +242,7 @@ class BaseGameplayMode:
         self._hud_assets = load_hud_assets(self._assets_root)
         if self._hud_assets.missing:
             self._hud_missing = list(self._hud_assets.missing)
+        self._hud_state = HudState()
 
         self._game_over_active = False
         self._game_over_record = None
@@ -283,6 +278,32 @@ class BaseGameplayMode:
         self._action = None
         return action
 
+    def _update_game_over_ui(self, dt: float) -> None:
+        record = self._game_over_record
+        if record is None:
+            self._enter_game_over()
+            record = self._game_over_record
+        if record is None:
+            return
+
+        action = self._game_over_ui.update(
+            dt,
+            record=record,
+            player_name_default=self._player_name_default(),
+            play_sfx=self._world.audio_router.play_sfx,
+            rand=self._state.rng.rand,
+            mouse=self._ui_mouse_pos(),
+        )
+        if action == "play_again":
+            self.open()
+            return
+        if action == "high_scores":
+            self._action = "open_high_scores"
+            return
+        if action == "main_menu":
+            self._action = "back_to_menu"
+            self.close_requested = True
+
     def draw_pause_background(self) -> None:
         self._world.draw(draw_aim_indicators=False)
 

crimson/modes/components/__init__.py

@@ -0,0 +1,2 @@
+"""Reusable gameplay-mode controllers."""
+

crimson/modes/components/highscore_record_builder.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from ...gameplay import GameplayState, PlayerState, most_used_weapon_id_for_player
+from ...persistence.highscores import HighScoreRecord
+
+
+def clamp_shots(fired: int, hit: int) -> tuple[int, int]:
+    fired = max(0, int(fired))
+    hit = max(0, min(int(hit), fired))
+    return fired, hit
+
+
+def shots_from_state(state: GameplayState, *, player_index: int) -> tuple[int, int]:
+    fired = 0
+    hit = 0
+    try:
+        fired = int(state.shots_fired[int(player_index)])
+        hit = int(state.shots_hit[int(player_index)])
+    except Exception:
+        fired = 0
+        hit = 0
+    return clamp_shots(fired, hit)
+
+
+def build_highscore_record_for_game_over(
+    *,
+    state: GameplayState,
+    player: PlayerState,
+    survival_elapsed_ms: int,
+    creature_kill_count: int,
+    game_mode_id: int,
+    shots_fired: int | None = None,
+    shots_hit: int | None = None,
+    clamp_shots_hit: bool = True,
+) -> HighScoreRecord:
+    record = HighScoreRecord.blank()
+    record.score_xp = int(player.experience)
+    record.survival_elapsed_ms = int(survival_elapsed_ms)
+    record.creature_kill_count = int(creature_kill_count)
+
+    weapon_id = most_used_weapon_id_for_player(
+        state, player_index=int(player.index), fallback_weapon_id=int(player.weapon_id)
+    )
+    record.most_used_weapon_id = int(weapon_id)
+
+    if shots_fired is None or shots_hit is None:
+        fired, hit = shots_from_state(state, player_index=int(player.index))
+    else:
+        fired = int(shots_fired)
+        hit = int(shots_hit)
+        if clamp_shots_hit:
+            fired, hit = clamp_shots(fired, hit)
+
+    record.shots_fired = fired
+    record.shots_hit = hit
+    record.game_mode_id = int(game_mode_id)
+    return record
+

crimson/modes/components/perk_menu_controller.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Sequence
+
+import pyray as rl
+
+from grim.fonts.small import SmallFontData
+from grim.math import clamp
+
+from ...gameplay import GameplayState, PerkSelectionState, PlayerState, perk_selection_current_choices, perk_selection_pick
+from ...perks import PerkId, perk_display_description, perk_display_name
+from ...ui.menu_panel import draw_classic_menu_panel
+from ...ui.perk_menu import (
+    PERK_MENU_TRANSITION_MS,
+    PerkMenuAssets,
+    PerkMenuLayout,
+    UiButtonState,
+    button_draw,
+    button_update,
+    button_width,
+    draw_menu_item,
+    draw_ui_text,
+    menu_item_hit_rect,
+    perk_menu_compute_layout,
+    perk_menu_panel_slide_x,
+    ui_origin,
+    ui_scale,
+    wrap_ui_text,
+)
+
+PlaySfxFn = Callable[[str], None]
+OnCloseFn = Callable[[], None]
+
+UI_TEXT_COLOR = rl.Color(220, 220, 220, 255)
+UI_SPONSOR_COLOR = rl.Color(255, 255, 255, int(255 * 0.5))
+
+
+@dataclass(frozen=True, slots=True)
+class PerkMenuContext:
+    state: GameplayState
+    perk_state: PerkSelectionState
+    players: Sequence[PlayerState]
+    creatures: Sequence[object]
+    player: PlayerState
+    game_mode: int
+    player_count: int
+    fx_toggle: int
+
+    font: SmallFontData | None
+    assets: PerkMenuAssets | None
+    mouse: rl.Vector2
+    fx_detail: bool = False
+    play_sfx: PlaySfxFn | None = None
+
+
+class PerkMenuController:
+    def __init__(self, *, cancel_label: str = "Cancel", on_close: OnCloseFn | None = None) -> None:
+        self._cancel_label = cancel_label
+        self._on_close = on_close
+        self.reset()
+
+    @property
+    def open(self) -> bool:
+        return bool(self._open)
+
+    @open.setter
+    def open(self, value: bool) -> None:
+        if not value and self._open:
+            self.close()
+        else:
+            self._open = bool(value)
+
+    @property
+    def selected_index(self) -> int:
+        return int(self._selected_index)
+
+    @selected_index.setter
+    def selected_index(self, value: int) -> None:
+        self._selected_index = int(value)
+
+    @property
+    def timeline_ms(self) -> float:
+        return float(self._timeline_ms)
+
+    @timeline_ms.setter
+    def timeline_ms(self, value: float) -> None:
+        self._timeline_ms = float(value)
+
+    @property
+    def active(self) -> bool:
+        return bool(self._open) or self._timeline_ms > 1e-3
+
+    def reset(self) -> None:
+        self._layout = PerkMenuLayout()
+        self._cancel_button = UiButtonState(self._cancel_label)
+        self._open = False
+        self._selected_index = 0
+        self._timeline_ms = 0.0
+
+    def close(self) -> None:
+        if not self._open:
+            return
+        self._open = False
+        if self._on_close is not None:
+            self._on_close()
+
+    def open_if_available(self, ctx: PerkMenuContext) -> bool:
+        if self._open:
+            return True
+        if ctx.assets is None:
+            return False
+        choices = perk_selection_current_choices(
+            ctx.state,
+            ctx.players,
+            ctx.perk_state,
+            game_mode=int(ctx.game_mode),
+            player_count=int(ctx.player_count),
+        )
+        if not choices:
+            self._open = False
+            return False
+        if ctx.play_sfx is not None:
+            ctx.play_sfx("sfx_ui_panelclick")
+        self._open = True
+        self._selected_index = 0
+        return True
+
+    def tick_timeline(self, dt_ui_ms: float) -> None:
+        if self._open:
+            self._timeline_ms = clamp(self._timeline_ms + float(dt_ui_ms), 0.0, PERK_MENU_TRANSITION_MS)
+        else:
+            self._timeline_ms = clamp(self._timeline_ms - float(dt_ui_ms), 0.0, PERK_MENU_TRANSITION_MS)
+
+    def handle_input(self, ctx: PerkMenuContext, *, dt_frame: float, dt_ui_ms: float) -> None:
+        if ctx.assets is None:
+            self.close()
+            return
+
+        choices = perk_selection_current_choices(
+            ctx.state,
+            ctx.players,
+            ctx.perk_state,
+            game_mode=int(ctx.game_mode),
+            player_count=int(ctx.player_count),
+        )
+        if not choices:
+            self.close()
+            return
+
+        if self._selected_index >= len(choices):
+            self._selected_index = 0
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_DOWN):
+            self._selected_index = (self._selected_index + 1) % len(choices)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_UP):
+            self._selected_index = (self._selected_index - 1) % len(choices)
+
+        screen_w = float(rl.get_screen_width())
+        screen_h = float(rl.get_screen_height())
+        scale = ui_scale(screen_w, screen_h)
+        origin_x, origin_y = ui_origin(screen_w, screen_h, scale)
+        slide_x = perk_menu_panel_slide_x(self._timeline_ms, width=self._layout.panel_w)
+
+        click = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
+
+        master_owned = int(ctx.player.perk_counts[int(PerkId.PERK_MASTER)]) > 0
+        expert_owned = int(ctx.player.perk_counts[int(PerkId.PERK_EXPERT)]) > 0
+        computed = perk_menu_compute_layout(
+            self._layout,
+            screen_w=screen_w,
+            origin_x=origin_x,
+            origin_y=origin_y,
+            scale=scale,
+            choice_count=len(choices),
+            expert_owned=expert_owned,
+            master_owned=master_owned,
+            panel_slide_x=slide_x,
+        )
+
+        for idx, perk_id in enumerate(choices):
+            label = perk_display_name(int(perk_id), fx_toggle=int(ctx.fx_toggle))
+            item_x = computed.list_x
+            item_y = computed.list_y + float(idx) * computed.list_step_y
+            rect = menu_item_hit_rect(ctx.font, label, x=item_x, y=item_y, scale=scale)
+            if rl.check_collision_point_rec(ctx.mouse, rect):
+                self._selected_index = idx
+                if click:
+                    if ctx.play_sfx is not None:
+                        ctx.play_sfx("sfx_ui_buttonclick")
+                    picked = perk_selection_pick(
+                        ctx.state,
+                        ctx.players,
+                        ctx.perk_state,
+                        idx,
+                        game_mode=int(ctx.game_mode),
+                        player_count=int(ctx.player_count),
+                        dt=float(dt_frame),
+                        creatures=ctx.creatures,
+                    )
+                    if picked is not None and ctx.play_sfx is not None:
+                        ctx.play_sfx("sfx_ui_bonus")
+                    self.close()
+                    return
+                break
+
+        cancel_w = button_width(
+            ctx.font,
+            self._cancel_button.label,
+            scale=scale,
+            force_wide=self._cancel_button.force_wide,
+        )
+        cancel_x = computed.cancel_x
+        cancel_y = computed.cancel_y
+        if button_update(
+            self._cancel_button,
+            x=cancel_x,
+            y=cancel_y,
+            width=cancel_w,
+            dt_ms=float(dt_ui_ms),
+            mouse=ctx.mouse,
+            click=click,
+        ):
+            if ctx.play_sfx is not None:
+                ctx.play_sfx("sfx_ui_buttonclick")
+            self.close()
+            return
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ENTER) or rl.is_key_pressed(rl.KeyboardKey.KEY_SPACE):
+            if ctx.play_sfx is not None:
+                ctx.play_sfx("sfx_ui_buttonclick")
+            picked = perk_selection_pick(
+                ctx.state,
+                ctx.players,
+                ctx.perk_state,
+                self._selected_index,
+                game_mode=int(ctx.game_mode),
+                player_count=int(ctx.player_count),
+                dt=float(dt_frame),
+                creatures=ctx.creatures,
+            )
+            if picked is not None and ctx.play_sfx is not None:
+                ctx.play_sfx("sfx_ui_bonus")
+            self.close()
+
+    def draw(self, ctx: PerkMenuContext) -> None:
+        menu_t = clamp(self._timeline_ms / PERK_MENU_TRANSITION_MS, 0.0, 1.0)
+        if menu_t <= 1e-3:
+            return
+        if ctx.assets is None:
+            return
+
+        choices = perk_selection_current_choices(
+            ctx.state,
+            ctx.players,
+            ctx.perk_state,
+            game_mode=int(ctx.game_mode),
+            player_count=int(ctx.player_count),
+        )
+        if not choices:
+            return
+
+        screen_w = float(rl.get_screen_width())
+        screen_h = float(rl.get_screen_height())
+        scale = ui_scale(screen_w, screen_h)
+        origin_x, origin_y = ui_origin(screen_w, screen_h, scale)
+        slide_x = perk_menu_panel_slide_x(self._timeline_ms, width=self._layout.panel_w)
+
+        master_owned = int(ctx.player.perk_counts[int(PerkId.PERK_MASTER)]) > 0
+        expert_owned = int(ctx.player.perk_counts[int(PerkId.PERK_EXPERT)]) > 0
+        computed = perk_menu_compute_layout(
+            self._layout,
+            screen_w=screen_w,
+            origin_x=origin_x,
+            origin_y=origin_y,
+            scale=scale,
+            choice_count=len(choices),
+            expert_owned=expert_owned,
+            master_owned=master_owned,
+            panel_slide_x=slide_x,
+        )
+
+        panel_tex = ctx.assets.menu_panel
+        if panel_tex is not None:
+            draw_classic_menu_panel(panel_tex, dst=computed.panel, shadow=bool(ctx.fx_detail))
+
+        title_tex = ctx.assets.title_pick_perk
+        if title_tex is not None:
+            src = rl.Rectangle(0.0, 0.0, float(title_tex.width), float(title_tex.height))
+            rl.draw_texture_pro(title_tex, src, computed.title, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+        sponsor = None
+        if master_owned:
+            sponsor = "extra perks sponsored by the Perk Master"
+        elif expert_owned:
+            sponsor = "extra perk sponsored by the Perk Expert"
+        if sponsor:
+            draw_ui_text(ctx.font, sponsor, computed.sponsor_x, computed.sponsor_y, scale=scale, color=UI_SPONSOR_COLOR)
+
+        for idx, perk_id in enumerate(choices):
+            label = perk_display_name(int(perk_id), fx_toggle=int(ctx.fx_toggle))
+            item_x = computed.list_x
+            item_y = computed.list_y + float(idx) * computed.list_step_y
+            rect = menu_item_hit_rect(ctx.font, label, x=item_x, y=item_y, scale=scale)
+            hovered = rl.check_collision_point_rec(ctx.mouse, rect) or (idx == self._selected_index)
+            draw_menu_item(ctx.font, label, x=item_x, y=item_y, scale=scale, hovered=hovered)
+
+        selected = choices[self._selected_index]
+        desc = perk_display_description(int(selected), fx_toggle=int(ctx.fx_toggle))
+        desc_x = float(computed.desc.x)
+        desc_y = float(computed.desc.y)
+        desc_w = float(computed.desc.width)
+        desc_h = float(computed.desc.height)
+        desc_scale = scale * 0.85
+        desc_lines = wrap_ui_text(ctx.font, desc, max_width=desc_w, scale=desc_scale)
+        line_h = float(ctx.font.cell_size * desc_scale) if ctx.font is not None else float(20 * desc_scale)
+        y = desc_y
+        for line in desc_lines:
+            if y + line_h > desc_y + desc_h:
+                break
+            draw_ui_text(ctx.font, line, desc_x, y, scale=desc_scale, color=UI_TEXT_COLOR)
+            y += line_h
+
+        cancel_w = button_width(ctx.font, self._cancel_button.label, scale=scale, force_wide=self._cancel_button.force_wide)
+        button_draw(ctx.assets, ctx.font, self._cancel_button, x=computed.cancel_x, y=computed.cancel_y, width=cancel_w, scale=scale)