crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/tutorial/timeline.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+from ..bonuses import BonusId
+from ..creatures.spawn import (
+    SpawnTemplateCall,
+    build_tutorial_stage3_fire_spawns,
+    build_tutorial_stage4_clear_spawns,
+    build_tutorial_stage5_repeat_spawns,
+    build_tutorial_stage6_perks_done_spawns,
+)
+
+_TUTORIAL_STAGE_TEXT: tuple[str, ...] = (
+    "In this tutorial you'll learn how to play Crimsonland",
+    "First learn to move by pushing the arrow keys.",
+    "Now pick up the bonuses by walking over them",
+    "Now learn to shoot and move at the same time.\nClick the left Mouse button to shoot.",
+    "Now, move the mouse to aim at the monsters",
+    "It will help you to move and shoot at the same time. Just keep moving!",
+    "Now let's learn about Perks. You'll receive a perk when you gain enough experience points.",
+    "Perks can give you extra abilities, or boost your skills. Choose wisely!",
+    "Great! Now you are ready to start playing Crimsonland",
+)
+
+_TUTORIAL_HINT_TEXT: tuple[str, ...] = (
+    "This is the speed powerup, it makes you move faster!",
+    "This is a weapon powerup. Picking it up gives you a new weapon.",
+    "This powerup doubles all experience points you gain while it's active.",
+    "This is the nuke powerup, picking it up causes a huge\nexposion harming all monsters nearby!",
+    "Reflex Boost powerup slows down time giving you a chance to react better",
+    "",
+    "",
+)
+
+
+@dataclass(slots=True)
+class TutorialState:
+    stage_index: int = -1
+    stage_timer_ms: int = 0
+    stage_transition_timer_ms: int = -1000
+    hint_index: int = -1
+    hint_alpha: int = 0
+    hint_fade_in: bool = False
+    repeat_spawn_count: int = 0
+    hint_bonus_creature_ref: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class BonusSpawnCall:
+    bonus_id: int
+    amount: int
+    pos: tuple[float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class TutorialFrameActions:
+    prompt_text: str = ""
+    prompt_alpha: float = 0.0
+    hint_text: str = ""
+    hint_alpha: float = 0.0
+    spawn_templates: tuple[SpawnTemplateCall, ...] = ()
+    spawn_bonuses: tuple[BonusSpawnCall, ...] = ()
+    stage5_bonus_carrier_drop: tuple[int, int] | None = None
+    play_levelup_sfx: bool = False
+    force_player_health: float = 100.0
+    force_player_experience: int | None = None
+
+
+def tutorial_stage5_bonus_carrier_config(repeat_spawn_count: int) -> tuple[int, int] | None:
+    """Return the (bonus_id, amount_override) applied to the stage-5 bonus carrier for this repeat count.
+
+    This reproduces the packed bonus-arg writes to `tutorial_hint_bonus_ptr` in `tutorial_timeline_update`.
+
+    - amount_override == -1 means "use the bonus meta default".
+    - For weapon bonuses, amount_override is the weapon id.
+    """
+    n = int(repeat_spawn_count)
+    if n == 1:
+        return int(BonusId.SPEED), -1
+    if n == 2:
+        return int(BonusId.WEAPON), 5
+    if n == 3:
+        return int(BonusId.DOUBLE_EXPERIENCE), -1
+    if n == 4:
+        return int(BonusId.NUKE), -1
+    if n == 5:
+        return int(BonusId.REFLEX_BOOST), -1
+    return None
+
+
+def _clamp01(value: float) -> float:
+    if value <= 0.0:
+        return 0.0
+    if value >= 1.0:
+        return 1.0
+    return float(value)
+
+
+def _tick_stage_transition(stage_index: int, transition_timer_ms: int, *, frame_dt_ms: int) -> tuple[int, int]:
+    stage_index = int(stage_index)
+    transition_timer_ms = int(transition_timer_ms)
+    dt_ms = int(frame_dt_ms)
+
+    if transition_timer_ms < -1:
+        transition_timer_ms += dt_ms
+        if transition_timer_ms < -1:
+            return stage_index, transition_timer_ms
+        stage_index += 1
+        if stage_index == 9:
+            stage_index = 0
+        transition_timer_ms = 0
+        return stage_index, transition_timer_ms
+
+    if -1 < transition_timer_ms:
+        transition_timer_ms += dt_ms
+    if 1000 < transition_timer_ms:
+        transition_timer_ms = -1
+    return stage_index, transition_timer_ms
+
+
+def _prompt_alpha(*, stage_index: int, stage_timer_ms: int, transition_timer_ms: int) -> float:
+    stage_index = int(stage_index)
+    stage_timer_ms = int(stage_timer_ms)
+    transition_timer_ms = int(transition_timer_ms)
+
+    if stage_index < 0:
+        return 0.0
+
+    if transition_timer_ms < -1:
+        alpha = float(-transition_timer_ms) * 0.001
+    elif transition_timer_ms < 0:
+        alpha = 1.0
+    else:
+        alpha = float(transition_timer_ms) * 0.001
+
+    if stage_index == 5:
+        if stage_timer_ms > 5000 and transition_timer_ms > -2:
+            alpha = 1.0 - float(stage_timer_ms - 5000) * 0.001
+        if stage_timer_ms >= 0x1771:
+            alpha = 0.0
+
+    return _clamp01(alpha)
+
+
+def _tick_hint(state: TutorialState, *, frame_dt_ms: int, hint_bonus_died: bool) -> tuple[tuple[SpawnTemplateCall, ...], str, float]:
+    hint_spawns: list[SpawnTemplateCall] = []
+
+    if (not state.hint_fade_in) and bool(hint_bonus_died):
+        state.hint_fade_in = True
+        state.hint_index = int(state.hint_index) + 1
+        hint_spawns.extend(
+            (
+                SpawnTemplateCall(template_id=0x24, pos=(128.0, 128.0), heading=3.1415927),
+                SpawnTemplateCall(template_id=0x26, pos=(152.0, 160.0), heading=3.1415927),
+            )
+        )
+
+    delta = int(frame_dt_ms) * 3
+    state.hint_alpha = int(state.hint_alpha) + (delta if state.hint_fade_in else -delta)
+    if state.hint_alpha < 0:
+        state.hint_alpha = 0
+    elif state.hint_alpha > 1000:
+        state.hint_alpha = 1000
+
+    idx = int(state.hint_index)
+    text = _TUTORIAL_HINT_TEXT[idx] if 0 <= idx < len(_TUTORIAL_HINT_TEXT) else ""
+    alpha = float(state.hint_alpha) * 0.001 if text else 0.0
+    return tuple(hint_spawns), text, _clamp01(alpha)
+
+
+def tick_tutorial_timeline(
+    state: TutorialState,
+    *,
+    frame_dt_ms: float,
+    any_move_active: bool,
+    any_fire_active: bool,
+    creatures_none_active: bool,
+    bonus_pool_empty: bool,
+    perk_pending_count: int,
+    hint_bonus_died: bool = False,
+) -> tuple[TutorialState, TutorialFrameActions]:
+    """Pure model of the tutorial director (`tutorial_timeline_update` / 0x00408990).
+
+    Notes:
+    - The returned UI model (prompt/hint text+alpha) reflects the state *before* any stage triggers
+      applied by this tick. The returned state reflects the post-trigger values for the next frame.
+    """
+    dt_ms = int(float(frame_dt_ms))
+    state = replace(state)
+    state.stage_timer_ms = int(state.stage_timer_ms) + dt_ms
+
+    stage_index, transition_timer_ms = _tick_stage_transition(state.stage_index, state.stage_transition_timer_ms, frame_dt_ms=dt_ms)
+    state.stage_index = int(stage_index)
+    state.stage_transition_timer_ms = int(transition_timer_ms)
+
+    prompt_text = _TUTORIAL_STAGE_TEXT[stage_index] if 0 <= stage_index < len(_TUTORIAL_STAGE_TEXT) else ""
+    prompt_alpha = _prompt_alpha(stage_index=stage_index, stage_timer_ms=state.stage_timer_ms, transition_timer_ms=transition_timer_ms)
+    if stage_index == 6 and int(perk_pending_count) < 1:
+        prompt_text = ""
+        prompt_alpha = 0.0
+
+    hint_spawns, hint_text, hint_alpha = _tick_hint(state, frame_dt_ms=dt_ms, hint_bonus_died=bool(hint_bonus_died))
+
+    actions = TutorialFrameActions(
+        prompt_text=prompt_text,
+        prompt_alpha=prompt_alpha,
+        hint_text=hint_text,
+        hint_alpha=hint_alpha,
+        spawn_templates=hint_spawns,
+        spawn_bonuses=(),
+        stage5_bonus_carrier_drop=None,
+        play_levelup_sfx=False,
+        force_player_health=100.0,
+        force_player_experience=0 if stage_index != 6 else None,
+    )
+
+    spawn_templates: list[SpawnTemplateCall] = list(actions.spawn_templates)
+    spawn_bonuses: list[BonusSpawnCall] = []
+    play_levelup_sfx = False
+    stage5_bonus_carrier_drop: tuple[int, int] | None = None
+    force_experience = actions.force_player_experience
+
+    if stage_index == 0:
+        if state.stage_timer_ms > 6000 and state.stage_transition_timer_ms == -1:
+            state.repeat_spawn_count = 0
+            state.hint_index = int(state.stage_transition_timer_ms)
+            state.hint_fade_in = False
+            state.stage_transition_timer_ms = -1000
+    elif stage_index == 1:
+        if bool(any_move_active) and state.stage_transition_timer_ms == -1:
+            state.stage_transition_timer_ms = -1000
+            play_levelup_sfx = True
+            spawn_bonuses.extend(
+                (
+                    BonusSpawnCall(bonus_id=int(BonusId.POINTS), amount=500, pos=(260.0, 260.0)),
+                    BonusSpawnCall(bonus_id=int(BonusId.POINTS), amount=1000, pos=(600.0, 400.0)),
+                    BonusSpawnCall(bonus_id=int(BonusId.POINTS), amount=500, pos=(300.0, 400.0)),
+                )
+            )
+    elif stage_index == 2:
+        if bool(bonus_pool_empty) and state.stage_transition_timer_ms == -1:
+            state.stage_transition_timer_ms = -1000
+            play_levelup_sfx = True
+    elif stage_index == 3:
+        if bool(any_fire_active) and state.stage_transition_timer_ms == -1:
+            state.stage_transition_timer_ms = -1000
+            play_levelup_sfx = True
+            spawn_templates.extend(build_tutorial_stage3_fire_spawns())
+    elif stage_index == 4:
+        if bool(creatures_none_active) and state.stage_transition_timer_ms == -1:
+            state.stage_timer_ms = 1000
+            state.stage_transition_timer_ms = -1000
+            play_levelup_sfx = True
+            state.repeat_spawn_count = 0
+            spawn_templates.extend(build_tutorial_stage4_clear_spawns())
+    elif stage_index == 5:
+        if bool(bonus_pool_empty) and bool(creatures_none_active):
+            state.repeat_spawn_count = int(state.repeat_spawn_count) + 1
+            if int(state.repeat_spawn_count) < 8:
+                state.hint_fade_in = False
+                state.hint_bonus_creature_ref = None
+                spawn_templates.extend(build_tutorial_stage5_repeat_spawns(int(state.repeat_spawn_count)))
+                stage5_bonus_carrier_drop = tutorial_stage5_bonus_carrier_config(int(state.repeat_spawn_count))
+            elif state.stage_transition_timer_ms == -1:
+                state.stage_transition_timer_ms = -1000
+                play_levelup_sfx = True
+                force_experience = 3000
+    elif stage_index == 6:
+        if int(perk_pending_count) < 1 and state.stage_transition_timer_ms == -1:
+            state.stage_transition_timer_ms = -1000
+            spawn_templates.extend(build_tutorial_stage6_perks_done_spawns())
+    elif stage_index == 7:
+        if bool(bonus_pool_empty) and bool(creatures_none_active) and state.stage_transition_timer_ms == -1:
+            state.stage_transition_timer_ms = -1000
+
+    return (
+        state,
+        TutorialFrameActions(
+            prompt_text=actions.prompt_text,
+            prompt_alpha=actions.prompt_alpha,
+            hint_text=actions.hint_text,
+            hint_alpha=actions.hint_alpha,
+            spawn_templates=tuple(spawn_templates),
+            spawn_bonuses=tuple(spawn_bonuses),
+            stage5_bonus_carrier_drop=stage5_bonus_carrier_drop,
+            play_levelup_sfx=bool(play_levelup_sfx),
+            force_player_health=actions.force_player_health,
+            force_player_experience=force_experience,
+        ),
+    )

crimson/typo/__init__.py

@@ -0,0 +1,2 @@
+from __future__ import annotations
+

crimson/typo/names.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+
+from grim.rand import Crand
+
+
+NAME_MAX_CHARS = 16  # creature_name_assign_random enforces strlen < 0x10.
+
+
+_NAME_PARTS: tuple[str, ...] = (
+    "lamb",
+    "gun",
+    "head",
+    "tail",
+    "leg",
+    "nose",
+    "road",
+    "stab",
+    "high",
+    "low",
+    "hat",
+    "pie",
+    "hand",
+    "jack",
+    "cube",
+    "ice",
+    "cow",
+    "king",
+    "lord",
+    "mate",
+    "mary",
+    "dick",
+    "bill",
+    "cat",
+    "harry",
+    "tom",
+    "fly",
+    "call",
+    "shot",
+    "gate",
+    "quick",
+    "brown",
+    "fox",
+    "jumper",
+    "over",
+    "lazy",
+    "dog",
+    "zeta",
+    "unique",
+    "nerd",
+    "earl",
+    "sleep",
+    "onyx",
+    "mill",
+    "blue",
+    "below",
+    "scape",
+    "reap",
+    "damo",
+    "break",
+    "boom",
+    "the",
+)
+
+
+def typo_name_part(rng: Crand, *, allow_the: bool) -> str:
+    mod = 52 if allow_the else 51
+    idx = int(rng.rand() % mod)
+    if idx == 39:
+        return "nerd"
+    return _NAME_PARTS[idx]
+
+
+def typo_build_name(rng: Crand, *, score_xp: int, unique_words: Sequence[str] | None = None) -> str:
+    score_xp = int(score_xp)
+    if unique_words:
+        return _typo_build_custom_name(rng, score_xp=score_xp, unique_words=unique_words)
+    if score_xp > 120:
+        if int(rng.rand() % 100) < 10 and unique_words:
+            return str(unique_words[int(rng.rand() % len(unique_words))])
+        if int(rng.rand() % 100) < 80:
+            return "".join(
+                [
+                    typo_name_part(rng, allow_the=True),
+                    typo_name_part(rng, allow_the=False),
+                    typo_name_part(rng, allow_the=False),
+                    typo_name_part(rng, allow_the=False),
+                ]
+            )
+
+    if (score_xp > 80 and int(rng.rand() % 100) < 80) or (score_xp > 60 and int(rng.rand() % 100) < 40):
+        return "".join(
+            [
+                typo_name_part(rng, allow_the=True),
+                typo_name_part(rng, allow_the=False),
+                typo_name_part(rng, allow_the=False),
+            ]
+        )
+
+    if (score_xp > 40 and int(rng.rand() % 100) < 80) or (score_xp > 20 and int(rng.rand() % 100) < 40):
+        return "".join(
+            [
+                typo_name_part(rng, allow_the=True),
+                typo_name_part(rng, allow_the=False),
+            ]
+        )
+
+    return typo_name_part(rng, allow_the=False)
+
+
+def _pick_word(rng: Crand, words: Sequence[str]) -> str:
+    return str(words[int(rng.rand() % len(words))])
+
+
+def _pick_unique_words(rng: Crand, words: Sequence[str], count: int) -> list[str]:
+    if count <= 1:
+        return [_pick_word(rng, words)]
+    if len(words) <= count:
+        return [_pick_word(rng, words) for _ in range(count)]
+
+    picked: list[str] = []
+    used: set[int] = set()
+    while len(picked) < count:
+        idx = int(rng.rand() % len(words))
+        if idx in used:
+            continue
+        used.add(idx)
+        picked.append(str(words[idx]))
+    return picked
+
+
+def _typo_build_custom_name(rng: Crand, *, score_xp: int, unique_words: Sequence[str]) -> str:
+    score_xp = int(score_xp)
+    if score_xp > 120:
+        if int(rng.rand() % 100) < 10:
+            return _pick_word(rng, unique_words)
+        if int(rng.rand() % 100) < 80:
+            return "".join(_pick_unique_words(rng, unique_words, 4))
+
+    if (score_xp > 80 and int(rng.rand() % 100) < 80) or (score_xp > 60 and int(rng.rand() % 100) < 40):
+        return "".join(_pick_unique_words(rng, unique_words, 3))
+
+    if (score_xp > 40 and int(rng.rand() % 100) < 80) or (score_xp > 20 and int(rng.rand() % 100) < 40):
+        return "".join(_pick_unique_words(rng, unique_words, 2))
+
+    return _pick_word(rng, unique_words)
+
+
+def load_typo_dictionary(path: Path) -> list[str]:
+    try:
+        raw = path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return []
+
+    words: list[str] = []
+    seen: set[str] = set()
+    for line in raw.splitlines():
+        text = line.split("#", 1)[0].strip()
+        if not text:
+            continue
+        if len(text) >= NAME_MAX_CHARS:
+            continue
+        if text in seen:
+            continue
+        words.append(text)
+        seen.add(text)
+    return words
+
+
+@dataclass(slots=True)
+class CreatureNameTable:
+    names: list[str]
+
+    @classmethod
+    def sized(cls, size: int) -> CreatureNameTable:
+        return cls(names=[""] * int(size))
+
+    def clear(self, idx: int) -> None:
+        if 0 <= int(idx) < len(self.names):
+            self.names[int(idx)] = ""
+
+    def find_by_name(self, name: str, *, active_mask: Sequence[bool]) -> int | None:
+        for idx, existing in enumerate(self.names):
+            if not (0 <= idx < len(active_mask) and bool(active_mask[idx])):
+                continue
+            if existing == name:
+                return idx
+        return None
+
+    def is_unique(self, name: str, *, exclude_idx: int, active_mask: Sequence[bool]) -> bool:
+        exclude = int(exclude_idx)
+        for idx, existing in enumerate(self.names):
+            if idx == exclude:
+                continue
+            if not (0 <= idx < len(active_mask) and bool(active_mask[idx])):
+                continue
+            if existing == name:
+                return False
+        return True
+
+    def assign_random(
+        self,
+        creature_idx: int,
+        rng: Crand,
+        *,
+        score_xp: int,
+        active_mask: Sequence[bool],
+        unique_words: Sequence[str] | None = None,
+    ) -> str:
+        idx = int(creature_idx)
+        if not (0 <= idx < len(self.names)):
+            raise IndexError(f"creature_idx out of range: {idx}")
+
+        too_long_attempts = 0
+        attempts = 0
+        while True:
+            name = typo_build_name(rng, score_xp=score_xp, unique_words=unique_words)
+            if not self.is_unique(name, exclude_idx=idx, active_mask=active_mask):
+                attempts += 1
+                if attempts < 200:
+                    continue
+
+            if len(name) < NAME_MAX_CHARS:
+                self.names[idx] = name
+                return name
+
+            too_long_attempts += 1
+            if too_long_attempts > 99:
+                self.names[idx] = name
+                return name

crimson/typo/player.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from ..gameplay import PlayerInput, PlayerState, weapon_assign_player
+
+TYPO_WEAPON_ID = 4
+
+
+def enforce_typo_player_frame(player: PlayerState) -> None:
+    """Match Typ-o Shooter's bespoke player loop (`player_fire_weapon @ 0x00444980`).
+
+    Typ-o resets timers and tops up ammo each frame, so typing speed (not weapon
+    cooldown) controls rate of fire.
+    """
+
+    if int(player.weapon_id) != TYPO_WEAPON_ID:
+        weapon_assign_player(player, TYPO_WEAPON_ID)
+
+    player.shot_cooldown = 0.0
+    player.spread_heat = 0.0
+    player.ammo = float(max(0, int(player.clip_size)))
+
+    player.reload_active = False
+    player.reload_timer = 0.0
+    player.reload_timer_max = 0.0
+
+
+def build_typo_player_input(
+    *,
+    aim_x: float,
+    aim_y: float,
+    fire_requested: bool,
+    reload_requested: bool,
+) -> PlayerInput:
+    fire = bool(fire_requested)
+    return PlayerInput(
+        move_x=0.0,
+        move_y=0.0,
+        aim_x=float(aim_x),
+        aim_y=float(aim_y),
+        fire_down=fire,
+        fire_pressed=fire,
+        reload_pressed=bool(reload_requested),
+    )

crimson/typo/spawns.py

@@ -0,0 +1,73 @@
+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
+
+
+@dataclass(frozen=True, slots=True)
+class TypoSpawnCall:
+    pos_x: float
+    pos_y: float
+    type_id: CreatureTypeId
+    tint_rgba: tuple[float, float, float, float]
+
+
+def tick_typo_spawns(
+    *,
+    elapsed_ms: int,
+    spawn_cooldown_ms: int,
+    frame_dt_ms: int,
+    player_count: int,
+    world_width: float,
+    world_height: float,
+) -> tuple[int, list[TypoSpawnCall]]:
+    elapsed_ms = int(elapsed_ms)
+    cooldown = int(spawn_cooldown_ms)
+    dt_ms = int(frame_dt_ms)
+    player_count = max(1, int(player_count))
+
+    cooldown -= dt_ms * player_count
+
+    spawns: list[TypoSpawnCall] = []
+    while cooldown < 0:
+        cooldown += 3500 - elapsed_ms // 800
+        cooldown = max(100, cooldown)
+
+        t = float(elapsed_ms) * 0.001
+        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.30000001, 0.0, 1.0)
+        tint_g = _clamp(tint_t * 10000.0 + 0.30000001, 0.0, 1.0)
+        tint_b = _clamp(math.sin(tint_t * 0.0001) + 0.30000001, 0.0, 1.0)
+        tint = (tint_r, tint_g, tint_b, 1.0)
+
+        spawns.append(
+            TypoSpawnCall(
+                pos_x=float(world_width) + 64.0,
+                pos_y=y,
+                type_id=CreatureTypeId.SPIDER_SP2,
+                tint_rgba=tint,
+            )
+        )
+        spawns.append(
+            TypoSpawnCall(
+                pos_x=-64.0,
+                pos_y=y,
+                type_id=CreatureTypeId.ALIEN,
+                tint_rgba=tint,
+            )
+        )
+
+    return cooldown, spawns
+

