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

crimson/creatures/runtime.py

@@ -14,6 +14,7 @@ from dataclasses import dataclass, replace
 import math
 from typing import Callable, Sequence
 
+from grim.math import clamp, distance_sq
 from grim.rand import Crand
 from ..effects import FxQueue, FxQueueRotated
 from ..gameplay import GameplayState, PlayerState, award_experience, perk_active
@@ -62,14 +63,6 @@ CREATURE_CORPSE_DESPAWN_HITBOX = -10.0
 CREATURE_DEATH_SLIDE_SCALE = 9.0
 
 
-def _clamp(value: float, lo: float, hi: float) -> float:
-    if value < lo:
-        return lo
-    if value > hi:
-        return hi
-    return value
-
-
 def _wrap_angle(angle: float) -> float:
     return (angle + math.pi) % math.tau - math.pi
 
@@ -85,12 +78,6 @@ def _angle_approach(current: float, target: float, rate: float, dt: float) -> fl
     return _wrap_angle(current)
 
 
-def _distance_sq(x0: float, y0: float, x1: float, y1: float) -> float:
-    dx = x1 - x0
-    dy = y1 - y0
-    return dx * dx + dy * dy
-
-
 def _owner_id_to_player_index(owner_id: int) -> int | None:
     # Native uses `-1/-2/-3/-4` for player indices and `-100` as a player-owned sentinel.
     if owner_id == -100:
@@ -136,8 +123,8 @@ class CreatureState:
     attack_cooldown: float = 0.0
     reward_value: float = 0.0
 
-    # Contact damage gate.
-    collision_flag: int = 0
+    # Plaguebearer infection state (native: `collision_flag` byte).
+    plague_infected: bool = False
     collision_timer: float = CONTACT_DAMAGE_PERIOD
     hitbox_size: float = CREATURE_HITBOX_ALIVE
 
@@ -174,6 +161,182 @@ class CreatureUpdateResult:
     sfx: tuple[str, ...] = ()
 
 
