crimsonland 0.1.0.dev4__py3-none-any.whl → 0.1.0.dev6__py3-none-any.whl

crimson/projectiles.py

@@ -112,7 +112,7 @@ class SecondaryProjectile:
     vel_y: float = 0.0
     type_id: int = 0
     owner_id: int = -100
-    lifetime: float = 0.0
+    trail_timer: float = 0.0
     target_id: int = -1
 
 
@@ -220,6 +220,7 @@ class ProjectilePool:
         damage_scale_by_type: dict[int, float] | None = None,
         damage_scale_default: float = 1.0,
         ion_aoe_scale: float = 1.0,
+        detail_preset: int = 5,
         rng: Callable[[], int] | None = None,
         runtime_state: object | None = None,
         players: list[PlayerDamageable] | None = None,
@@ -280,6 +281,12 @@ class ProjectilePool:
         if rng is None:
             rng = _rng_zero
 
+        effects = None
+        sfx_queue = None
+        if runtime_state is not None:
+            effects = getattr(runtime_state, "effects", None)
+            sfx_queue = getattr(runtime_state, "sfx_queue", None)
+
         hits: list[tuple[int, float, float, float, float, float, float]] = []
         margin = 64.0
 
@@ -292,6 +299,170 @@ class ProjectilePool:
         def _damage_type_for() -> int:
             return 1
 
