crimsonland 0.1.0.dev5__py3-none-any.whl → 0.1.0.dev11__py3-none-any.whl

crimson/audio_router.py

@@ -9,7 +9,7 @@ from grim.audio import AudioState, play_sfx, trigger_game_tune
 from .creatures.spawn import CreatureTypeId
 from .game_modes import GameMode
 from .weapon_sfx import resolve_weapon_sfx_ref
-from .weapons import WEAPON_BY_ID
+from .weapons import WEAPON_BY_ID, WeaponId
 
 _MAX_HIT_SFX_PER_FRAME = 4
 _MAX_DEATH_SFX_PER_FRAME = 3
@@ -96,7 +96,17 @@ class AudioRouter:
             return
 
         if int(getattr(player, "shot_seq", 0)) > int(prev_shot_seq):
-            self.play_sfx(resolve_weapon_sfx_ref(weapon.fire_sound))
+            if float(getattr(player, "fire_bullets_timer", 0.0)) > 0.0:
+                # player_update (crimsonland.exe): when Fire Bullets is active, the regular per-weapon
+                # shot sfx is suppressed and replaced by Fire Bullets + Plasma Minigun fire sfx.
+                fire_bullets = WEAPON_BY_ID.get(int(WeaponId.FIRE_BULLETS))
+                plasma_minigun = WEAPON_BY_ID.get(int(WeaponId.PLASMA_MINIGUN))
+                if fire_bullets is not None:
+                    self.play_sfx(resolve_weapon_sfx_ref(fire_bullets.fire_sound))
+                if plasma_minigun is not None:
+                    self.play_sfx(resolve_weapon_sfx_ref(plasma_minigun.fire_sound))
+            else:
+                self.play_sfx(resolve_weapon_sfx_ref(weapon.fire_sound))
 
         reload_active = bool(getattr(player, "reload_active", False))
         reload_timer = float(getattr(player, "reload_timer", 0.0))

crimson/creatures/anim.py

@@ -28,6 +28,7 @@ _CREATURE_CORPSE_FRAMES: dict[int, int] = {
     3: 1,  # spider sp1
     4: 2,  # spider sp2
     5: 7,  # trooper
+    7: 6,  # ping-pong strip corpse fallback
 }
 
 

crimson/demo.py

@@ -475,6 +475,9 @@ class DemoView:
             player = self._world.players[idx]
             player.pos_x = float(x)
             player.pos_y = float(y)
+            # Keep aim anchored to the spawn position so demo aim starts stable.
+            player.aim_x = float(x)
+            player.aim_y = float(y)
             weapon_assign_player(player, int(weapon_id))
         self._demo_targets = [None] * len(self._world.players)
 
@@ -549,7 +552,8 @@ class DemoView:
 
     def _setup_variant_0(self) -> None:
         self._demo_time_limit_ms = 4000