+@dataclass(slots=True)
+class _CreatureInteractionCtx:
+    pool: CreaturePool
+    creature_index: int
+    creature: CreatureState
+    state: GameplayState
+    players: list[PlayerState]
+    player: PlayerState
+    dt: float
+    rand: Callable[[], int]
+    detail_preset: int
+    world_width: float
+    world_height: float
+    fx_queue: FxQueue | None
+    fx_queue_rotated: FxQueueRotated | None
+    deaths: list[CreatureDeath]
+    sfx: list[str]
+    skip_creature: bool = False
+    contact_dist_sq: float = 0.0
+
+
+_CreatureInteractionStep = Callable[[_CreatureInteractionCtx], None]
+
+
+def _creature_interaction_plaguebearer_spread(ctx: _CreatureInteractionCtx) -> None:
+    if ctx.players and perk_active(ctx.players[0], PerkId.PLAGUEBEARER) and int(ctx.state.plaguebearer_infection_count) < 0x3C:
+        ctx.pool._plaguebearer_spread_infection(ctx.creature_index)
+
+
+def _creature_interaction_energizer_eat(ctx: _CreatureInteractionCtx) -> None:
+    creature = ctx.creature
+    if float(ctx.state.bonuses.energizer) <= 0.0:
+        return
+    if float(creature.max_hp) >= 380.0:
+        return
+    if float(ctx.player.health) <= 0.0:
+        return
+
+    eat_dist_sq = distance_sq(creature.x, creature.y, ctx.player.pos_x, ctx.player.pos_y)
+    if eat_dist_sq >= 20.0 * 20.0:
+        return
+
+    creature.x = clamp(creature.x - creature.vel_x * ctx.dt, 0.0, float(ctx.world_width))
+    creature.y = clamp(creature.y - creature.vel_y * ctx.dt, 0.0, float(ctx.world_height))
+
+    ctx.state.effects.spawn_burst(
+        pos_x=float(creature.x),
+        pos_y=float(creature.y),
+        count=6,
+        rand=ctx.rand,
+        detail_preset=int(ctx.detail_preset),
+    )
+    ctx.sfx.append("sfx_ui_bonus")
+
+    prev_guard = bool(ctx.state.bonus_spawn_guard)
+    ctx.state.bonus_spawn_guard = True
+    creature.last_hit_owner_id = -1 - int(ctx.player.index)
+    ctx.deaths.append(
+        ctx.pool.handle_death(
+            ctx.creature_index,
+            state=ctx.state,
+            players=ctx.players,
+            rand=ctx.rand,
+            detail_preset=int(ctx.detail_preset),
+            world_width=float(ctx.world_width),
+            world_height=float(ctx.world_height),
+            fx_queue=ctx.fx_queue,
+            keep_corpse=False,
+        )
+    )
+    ctx.state.bonus_spawn_guard = prev_guard
+    ctx.skip_creature = True
+
+
+def _creature_interaction_contact_damage(ctx: _CreatureInteractionCtx) -> None:
+    creature = ctx.creature
+    if float(ctx.state.bonuses.energizer) > 0.0:
+        return
+
+    ctx.contact_dist_sq = distance_sq(creature.x, creature.y, ctx.player.pos_x, ctx.player.pos_y)
+    contact_r = (float(creature.size) + float(ctx.player.size)) * 0.25 + 20.0
+    in_contact = ctx.contact_dist_sq <= contact_r * contact_r
+    if not in_contact:
+        return
+
+    creature.collision_timer -= ctx.dt
+    if creature.collision_timer >= 0.0:
+        return
+
+    creature.collision_timer += CONTACT_DAMAGE_PERIOD
+
+    mr_melee_killed = False
+    mr_melee_death_start_needed = False
+    if perk_active(ctx.player, PerkId.MR_MELEE):
+        mr_melee_death_start_needed = creature.hp > 0.0 and creature.hitbox_size == CREATURE_HITBOX_ALIVE
+
+        from .damage import creature_apply_damage
+
+        mr_melee_killed = creature_apply_damage(
+            creature,
+            damage_amount=25.0,
+            damage_type=2,
+            impulse_x=0.0,
+            impulse_y=0.0,
+            owner_id=-1 - int(ctx.player.index),
+            dt=ctx.dt,
+            players=ctx.players,
+            rand=ctx.rand,
+        )
+
+    if float(ctx.player.shield_timer) <= 0.0:
+        if perk_active(ctx.player, PerkId.TOXIC_AVENGER):
+            creature.flags |= CreatureFlags.SELF_DAMAGE_TICK | CreatureFlags.SELF_DAMAGE_TICK_STRONG
+        elif perk_active(ctx.player, PerkId.VEINS_OF_POISON):
+            creature.flags |= CreatureFlags.SELF_DAMAGE_TICK
+
+    player_take_damage(ctx.state, ctx.player, float(creature.contact_damage), dt=ctx.dt, rand=ctx.rand)
+
+    if ctx.fx_queue is not None:
+        dx = float(ctx.player.pos_x) - float(creature.x)
+        dy = float(ctx.player.pos_y) - float(creature.y)
+        dist = math.hypot(dx, dy)
+        if dist > 1e-9:
+            dx /= dist
+            dy /= dist
+        else:
+            dx = 0.0
+            dy = 0.0
+        ctx.fx_queue.add_random(
+            pos_x=float(ctx.player.pos_x) + dx * 3.0,
+            pos_y=float(ctx.player.pos_y) + dy * 3.0,
+            rand=ctx.rand,
+        )
+
+    if mr_melee_killed and mr_melee_death_start_needed:
+        ctx.deaths.append(
+            ctx.pool.handle_death(
+                ctx.creature_index,
+                state=ctx.state,
+                players=ctx.players,
+                rand=ctx.rand,
+                detail_preset=int(ctx.detail_preset),
+                world_width=float(ctx.world_width),
+                world_height=float(ctx.world_height),
+                fx_queue=ctx.fx_queue,
+            )
+        )
+        if creature.active:
+            ctx.pool._tick_dead(
+                creature,
+                dt=ctx.dt,
+                world_width=float(ctx.world_width),
+                world_height=float(ctx.world_height),
+                fx_queue_rotated=ctx.fx_queue_rotated,
+            )
+        ctx.skip_creature = True
+
+
+def _creature_interaction_plaguebearer_contact_flag(ctx: _CreatureInteractionCtx) -> None:
+    if float(ctx.state.bonuses.energizer) > 0.0:
+        return
+
+    creature = ctx.creature
+    if bool(ctx.player.plaguebearer_active) and float(creature.hp) < 150.0 and int(ctx.state.plaguebearer_infection_count) < 0x32:
+        if ctx.contact_dist_sq < 30.0 * 30.0:
+            creature.plague_infected = True
+
+
+_CREATURE_INTERACTION_STEPS: tuple[_CreatureInteractionStep, ...] = (
+    _creature_interaction_plaguebearer_spread,
+    _creature_interaction_energizer_eat,
+    _creature_interaction_contact_damage,
+    _creature_interaction_plaguebearer_contact_flag,
+)
+
+
 class CreaturePool:
     def __init__(self, *, size: int = CREATURE_POOL_SIZE, env: SpawnEnv | None = None) -> None:
         self._entries = [CreatureState() for _ in range(int(size))]