+        def _spawn_ion_hit_effects(type_id: int, pos_x: float, pos_y: float) -> None:
+            if effects is None or not hasattr(effects, "spawn"):
+                return
+
+            ring_scale = 0.0
+            ring_strength = 0.0
+            burst_scale = 0.0
+            if type_id == int(ProjectileTypeId.ION_MINIGUN):
+                ring_scale = 1.5
+                ring_strength = 0.1
+                burst_scale = 0.8
+            elif type_id == int(ProjectileTypeId.ION_RIFLE):
+                ring_scale = 1.2
+                ring_strength = 0.4
+                burst_scale = 1.2
+            elif type_id == int(ProjectileTypeId.ION_CANNON):
+                ring_scale = 1.0
+                ring_strength = 1.0
+                burst_scale = 2.2
+                if isinstance(sfx_queue, list):
+                    sfx_queue.append("sfx_shockwave")
+            else:
+                return
+
+            detail = int(detail_preset)
+
+            # Port of `FUN_0042f270(pos, ring_scale, ring_strength)`: ring burst (effect_id=1).
+            effects.spawn(
+                effect_id=1,
+                pos_x=float(pos_x),
+                pos_y=float(pos_y),
+                vel_x=0.0,
+                vel_y=0.0,
+                rotation=0.0,
+                scale=1.0,
+                half_width=4.0,
+                half_height=4.0,
+                age=0.0,
+                lifetime=float(ring_strength) * 0.8,
+                flags=0x19,
+                color_r=0.6,
+                color_g=0.6,
+                color_b=0.9,
+                color_a=1.0,
+                rotation_step=0.0,
+                scale_step=float(ring_scale) * 45.0,
+                detail_preset=detail,
+            )
+
+            # Port of `FUN_0042f540(pos, burst_scale)`: burst cloud (effect_id=0).
+            burst = float(burst_scale) * 0.8
+            lifetime = min(burst * 0.7, 1.1)
+            half = burst * 32.0
+            count = int(half)
+            if detail < 3:
+                count //= 2
+
+            for _ in range(max(0, count)):
+                rotation = float(int(rng()) & 0x7F) * 0.049087387
+                vel_x = float((int(rng()) & 0x7F) - 0x40) * burst * 1.4
+                vel_y = float((int(rng()) & 0x7F) - 0x40) * burst * 1.4
+                scale_step = (float(int(rng()) % 100) * 0.01 + 0.1) * burst
+                effects.spawn(
+                    effect_id=0,
+                    pos_x=float(pos_x),
+                    pos_y=float(pos_y),
+                    vel_x=vel_x,
+                    vel_y=vel_y,
+                    rotation=rotation,
+                    scale=1.0,
+                    half_width=half,
+                    half_height=half,
+                    age=0.0,
+                    lifetime=float(lifetime),
+                    flags=0x1D,
+                    color_r=0.4,
+                    color_g=0.5,
+                    color_b=1.0,
+                    color_a=0.5,
+                    rotation_step=0.0,
+                    scale_step=scale_step,
+                    detail_preset=detail,
+                )
+
+        def _spawn_plasma_cannon_hit_effects(pos_x: float, pos_y: float) -> None:
+            """Port of `projectile_update` Plasma Cannon hit extras.
+
+            Native does:
+            - `sfx_play_panned(sfx_explosion_medium)`
+            - `sfx_play_panned(sfx_shockwave)`
+            - `FUN_0042f330(pos, 1.5, 1.0)`
+            - `FUN_0042f330(pos, 1.0, 1.0)`
+            """
+
+            if effects is None or not hasattr(effects, "spawn"):
+                return
+
+            if isinstance(sfx_queue, list):
+                sfx_queue.append("sfx_explosion_medium")
+                sfx_queue.append("sfx_shockwave")
+
+            detail = int(detail_preset)
+
+            def _spawn_ring(*, scale: float) -> None:
+                effects.spawn(
+                    effect_id=1,
+                    pos_x=float(pos_x),
+                    pos_y=float(pos_y),
+                    vel_x=0.0,
+                    vel_y=0.0,
+                    rotation=0.0,
+                    scale=1.0,
+                    half_width=4.0,
+                    half_height=4.0,
+                    age=0.1,
+                    lifetime=1.0,
+                    flags=0x19,
+                    color_r=0.9,
+                    color_g=0.6,
+                    color_b=0.3,
+                    color_a=1.0,
+                    rotation_step=0.0,
+                    scale_step=float(scale) * 45.0,
+                    detail_preset=detail,
+                )
+
+            _spawn_ring(scale=1.5)
+            _spawn_ring(scale=1.0)
+
+        def _spawn_splitter_hit_effects(pos_x: float, pos_y: float) -> None:
+            """Port of `FUN_0042f3f0(pos, 26.0, 3)` from the Splitter Gun hit branch."""
+
+            if effects is None or not hasattr(effects, "spawn"):
+                return
+
+            detail = int(detail_preset)
+            for _ in range(3):
+                angle = float(int(rng()) & 0x1FF) * (math.tau / 512.0)
+                radius = float(int(rng()) % 26)
+                jitter_age = -float(int(rng()) & 0xFF) * 0.0012
+                lifetime = 0.1 - jitter_age
+
+                effects.spawn(
+                    effect_id=0,
+                    pos_x=float(pos_x) + math.cos(angle) * radius,
+                    pos_y=float(pos_y) + math.sin(angle) * radius,
+                    vel_x=0.0,
+                    vel_y=0.0,
+                    rotation=0.0,
+                    scale=1.0,
+                    half_width=4.0,
+                    half_height=4.0,
+                    age=jitter_age,
+                    lifetime=lifetime,
+                    flags=0x19,
+                    color_r=1.0,
+                    color_g=0.9,
+                    color_b=0.1,
+                    color_a=1.0,
+                    rotation_step=0.0,
+                    scale_step=55.0,
+                    detail_preset=detail,
+                )
+
         def _apply_damage_to_creature(
             creature_index: int,
             damage: float,
@@ -476,54 +647,6 @@ class ProjectilePool:
                     acc_x = 0.0
                     acc_y = 0.0
 
-                    if proj.hits_players:
-                        hit_player_idx = None
-                        if players is not None:
-                            for idx, player in enumerate(players):
-                                if float(player.health) <= 0.0:
-                                    continue
-                                player_radius = _hit_radius_for(player)
-                                hit_r = proj.hit_radius + player_radius
-                                if _distance_sq(proj.pos_x, proj.pos_y, player.pos_x, player.pos_y) <= hit_r * hit_r:
-                                    hit_player_idx = idx
-                                    break
-
-                        if hit_player_idx is None:
-                            step += 3
-                            continue
-
-                        type_id = proj.type_id
-                        hit_x = float(proj.pos_x)
-                        hit_y = float(proj.pos_y)
-                        player = players[int(hit_player_idx)] if players is not None else None
-                        target_x = float(getattr(player, "pos_x", hit_x) if player is not None else hit_x)
-                        target_y = float(getattr(player, "pos_y", hit_y) if player is not None else hit_y)
-                        hits.append((type_id, proj.origin_x, proj.origin_y, hit_x, hit_y, target_x, target_y))
-
-                        if proj.life_timer != 0.25 and type_id not in (
-                            ProjectileTypeId.FIRE_BULLETS,
-                            ProjectileTypeId.GAUSS_GUN,
-                            ProjectileTypeId.BLADE_GUN,
-                        ):
-                            proj.life_timer = 0.25
-                            jitter = rng() & 3
-                            proj.pos_x += dir_x * float(jitter)
-                            proj.pos_y += dir_y * float(jitter)
-
-                        dist = math.hypot(proj.origin_x - proj.pos_x, proj.origin_y - proj.pos_y)
-                        if dist < 50.0:
-                            dist = 50.0
-
-                        damage_scale = _damage_scale(type_id)
-                        damage_amount = ((100.0 / dist) * damage_scale * 30.0 + 10.0) * 0.95
-                        if damage_amount > 0.0:
-                            if apply_player_damage is not None:
-                                apply_player_damage(int(hit_player_idx), float(damage_amount))
-                            elif players is not None:
-                                players[int(hit_player_idx)].health -= float(damage_amount)
-
-                        break
-
                     hit_idx = None
                     for idx, creature in enumerate(creatures):
                         if creature.hp <= 0.0:
@@ -537,6 +660,61 @@ class ProjectilePool:
                             break
 
                     if hit_idx is None:
+                        if proj.hits_players:
+                            hit_player_idx = None
+                            owner_id = int(proj.owner_id)
+                            owner_player_index = -1 - owner_id if owner_id < 0 and owner_id != -100 else None
+                            if players is not None:
+                                for idx, player in enumerate(players):
+                                    if owner_player_index is not None and idx == owner_player_index:
+                                        continue
+                                    if float(player.health) <= 0.0:
+                                        continue
+                                    player_radius = _hit_radius_for(player)
+                                    hit_r = proj.hit_radius + player_radius
+                                    if (
+                                        _distance_sq(proj.pos_x, proj.pos_y, player.pos_x, player.pos_y)
+                                        <= hit_r * hit_r
+                                    ):
+                                        hit_player_idx = idx
+                                        break
+
+                            if hit_player_idx is None:
+                                step += 3
+                                continue
+
+                            type_id = proj.type_id
+                            hit_x = float(proj.pos_x)
+                            hit_y = float(proj.pos_y)
+                            player = players[int(hit_player_idx)] if players is not None else None
+                            target_x = float(getattr(player, "pos_x", hit_x) if player is not None else hit_x)
+                            target_y = float(getattr(player, "pos_y", hit_y) if player is not None else hit_y)
+                            hits.append((type_id, proj.origin_x, proj.origin_y, hit_x, hit_y, target_x, target_y))
+
+                            if proj.life_timer != 0.25 and type_id not in (
+                                ProjectileTypeId.FIRE_BULLETS,
+                                ProjectileTypeId.GAUSS_GUN,
+                                ProjectileTypeId.BLADE_GUN,
+                            ):
+                                proj.life_timer = 0.25
+                                jitter = rng() & 3
+                                proj.pos_x += dir_x * float(jitter)
+                                proj.pos_y += dir_y * float(jitter)
+
+                            dist = math.hypot(proj.origin_x - proj.pos_x, proj.origin_y - proj.pos_y)
+                            if dist < 50.0:
+                                dist = 50.0
+
+                            damage_scale = _damage_scale(type_id)
+                            damage_amount = ((100.0 / dist) * damage_scale * 30.0 + 10.0) * 0.95
+                            if damage_amount > 0.0:
+                                if apply_player_damage is not None:
+                                    apply_player_damage(int(hit_player_idx), float(damage_amount))
+                                elif players is not None:
+                                    players[int(hit_player_idx)].health -= float(damage_amount)
+
+                            break
+
                         step += 3
                         continue
 
@@ -548,6 +726,7 @@ class ProjectilePool:
                             creature.flags |= CreatureFlags.SELF_DAMAGE_TICK
 
                     if type_id == ProjectileTypeId.SPLITTER_GUN:
+                        _spawn_splitter_hit_effects(proj.pos_x, proj.pos_y)
                         self.spawn(
                             pos_x=proj.pos_x,
                             pos_y=proj.pos_y,
@@ -598,6 +777,8 @@ class ProjectilePool:
                     if type_id == ProjectileTypeId.ION_RIFLE:
                         if runtime_state is not None and getattr(runtime_state, "shock_chain_projectile_id", -1) == proj_index:
                             proj.reserved = float(int(hit_idx) + 1)
+                    if type_id in (ProjectileTypeId.ION_MINIGUN, ProjectileTypeId.ION_RIFLE, ProjectileTypeId.ION_CANNON):
+                        _spawn_ion_hit_effects(int(type_id), target_x, target_y)
                     elif type_id == ProjectileTypeId.PLASMA_CANNON:
                         size = float(getattr(creature, "size", 50.0) or 50.0)
                         ring_radius = size * 0.5 + 1.0
@@ -617,6 +798,7 @@ class ProjectilePool:
                                 owner_id=-100,
                                 base_damage=plasma_meta,
                             )
+                        _spawn_plasma_cannon_hit_effects(proj.pos_x, proj.pos_y)
                     elif type_id == ProjectileTypeId.SHRINKIFIER:
                         if hasattr(creature, "size"):
                             new_size = float(getattr(creature, "size", 50.0) or 50.0) * 0.65
@@ -821,12 +1003,13 @@ class SecondaryProjectilePool:
         entry.pos_y = float(pos_y)
         entry.owner_id = int(owner_id)
         entry.target_id = -1
+        entry.trail_timer = 0.0
 
         if entry.type_id == 3:
+            # Detonation state: `vel_x` becomes the expansion timer and `vel_y` the scale.
             entry.vel_x = 0.0
-            entry.vel_y = 0.0
+            entry.vel_y = float(time_to_live)
             entry.speed = float(time_to_live)
-            entry.lifetime = 0.0
             return index
 
         # Effects.md: vel = cos/sin(angle - PI/2) * 90 (190 for type 2).
@@ -838,7 +1021,6 @@ class SecondaryProjectilePool:
         entry.vel_x = vx
         entry.vel_y = vy
         entry.speed = float(time_to_live)
-        entry.lifetime = 0.0
         return index
 
     def iter_active(self) -> list[SecondaryProjectile]:
@@ -873,6 +1055,7 @@ class SecondaryProjectilePool:
         rand = _rng_zero
         freeze_active = False
         effects = None
+        sprite_effects = None
         sfx_queue = None
         if runtime_state is not None:
             rng = getattr(runtime_state, "rng", None)
@@ -884,6 +1067,7 @@ class SecondaryProjectilePool:
                 freeze_active = True
 
             effects = getattr(runtime_state, "effects", None)
+            sprite_effects = getattr(runtime_state, "sprite_effects", None)
             sfx_queue = getattr(runtime_state, "sfx_queue", None)
 
         for entry in self._entries:
@@ -891,9 +1075,10 @@ class SecondaryProjectilePool:
                 continue
 
             if entry.type_id == 3:
-                entry.lifetime += dt * 3.0
-                t = entry.lifetime
-                scale = entry.speed
+                # Detonation: `vel_x` becomes the expansion timer (0..1) and `vel_y` the scale.
+                entry.vel_x += dt * 3.0
+                t = float(entry.vel_x)
+                scale = float(entry.vel_y)
                 if t > 1.0:
                     if fx_queue is not None:
                         fx_queue.add(
@@ -973,6 +1158,23 @@ class SecondaryProjectilePool:
 
                 entry.speed -= dt * 0.5
 
+            # Rocket smoke trail (`trail_timer` in crimsonland.exe).
+            entry.trail_timer -= (abs(float(entry.vel_x)) + abs(float(entry.vel_y))) * dt * 0.01
+            if entry.trail_timer < 0.0:
+                dir_x = math.cos(float(entry.angle) - math.pi / 2.0)
+                dir_y = math.sin(float(entry.angle) - math.pi / 2.0)
+                spawn_x = float(entry.pos_x) - dir_x * 9.0
+                spawn_y = float(entry.pos_y) - dir_y * 9.0
+                vel_x = math.cos(float(entry.angle) + math.pi / 2.0) * 90.0
+                vel_y = math.sin(float(entry.angle) + math.pi / 2.0) * 90.0
+                if sprite_effects is not None and hasattr(sprite_effects, "spawn"):
+                    sprite_id = sprite_effects.spawn(pos_x=spawn_x, pos_y=spawn_y, vel_x=vel_x, vel_y=vel_y, scale=14.0)
+                    try:
+                        sprite_effects.entries[int(sprite_id)].color_a = 0.25
+                    except Exception:
+                        pass
+                entry.trail_timer = 0.06
+
             # projectile_update uses creature_find_in_radius(..., 8.0, ...)
             hit_idx: int | None = None
             for idx, creature in enumerate(creatures):
@@ -1025,16 +1227,70 @@ class SecondaryProjectilePool:
                             rand=rand,
                         )
 
+                if entry.type_id == 1 and effects is not None and hasattr(effects, "spawn_explosion_burst") and int(detail_preset) > 2:
+                    effects.spawn_explosion_burst(
+                        pos_x=float(entry.pos_x),
+                        pos_y=float(entry.pos_y),
+                        scale=0.4,
+                        rand=rand,
+                        detail_preset=int(detail_preset),
+                    )
+
                 entry.type_id = 3
                 entry.vel_x = 0.0
-                entry.vel_y = 0.0
-                entry.speed = det_scale
-                entry.lifetime = 0.0
+                entry.vel_y = float(det_scale)
+                entry.trail_timer = 0.0
+
+                # Extra debris and scorch decals on detonation.
+                if not freeze_active:
+                    extra_decals = 0
+                    extra_radius = 0.0
+                    if entry.type_id == 3:
+                        # NOTE: entry.type_id is already 3 here; use det_scale based on prior type.
+                        if det_scale == 1.0:
+                            extra_decals = 0x14
+                            extra_radius = 90.0
+                        elif det_scale == 0.35:
+                            extra_decals = 10
+                            extra_radius = 63.0
+                        elif det_scale == 0.25:
+                            extra_decals = 3
+                            extra_radius = 44.0
+                    if fx_queue is not None and extra_decals > 0:
+                        cx = float(creatures[hit_idx].x)
+                        cy = float(creatures[hit_idx].y)
+                        for _ in range(int(extra_decals)):
+                            angle = float(int(rand()) % 0x274) * 0.01
+                            radius = float(int(rand()) % max(1, int(extra_radius)))
+                            fx_queue.add_random(
+                                pos_x=cx + math.cos(angle) * radius,
+                                pos_y=cy + math.sin(angle) * radius,
+                                rand=rand,
+                            )
+
+                    if sprite_effects is not None and hasattr(sprite_effects, "spawn"):
+                        step = math.tau / 10.0
+                        for idx in range(10):
+                            mag = float(int(rand()) % 800) * 0.1
+                            ang = float(idx) * step
+                            vel_x = math.cos(ang) * mag
+                            vel_y = math.sin(ang) * mag
+                            sprite_id = sprite_effects.spawn(
+                                pos_x=float(entry.pos_x),
+                                pos_y=float(entry.pos_y),
+                                vel_x=vel_x,
+                                vel_y=vel_y,
+                                scale=14.0,
+                            )
+                            try:
+                                sprite_effects.entries[int(sprite_id)].color_a = 0.37
+                            except Exception:
+                                pass
+
                 continue
 
             if entry.speed <= 0.0:
                 entry.type_id = 3
                 entry.vel_x = 0.0
-                entry.vel_y = 0.0
-                entry.speed = 0.5
-                entry.lifetime = 0.0
+                entry.vel_y = 0.5
+                entry.trail_timer = 0.0