crimson/typo/typing.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+
+TYPING_MAX_CHARS = 17
+
+
+@dataclass(frozen=True, slots=True)
+class TypingEnterResult:
+    fire_requested: bool = False
+    reload_requested: bool = False
+    target_creature_idx: int | None = None
+
+
+@dataclass(slots=True)
+class TypingBuffer:
+    text: str = ""
+    shots_fired: int = 0
+    shots_hit: int = 0
+
+    def clear(self) -> None:
+        self.text = ""
+
+    def backspace(self) -> None:
+        if self.text:
+            self.text = self.text[:-1]
+
+    def push_char(self, ch: str) -> None:
+        if not ch:
+            return
+        if len(self.text) >= TYPING_MAX_CHARS:
+            return
+        self.text += ch[0]
+
+    def enter(self, *, find_target: Callable[[str], int | None]) -> TypingEnterResult:
+        if not self.text:
+            return TypingEnterResult()
+
+        entered = self.text
+        self.shots_fired += 1
+        self.clear()
+
+        target = find_target(entered)
+        if target is not None:
+            self.shots_hit += 1
+            return TypingEnterResult(fire_requested=True, target_creature_idx=int(target))
+        if entered == "reload":
+            return TypingEnterResult(reload_requested=True)
+        return TypingEnterResult()
+

crimson/ui/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__all__ = ["cursor", "hud", "perk_menu"]