@@ -211,10 +374,10 @@ class CreaturePool:
                 continue
 
             if math.hypot(float(creature.x) - float(origin.x), float(creature.y) - float(origin.y)) < 45.0:
-                if creature.collision_flag != 0 and float(origin.hp) < 150.0:
-                    origin.collision_flag = 1
-                if origin.collision_flag != 0 and float(creature.hp) < 150.0:
-                    creature.collision_flag = 1
+                if creature.plague_infected and float(origin.hp) < 150.0:
+                    origin.plague_infected = True
+                if origin.plague_infected and float(creature.hp) < 150.0:
+                    creature.plague_infected = True
                 return
 
     def _alloc_slot(self, *, rand: Callable[[], int] | None = None) -> int:
@@ -403,11 +566,36 @@ class CreaturePool:
                 creature.vel_y = 0.0
                 continue
 
+            poison_killed = False
             if creature.flags & CreatureFlags.SELF_DAMAGE_TICK_STRONG:
-                creature.hp -= dt * 180.0
+                from .damage import creature_apply_damage
+
+                poison_killed = creature_apply_damage(
+                    creature,
+                    damage_amount=dt * 180.0,
+                    damage_type=0,
+                    impulse_x=0.0,
+                    impulse_y=0.0,
+                    owner_id=int(creature.last_hit_owner_id),
+                    dt=dt,
+                    players=players,
+                    rand=rand,
+                )
             elif creature.flags & CreatureFlags.SELF_DAMAGE_TICK:
-                creature.hp -= dt * 60.0
-            if creature.hp <= 0.0:
+                from .damage import creature_apply_damage
+
+                poison_killed = creature_apply_damage(
+                    creature,
+                    damage_amount=dt * 60.0,
+                    damage_type=0,
+                    impulse_x=0.0,
+                    impulse_y=0.0,
+                    owner_id=int(creature.last_hit_owner_id),
+                    dt=dt,
+                    players=players,
+                    rand=rand,
+                )
+            if poison_killed:
                 deaths.append(
                     self.handle_death(
                         idx,
@@ -430,7 +618,7 @@ class CreaturePool:
                     )
                 continue
 
-            if creature.collision_flag != 0:
+            if creature.plague_infected:
                 creature.collision_timer -= float(dt)
                 if creature.collision_timer < 0.0:
                     creature.collision_timer += CONTACT_DAMAGE_PERIOD
@@ -531,7 +719,7 @@ class CreaturePool:
                             )
                         continue
 
-                if (float(state.bonuses.energizer) > 0.0 and float(creature.max_hp) < 500.0) or creature.collision_flag != 0:
+                if (float(state.bonuses.energizer) > 0.0 and float(creature.max_hp) < 500.0) or creature.plague_infected:
                     creature.target_heading = _wrap_angle(float(creature.target_heading) + math.pi)
 
                 turn_rate = float(creature.move_speed) * CREATURE_TURN_RATE_SCALE
@@ -547,16 +735,16 @@ class CreaturePool:
                         dir_y = math.sin(creature.heading - math.pi / 2.0)
                         creature.vel_x = dir_x * speed
                         creature.vel_y = dir_y * speed
-                        creature.x = _clamp(creature.x + creature.vel_x * dt, 0.0, float(world_width))
-                        creature.y = _clamp(creature.y + creature.vel_y * dt, 0.0, float(world_height))
+                        creature.x = clamp(creature.x + creature.vel_x * dt, 0.0, float(world_width))
+                        creature.y = clamp(creature.y + creature.vel_y * dt, 0.0, float(world_height))
                 else:
                     # Spawner/short-strip creatures clamp to bounds using `size` as a radius; most are stationary
                     # unless ANIM_LONG_STRIP is set (see creature_update_all).
                     radius = max(0.0, float(creature.size))
                     max_x = max(radius, float(world_width) - radius)
                     max_y = max(radius, float(world_height) - radius)
-                    creature.x = _clamp(creature.x, radius, max_x)
-                    creature.y = _clamp(creature.y, radius, max_y)
+                    creature.x = clamp(creature.x, radius, max_x)
+                    creature.y = clamp(creature.y, radius, max_y)
                     if (creature.flags & CreatureFlags.ANIM_LONG_STRIP) == 0:
                         creature.vel_x = 0.0
                         creature.vel_y = 0.0
@@ -566,130 +754,32 @@ class CreaturePool:
                         dir_y = math.sin(creature.heading - math.pi / 2.0)
                         creature.vel_x = dir_x * speed
                         creature.vel_y = dir_y * speed