-        weapon_id = 12
+        # demo_setup_variant_0 uses weapon_id=0x0B.
+        weapon_id = 11
         self._setup_world_players(
             [
                 (448.0, 384.0, weapon_id),
@@ -567,7 +571,8 @@ class DemoView:
 
     def _setup_variant_1(self) -> None:
         self._demo_time_limit_ms = 5000
-        weapon_id = 6
+        # demo_setup_variant_1 uses weapon_id=0x05.
+        weapon_id = 5
         self._setup_world_players(
             [
                 (490.0, 448.0, weapon_id),
@@ -586,7 +591,8 @@ class DemoView:
 
     def _setup_variant_2(self) -> None:
         self._demo_time_limit_ms = 5000
-        weapon_id = 22
+        # demo_setup_variant_2 uses weapon_id=0x15.
+        weapon_id = 21
         self._setup_world_players([(512.0, 512.0, weapon_id)])
         y = 128
         i = 0
@@ -601,7 +607,8 @@ class DemoView:
 
     def _setup_variant_3(self) -> None:
         self._demo_time_limit_ms = 4000
-        weapon_id = 19
+        # demo_setup_variant_3 uses weapon_id=0x12.
+        weapon_id = 18
         self._setup_world_players([(512.0, 512.0, weapon_id)])
         for idx in range(20):
             x = float(self._crand_mod(200) + 32)
@@ -690,8 +697,8 @@ class DemoView:
                 rl.draw_circle(int(sx), int(sy), radius, rl.Color(200, 120, 255, 255))
                 continue
             if proj.type_id == 3:
-                t = _clamp(proj.lifetime, 0.0, 1.0)
-                radius = proj.speed * t * 80.0
+                t = _clamp(proj.vel_x, 0.0, 1.0)
+                radius = proj.vel_y * t * 80.0
                 alpha = int((1.0 - t) * 180.0)
                 color = rl.Color(200, 120, 255, alpha)
                 rl.draw_circle_lines(int(sx), int(sy), max(1.0, radius * scale), color)
@@ -881,10 +888,10 @@ class DemoView:
     def _update_world(self, dt: float) -> None:
         if not self._world.players:
             return
-        inputs = self._build_demo_inputs()
+        inputs = self._build_demo_inputs(dt)
         self._world.update(dt, inputs=inputs, auto_pick_perks=False, game_mode=0, perk_progression_enabled=False)
 
-    def _build_demo_inputs(self) -> list[PlayerInput]:
+    def _build_demo_inputs(self, dt: float) -> list[PlayerInput]:
         players = self._world.players
         creatures = self._world.creatures.entries
         if len(self._demo_targets) != len(players):
@@ -892,42 +899,77 @@ class DemoView:
         center_x = float(self._world.world_size) * 0.5
         center_y = float(self._world.world_size) * 0.5
 
+        dt = float(dt)
+
+        def _turn_towards_heading(cur: float, target: float) -> tuple[float, float]:
+            cur = cur % math.tau
+            target = target % math.tau
+            delta = (target - cur + math.pi) % math.tau - math.pi
+            diff = abs(delta)
+            if diff <= 1e-9:
+                return cur, 0.0
+            step = dt * diff * 5.0
+            cur = (cur + step) % math.tau if delta > 0.0 else (cur - step) % math.tau
+            return cur, diff
+
         inputs: list[PlayerInput] = []
         for idx, player in enumerate(players):
             target_idx = self._select_demo_target(idx, player, creatures)
-            aim_x = center_x
-            aim_y = center_y
             target = None
             if target_idx is not None and 0 <= target_idx < len(creatures):
                 candidate = creatures[target_idx]
-                if candidate.hp > 0.0:
+                if candidate.active and candidate.hp > 0.0:
                     target = candidate
-                    aim_x = candidate.x
-                    aim_y = candidate.y
-
-            move_x, move_y = 0.0, 0.0
-            to_cx = center_x - player.pos_x
-            to_cy = center_y - player.pos_y
-            nx, ny, d = _normalize(to_cx, to_cy)
-            if d > 120.0:
-                move_x += nx
-                move_y += ny
 
+            # Aim: ease the aim point toward the target.
+            aim_x = float(player.aim_x)
+            aim_y = float(player.aim_y)
+            auto_fire = False
             if target is not None:
-                rx = player.pos_x - target.x
-                ry = player.pos_y - target.y
-                rnx, rny, rd = _normalize(rx, ry)
-                if 0.0 < rd < 160.0:
-                    strength = (160.0 - rd) / 160.0
-                    move_x += rnx * (1.5 * strength)
-                    move_y += rny * (1.5 * strength)
-
-            orbit_dir = -1.0 if (player.index % 2) else 1.0
-            ox, oy, _ = _normalize(-(player.pos_y - center_y), player.pos_x - center_x)
-            move_x += ox * 0.55 * orbit_dir
-            move_y += oy * 0.55 * orbit_dir
-
-            fire_down = target is not None
+                aim_dx = float(target.x) - aim_x
+                aim_dy = float(target.y) - aim_y
+                aim_dir_x, aim_dir_y, aim_dist = _normalize(aim_dx, aim_dy)
+                if aim_dist >= 4.0:
+                    step = aim_dist * 6.0 * dt
+                    aim_x += aim_dir_x * step
+                    aim_y += aim_dir_y * step
+                else:
+                    aim_x = float(target.x)
+                    aim_y = float(target.y)
+                auto_fire = aim_dist < 128.0
+            else:
+                ax, ay, amag = _normalize(float(player.pos_x) - center_x, float(player.pos_y) - center_y)
+                if amag <= 1e-6:
+                    ax, ay = 0.0, -1.0
+                aim_x = float(player.pos_x) + ax * 60.0
+                aim_y = float(player.pos_y) + ay * 60.0
+
+            # Movement:
+            # - orbit center if no target
+            # - chase target when near center
+            # - return to center when too far
+            if target is None:
+                move_dx = -(float(player.pos_y) - center_y)
+                move_dy = float(player.pos_x) - center_x
+            else:
+                center_dist = math.hypot(float(player.pos_x) - center_x, float(player.pos_y) - center_y)
+                if center_dist <= 300.0:
+                    move_dx = float(target.x) - float(player.pos_x)
+                    move_dy = float(target.y) - float(player.pos_y)
+                else:
+                    move_dx = center_x - float(player.pos_x)
+                    move_dy = center_y - float(player.pos_y)
+
+            desired_x, desired_y, desired_mag = _normalize(move_dx, move_dy)
+            if desired_mag <= 1e-6:
+                move_x = 0.0
+                move_y = 0.0
+            else:
+                desired_heading = math.atan2(desired_y, desired_x) + math.pi / 2.0
+                smoothed_heading, angle_diff = _turn_towards_heading(float(player.heading), desired_heading)
+                move_mag = max(0.001, (math.pi - angle_diff) / math.pi)
+                move_x = math.cos(smoothed_heading - math.pi / 2.0) * move_mag
+                move_y = math.sin(smoothed_heading - math.pi / 2.0) * move_mag
 
             inputs.append(
                 PlayerInput(
@@ -935,8 +977,8 @@ class DemoView:
                     move_y=move_y,
                     aim_x=aim_x,
                     aim_y=aim_y,
-                    fire_down=fire_down,
-                    fire_pressed=fire_down,
+                    fire_down=auto_fire,
+                    fire_pressed=auto_fire,
                     reload_pressed=False,
                 )
             )

crimson/effects.py

@@ -261,7 +261,7 @@ class ParticlePool:
             entry.age = alpha
             entry.scale_x = shade
             entry.scale_y = shade
-            entry.scale_z = shade
+            # Native only updates scale_x/scale_y; scale_z stays at its spawn value (1.0).
 
             alive = entry.intensity > (0.0 if style == 0 else 0.8)
             if not alive:

crimson/game.py

@@ -789,6 +789,7 @@ class SurvivalGameView:
             ViewContext(assets_dir=state.assets_dir),
             texture_cache=state.texture_cache,
             config=state.config,
+            console=state.console,
             audio=state.audio,
             audio_rng=state.rng,
         )
@@ -848,6 +849,7 @@ class RushGameView:
             ViewContext(assets_dir=state.assets_dir),
             texture_cache=state.texture_cache,
             config=state.config,
+            console=state.console,
             audio=state.audio,
             audio_rng=state.rng,
         )
@@ -905,6 +907,7 @@ class TypoShooterGameView:
             ViewContext(assets_dir=state.assets_dir),
             texture_cache=state.texture_cache,
             config=state.config,
+            console=state.console,
             audio=state.audio,
             audio_rng=state.rng,
         )
@@ -962,6 +965,7 @@ class TutorialGameView:
             ViewContext(assets_dir=state.assets_dir),
             texture_cache=state.texture_cache,
             config=state.config,
+            console=state.console,
             audio=state.audio,
             audio_rng=state.rng,
             demo_mode_active=state.demo_enabled,
@@ -1011,6 +1015,7 @@ class QuestGameView:
             ViewContext(assets_dir=state.assets_dir),
             texture_cache=state.texture_cache,
             config=state.config,
+            console=state.console,
             audio=state.audio,
             audio_rng=state.rng,
             demo_mode_active=state.demo_enabled,

crimson/gameplay.py

@@ -159,8 +159,11 @@ class BonusHudSlot:
     bonus_id: int = 0
     label: str = ""
     icon_id: int = -1
+    slide_x: float = -184.0
     timer_ref: _TimerRef | None = None
     timer_ref_alt: _TimerRef | None = None
+    timer_value: float = 0.0
+    timer_value_alt: float = 0.0
 
 
 BONUS_HUD_SLOT_COUNT = 16
@@ -199,8 +202,11 @@ class BonusHudState:
         slot.bonus_id = int(bonus_id)
         slot.label = label
         slot.icon_id = int(icon_id)
+        slot.slide_x = -184.0
         slot.timer_ref = timer_ref
         slot.timer_ref_alt = timer_ref_alt
+        slot.timer_value = 0.0
+        slot.timer_value_alt = 0.0
 
 
 @dataclass(slots=True)
@@ -358,11 +364,49 @@ class BonusPool:
             return None
 
         rng = state.rng
-        if rng.rand() % 9 != 1:
-            if not any(perk_active(player, PerkId.BONUS_MAGNET) for player in players):
-                return None
-            if rng.rand() % 10 != 2:
-                return None
+        # Native special-case: while any player has Pistol, 3/4 chance to force a Weapon drop.
+        if players and any(int(player.weapon_id) == int(WeaponId.PISTOL) for player in players):
+            if (int(rng.rand()) & 3) < 3:
+                entry = self.spawn_at_pos(
+                    pos_x,
+                    pos_y,
+                    state=state,
+                    players=players,
+                    world_width=world_width,
+                    world_height=world_height,
+                )
+                if entry is None:
+                    return None
+
+                entry.bonus_id = int(BonusId.WEAPON)
+                weapon_id = int(weapon_pick_random_available(state))
+                entry.amount = int(weapon_id)
+                if weapon_id == int(WeaponId.PISTOL):
+                    weapon_id = int(weapon_pick_random_available(state))
+                    entry.amount = int(weapon_id)
+
+                matches = sum(1 for bonus in self._entries if bonus.bonus_id == entry.bonus_id)
+                if matches > 1:
+                    self._clear_entry(entry)
+                    return None
+
+                if entry.amount == int(WeaponId.PISTOL) or (players and perk_active(players[0], PerkId.MY_FAVOURITE_WEAPON)):
+                    self._clear_entry(entry)
+                    return None
+
+                return entry
+
+        base_roll = int(rng.rand())
+        if base_roll % 9 != 1:
+            allow_without_magnet = False
+            if players and int(players[0].weapon_id) == int(WeaponId.PISTOL):
+                allow_without_magnet = int(rng.rand()) % 5 == 1
+
+            if not allow_without_magnet:
+                if not (players and perk_active(players[0], PerkId.BONUS_MAGNET)):
+                    return None
+                if int(rng.rand()) % 10 != 2:
+                    return None
 
         entry = self.spawn_at_pos(
             pos_x,
@@ -377,11 +421,9 @@ class BonusPool:
 
         if entry.bonus_id == int(BonusId.WEAPON):
             near_sq = BONUS_WEAPON_NEAR_RADIUS * BONUS_WEAPON_NEAR_RADIUS
-            for player in players:
-                if _distance_sq(pos_x, pos_y, player.pos_x, player.pos_y) < near_sq:
-                    entry.bonus_id = int(BonusId.POINTS)
-                    entry.amount = 100
-                    break
+            if players and _distance_sq(pos_x, pos_y, players[0].pos_x, players[0].pos_y) < near_sq:
+                entry.bonus_id = int(BonusId.POINTS)
+                entry.amount = 100
 
         if entry.bonus_id != int(BonusId.POINTS):
             matches = sum(1 for bonus in self._entries if bonus.bonus_id == entry.bonus_id)
@@ -390,10 +432,9 @@ class BonusPool:
                 return None
 
         if entry.bonus_id == int(BonusId.WEAPON):
-            for player in players:
-                if entry.amount == player.weapon_id:
-                    self._clear_entry(entry)
-                    return None
+            if players and entry.amount == players[0].weapon_id:
+                self._clear_entry(entry)
+                return None
 
         return entry
 
@@ -431,7 +472,7 @@ class BonusPool:
                         player,
                         BonusId(entry.bonus_id),
                         amount=entry.amount,
-                        origin=player,
+                        origin=entry,
                         creatures=creatures,
                         players=players,
                         apply_creature_damage=apply_creature_damage,
@@ -933,8 +974,8 @@ def perk_apply(
             weapon_id = int(current)
             for _ in range(100):
                 candidate = int(weapon_pick_random_available(state))
-                if candidate != 0 and candidate != current:
-                    weapon_id = candidate
+                weapon_id = candidate
+                if candidate != int(WeaponId.PISTOL) and candidate != current:
                     break
             weapon_assign_player(owner, weapon_id, state=state)
             return
@@ -1626,7 +1667,7 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
 
     shot_cooldown = float(weapon.shot_cooldown) if weapon.shot_cooldown is not None else 0.0
     spread_heat_base = float(weapon.spread_heat_inc) if weapon.spread_heat_inc is not None else 0.0
-    if is_fire_bullets and fire_bullets_weapon is not None and fire_bullets_weapon.spread_heat_inc is not None:
+    if is_fire_bullets and pellet_count == 1 and fire_bullets_weapon is not None and fire_bullets_weapon.spread_heat_inc is not None:
         spread_heat_base = float(fire_bullets_weapon.spread_heat_inc)
 
     if is_fire_bullets and pellet_count == 1 and fire_bullets_weapon is not None:
@@ -1681,9 +1722,7 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
         shot_count = pellets
         meta = _projectile_meta_for_type_id(ProjectileTypeId.FIRE_BULLETS)
         for _ in range(pellets):
-            angle = shot_angle
-            if pellets > 1:
-                angle += float(int(state.rng.rand()) % 200 - 100) * 0.0015
+            angle = shot_angle + float(int(state.rng.rand()) % 200 - 100) * 0.0015
             state.projectiles.spawn(
                 pos_x=muzzle_x,
                 pos_y=muzzle_y,
@@ -1890,7 +1929,9 @@ def player_update(player: PlayerState, input_state: PlayerInput, dt: float, stat
     raw_move_x = float(input_state.move_x)
     raw_move_y = float(input_state.move_y)
     raw_mag = math.hypot(raw_move_x, raw_move_y)
-    moving_input = raw_mag > 0.2
+    # Demo/autoplay uses very small analog magnitudes to represent turn-in-place and
+    # heading alignment slowdown; don't apply a deadzone there.
+    moving_input = raw_mag > (0.0 if state.demo_mode_active else 0.2)
 
     if moving_input:
         inv = 1.0 / raw_mag if raw_mag > 1e-9 else 0.0
@@ -2323,8 +2364,8 @@ def bonus_apply(
     return
 
 
-def bonus_hud_update(state: GameplayState, players: list[PlayerState]) -> None:
-    """Refresh HUD slots based on current timer values."""
+def bonus_hud_update(state: GameplayState, players: list[PlayerState], *, dt: float = 0.0) -> None:
+    """Refresh HUD slots based on current timer values + advance slide animation."""
 
     def _timer_value(ref: _TimerRef | None) -> float:
         if ref is None:
@@ -2338,16 +2379,35 @@ def bonus_hud_update(state: GameplayState, players: list[PlayerState]) -> None:
             return float(getattr(players[idx], ref.key, 0.0) or 0.0)
         return 0.0
 
-    for slot in state.bonus_hud.slots:
+    player_count = len(players)
+    dt = max(0.0, float(dt))
+
+    for slot_index, slot in enumerate(state.bonus_hud.slots):
         if not slot.active:
             continue
-        timer = _timer_value(slot.timer_ref)
-        if slot.timer_ref_alt is not None:
-            timer = max(timer, _timer_value(slot.timer_ref_alt))
-        if timer <= 0.0:
+        timer = max(0.0, _timer_value(slot.timer_ref))
+        timer_alt = max(0.0, _timer_value(slot.timer_ref_alt)) if (slot.timer_ref_alt is not None and player_count > 1) else 0.0
+        slot.timer_value = float(timer)
+        slot.timer_value_alt = float(timer_alt)
+
+        if timer > 0.0 or timer_alt > 0.0:
+            slot.slide_x += dt * 350.0
+        else:
+            slot.slide_x -= dt * 320.0
+
+        if slot.slide_x > -2.0:
+            slot.slide_x = -2.0
+
+        if slot.slide_x < -184.0 and not any(other.active for other in state.bonus_hud.slots[slot_index + 1 :]):
             slot.active = False
+            slot.bonus_id = 0
+            slot.label = ""
+            slot.icon_id = -1
+            slot.slide_x = -184.0
             slot.timer_ref = None
             slot.timer_ref_alt = None
+            slot.timer_value = 0.0
+            slot.timer_value_alt = 0.0
 
 
 def bonus_telekinetic_update(
@@ -2398,7 +2458,7 @@ def bonus_telekinetic_update(
             player,
             BonusId(int(entry.bonus_id)),
             amount=int(entry.amount),
-            origin=player,
+            origin=entry,
             creatures=creatures,
             players=players,
             apply_creature_damage=apply_creature_damage,
@@ -2462,6 +2522,6 @@ def bonus_update(
         state.bonuses.freeze = max(0.0, state.bonuses.freeze - dt)
 
     if update_hud:
-        bonus_hud_update(state, players)
+        bonus_hud_update(state, players, dt=dt)
 
     return pickups

crimson/modes/base_gameplay_mode.py

@@ -8,14 +8,17 @@ import pyray as rl
 
 from grim.assets import PaqTextureCache
 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.view import ViewContext
 
+from ..gameplay import _creature_find_in_radius, perk_count_get
 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, load_hud_assets
+from ..ui.hud import HudAssets, draw_target_health_bar, load_hud_assets
 
 if TYPE_CHECKING:
     from ..persistence.save_status import GameStatus
@@ -45,6 +48,7 @@ class BaseGameplayMode:
         hardcore: bool = False,
         texture_cache: PaqTextureCache | None = None,
         config: CrimsonConfig | None = None,
+        console: ConsoleState | None = None,
         audio: AudioState | None = None,
         audio_rng: random.Random | None = None,
     ) -> None:
@@ -54,7 +58,9 @@ class BaseGameplayMode:
         self._small: SmallFontData | None = None
         self._hud_assets: HudAssets | None = None
 
+        self._default_game_mode_id = int(default_game_mode_id)
         self._config = config
+        self._console = console
         self._base_dir = config.path.parent if config is not None else Path.cwd()
 
         self.close_requested = False
@@ -90,6 +96,74 @@ class BaseGameplayMode:
         self._last_dt_ms = 0.0
         self._screen_fade: _ScreenFade | None = None
 
+    def _cvar_float(self, name: str, default: float = 0.0) -> float:
+        console = self._console
+        if console is None:
+            return float(default)
+        cvar = console.cvars.get(name)
+        if cvar is None:
+            return float(default)
+        return float(cvar.value_f)
+
+    def _hud_small_indicators(self) -> bool:
+        return self._cvar_float("cv_uiSmallIndicators", 0.0) != 0.0
+
+    def _config_game_mode_id(self) -> int:
+        config = self._config
+        if config is None:
+            return int(self._default_game_mode_id)
+        try:
+            value = config.data.get("game_mode", self._default_game_mode_id)
+            return int(value or self._default_game_mode_id)
+        except Exception:
+            return int(self._default_game_mode_id)
+
+    def _draw_target_health_bar(self, *, alpha: float = 1.0) -> None:
+        creatures = getattr(self._creatures, "entries", [])
+        if not creatures:
+            return
+
+        if perk_count_get(self._player, PerkId.DOCTOR) <= 0:
+            return
+
+        target_idx = _creature_find_in_radius(
+            creatures,
+            pos_x=float(getattr(self._player, "aim_x", 0.0)),
+            pos_y=float(getattr(self._player, "aim_y", 0.0)),
+            radius=12.0,
+            start_index=0,
+        )
+        if target_idx == -1:
+            return
+
+        creature = creatures[target_idx]
+        if not bool(getattr(creature, "active", False)):
+            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:
+            return
+
+        ratio = hp / max_hp
+        if ratio < 0.0:
+            ratio = 0.0
+        if ratio > 1.0:
+            ratio = 1.0
+
+        x0, y0 = self._world.world_to_screen(float(creature.x) - 32.0, float(creature.y) + 32.0)
+        x1, _y1 = self._world.world_to_screen(float(creature.x) + 32.0, float(creature.y) + 32.0)
+        width = float(x1) - float(x0)
+        if width <= 1e-3:
+            return
+        draw_target_health_bar(
+            x=float(x0),
+            y=float(y0),
+            width=width,
+            ratio=ratio,
+            alpha=float(alpha),
+            scale=width / 64.0,
+        )
+
     def _bind_world(self) -> None:
         self._state = self._world.state
         self._creatures = self._world.creatures