-                        creature.x = _clamp(creature.x + creature.vel_x * dt, radius, max_x)
-                        creature.y = _clamp(creature.y + creature.vel_y * dt, radius, max_y)
-
-            if (
-                players
-                and perk_active(players[0], PerkId.PLAGUEBEARER)
-                and int(state.plaguebearer_infection_count) < 0x3C
-            ):
-                self._plaguebearer_spread_infection(idx)
-
-            if float(state.bonuses.energizer) > 0.0 and float(creature.max_hp) < 380.0 and float(player.health) > 0.0:
-                eat_dist_sq = _distance_sq(creature.x, creature.y, player.pos_x, player.pos_y)
-                if eat_dist_sq < 20.0 * 20.0:
-                    creature.x = _clamp(creature.x - creature.vel_x * dt, 0.0, float(world_width))
-                    creature.y = _clamp(creature.y - creature.vel_y * dt, 0.0, float(world_height))
-
-                    state.effects.spawn_burst(
-                        pos_x=float(creature.x),
-                        pos_y=float(creature.y),
-                        count=6,
-                        rand=rand,
-                        detail_preset=int(detail_preset),
-                    )
-                    sfx.append("sfx_ui_bonus")
-
-                    prev_guard = bool(state.bonus_spawn_guard)
-                    state.bonus_spawn_guard = True
-                    creature.last_hit_owner_id = -1 - int(player.index)
-                    deaths.append(
-                        self.handle_death(
-                            idx,
-                            state=state,
-                            players=players,
-                            rand=rand,
-                            detail_preset=int(detail_preset),
-                            world_width=world_width,
-                            world_height=world_height,
-                            fx_queue=fx_queue,
-                            keep_corpse=False,
-                        )
-                    )
-                    state.bonus_spawn_guard = prev_guard
-                    continue
-
-            # Contact damage throttle. While Energizer is active, the native suppresses
-            # contact/melee interactions for most creatures (and instead allows "eat" kills).
-            if float(state.bonuses.energizer) <= 0.0:
-                dist_sq = _distance_sq(creature.x, creature.y, player.pos_x, player.pos_y)
-                contact_r = (float(creature.size) + float(player.size)) * 0.25 + 20.0
-                in_contact = dist_sq <= contact_r * contact_r
-                if in_contact:
-                    creature.collision_timer -= dt
-                    if creature.collision_timer < 0.0:
-                        creature.collision_timer += CONTACT_DAMAGE_PERIOD
-                        if perk_active(player, PerkId.MR_MELEE):
-                            death_start_needed = creature.hp > 0.0 and creature.hitbox_size == CREATURE_HITBOX_ALIVE
-
-                            from .damage import creature_apply_damage
-
-                            killed = creature_apply_damage(
-                                creature,
-                                damage_amount=25.0,
-                                damage_type=2,
-                                impulse_x=0.0,
-                                impulse_y=0.0,
-                                owner_id=-1 - int(player.index),
-                                dt=dt,
-                                players=players,
-                                rand=rand,
-                            )
-                            if killed and death_start_needed:
-                                deaths.append(
-                                    self.handle_death(
-                                        idx,
-                                        state=state,
-                                        players=players,
-                                        rand=rand,
-                                        detail_preset=int(detail_preset),
-                                        world_width=world_width,
-                                        world_height=world_height,
-                                        fx_queue=fx_queue,
-                                    )
-                                )
-                                if creature.active:
-                                    self._tick_dead(
-                                        creature,
-                                        dt=dt,
-                                        world_width=world_width,
-                                        world_height=world_height,
-                                        fx_queue_rotated=fx_queue_rotated,
-                                    )
-                                continue
-
-                        if float(player.shield_timer) <= 0.0:
-                            if perk_active(player, PerkId.TOXIC_AVENGER):
-                                creature.flags |= (
-                                    CreatureFlags.SELF_DAMAGE_TICK | CreatureFlags.SELF_DAMAGE_TICK_STRONG
-                                )
-                            elif perk_active(player, PerkId.VEINS_OF_POISON):
-                                creature.flags |= CreatureFlags.SELF_DAMAGE_TICK
-                        player_take_damage(state, player, float(creature.contact_damage), dt=dt, rand=rand)
-                        if fx_queue is not None:
-                            dx = float(player.pos_x) - float(creature.x)
-                            dy = float(player.pos_y) - float(creature.y)
-                            dist = math.hypot(dx, dy)
-                            if dist > 1e-9:
-                                dx /= dist
-                                dy /= dist
-                            else:
-                                dx = 0.0
-                                dy = 0.0
-                            fx_queue.add_random(
-                                pos_x=float(player.pos_x) + dx * 3.0,
-                                pos_y=float(player.pos_y) + dy * 3.0,
-                                rand=rand,
-                            )
-
-                if (
-                    bool(player.plaguebearer_active)
-                    and float(creature.hp) < 150.0
-                    and int(state.plaguebearer_infection_count) < 0x32
-                    and dist_sq < 30.0 * 30.0
-                ):
-                    creature.collision_flag = 1
+                        creature.x = clamp(creature.x + creature.vel_x * dt, radius, max_x)
+                        creature.y = clamp(creature.y + creature.vel_y * dt, radius, max_y)
+
+            interaction_ctx = _CreatureInteractionCtx(
+                pool=self,
+                creature_index=int(idx),
+                creature=creature,
+                state=state,
+                players=players,
+                player=player,
+                dt=dt,
+                rand=rand,
+                detail_preset=int(detail_preset),
+                world_width=float(world_width),
+                world_height=float(world_height),
+                fx_queue=fx_queue,
+                fx_queue_rotated=fx_queue_rotated,
+                deaths=deaths,
+                sfx=sfx,
+            )
+            for step in _CREATURE_INTERACTION_STEPS:
+                step(interaction_ctx)
+                if interaction_ctx.skip_creature:
+                    break
+            if interaction_ctx.skip_creature:
+                continue
 
             if (not frozen_by_evil_eyes) and (creature.flags & (CreatureFlags.RANGED_ATTACK_SHOCK | CreatureFlags.RANGED_ATTACK_VARIANT)):
                 # Ported from creature_update_all (see `analysis/ghidra/raw/crimsonland.exe_decompiled.c`
@@ -862,7 +952,7 @@ class CreaturePool:
         entry.tint_b = float(tint[2])
         entry.tint_a = float(tint[3])
 
-        entry.collision_flag = 0
+        entry.plague_infected = False
         entry.collision_timer = CONTACT_DAMAGE_PERIOD
         entry.hitbox_size = CREATURE_HITBOX_ALIVE
 
@@ -909,8 +999,8 @@ class CreaturePool:
                 dir_y = math.sin(creature.heading - math.pi / 2.0)
                 creature.vel_x = dir_x * new_hitbox * float(dt) * CREATURE_DEATH_SLIDE_SCALE
                 creature.vel_y = dir_y * new_hitbox * float(dt) * CREATURE_DEATH_SLIDE_SCALE
-                creature.x = _clamp(creature.x - creature.vel_x, 0.0, float(world_width))
-                creature.y = _clamp(creature.y - creature.vel_y, 0.0, float(world_height))
+                creature.x = clamp(creature.x - creature.vel_x, 0.0, float(world_width))
+                creature.y = clamp(creature.y - creature.vel_y, 0.0, float(world_height))
             else:
                 creature.vel_x = 0.0
                 creature.vel_y = 0.0

crimson/creatures/spawn.py

@@ -27,6 +27,7 @@ __all__ = [
     "CreatureFlags",
     "CreatureInit",
     "CreatureTypeId",
+    "RANDOM_HEADING_SENTINEL",
     "SpawnId",
     "SPAWN_ID_TO_TEMPLATE",
     "SPAWN_TEMPLATES",
@@ -54,6 +55,9 @@ __all__ = [
 Tint = tuple[float | None, float | None, float | None, float | None]
 TintRGBA = tuple[float, float, float, float]
 
+# Heading sentinel that forces randomized heading in `creature_spawn_template`.
+RANDOM_HEADING_SENTINEL = -100.0
+
 
 class CreatureTypeId(IntEnum):
     ZOMBIE = 0
@@ -1366,7 +1370,7 @@ class CreatureInit:
     pos_y: float
 
     # Headings are in radians. The original seeds a random heading early, then overwrites it
-    # at the end with the function argument (or a randomized argument for `-100.0`).
+    # at the end with the function argument (or a randomized argument for `RANDOM_HEADING_SENTINEL`).
     heading: float
 
     phase_seed: float
@@ -1648,9 +1652,9 @@ class PlanBuilder:
         spawn_slots: list[SpawnSlotInit] = []
         effects: list[BurstEffect] = []
 
-        # `heading == -100.0` uses a randomized heading.
+        # `heading == RANDOM_HEADING_SENTINEL` uses a randomized heading.
         final_heading = heading
-        if final_heading == -100.0:
+        if final_heading == RANDOM_HEADING_SENTINEL:
             final_heading = float(rng.rand() % 628) * 0.01
 
         # Base initialization always consumes one rand() for a transient heading value.