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

crimson/demo.py

@@ -690,8 +690,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)

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/gameplay.py

@@ -1626,7 +1626,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 +1681,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,

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
 
 
@@ -383,6 +383,86 @@ class ProjectilePool:
                     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,
@@ -567,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:
@@ -628,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
 
@@ -639,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,
@@ -710,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
@@ -914,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).
@@ -931,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]:
@@ -966,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)
@@ -977,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:
@@ -984,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(
@@ -1066,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):
@@ -1118,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

crimson/render/world_renderer.py

@@ -452,13 +452,13 @@ class WorldRenderer:
         ):
             atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x10)
             if atlas is not None:
-                grid = SIZE_CODE_GRID.get(int(atlas.size_code))
-                if grid:
+                aura_grid = SIZE_CODE_GRID.get(int(atlas.size_code))
+                if aura_grid:
                     frame = int(atlas.frame)
-                    col = frame % grid
-                    row = frame // grid
-                    cell_w = float(self.particles_texture.width) / float(grid)
-                    cell_h = float(self.particles_texture.height) / float(grid)
+                    col = frame % aura_grid
+                    row = frame // aura_grid
+                    cell_w = float(self.particles_texture.width) / float(aura_grid)
+                    cell_h = float(self.particles_texture.height) / float(aura_grid)
                     src = rl.Rectangle(
                         cell_w * float(col),
                         cell_h * float(row),
@@ -922,6 +922,7 @@ class WorldRenderer:
                             origin = rl.Vector2(size * 0.5, size * 0.5)
                             rl.draw_texture_pro(particles_texture, src, dst, origin, float(angle * _RAD_TO_DEG), tint)
             else:
+                # Native draws a small blue "core" at the head during the fade stage (life_timer < 0.4).
                 core_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha))
                 self._draw_atlas_sprite(
                     texture,
@@ -935,13 +936,8 @@ class WorldRenderer:
                 )
 
                 if is_ion:
-                    if type_id == int(ProjectileTypeId.ION_RIFLE):
-                        radius = 88.0
-                    elif type_id == int(ProjectileTypeId.ION_MINIGUN):
-                        radius = 60.0
-                    else:
-                        radius = 128.0
-                    radius *= perk_scale
+                    # Native: chain reach is derived from the streak scale (`fVar29 * perk_scale * 40.0`).
+                    radius = effect_scale * perk_scale * 40.0
 
                     # Pick a stable set of targets so the arc visuals don't flicker.
                     candidates: list[tuple[float, object]] = []
@@ -1346,6 +1342,99 @@ class WorldRenderer:
         rl.end_blend_mode()
         return True
 
+    def _draw_sharpshooter_laser_sight(
+        self,
+        *,
+        cam_x: float,
+        cam_y: float,
+        scale_x: float,
+        scale_y: float,
+        scale: float,
+        alpha: float,
+    ) -> None:
+        """Laser sight overlay for the Sharpshooter perk (`projectile_render` @ 0x00422c70)."""
+
+        alpha = clamp(float(alpha), 0.0, 1.0)
+        if alpha <= 1e-3:
+            return
+        if self.bullet_trail_texture is None:
+            return
+
+        players = self.players
+        if not players:
+            return
+
+        tail_alpha = int(clamp(alpha * 0.5, 0.0, 1.0) * 255.0 + 0.5)
+        head_alpha = int(clamp(alpha * 0.2, 0.0, 1.0) * 255.0 + 0.5)
+        tail = rl.Color(255, 0, 0, tail_alpha)
+        head = rl.Color(255, 0, 0, head_alpha)
+
+        rl.begin_blend_mode(rl.BLEND_ADDITIVE)
+        rl.rl_set_texture(self.bullet_trail_texture.id)
+        rl.rl_begin(rl.RL_QUADS)
+
+        for player in players:
+            if float(getattr(player, "health", 0.0)) <= 0.0:
+                continue
+            if not perk_active(player, PerkId.SHARPSHOOTER):
+                continue
+
+            aim_heading = float(getattr(player, "aim_heading", 0.0))
+            dir_x = math.cos(aim_heading - math.pi / 2.0)
+            dir_y = math.sin(aim_heading - math.pi / 2.0)
+
+            start_x = float(getattr(player, "pos_x", 0.0)) + dir_x * 15.0
+            start_y = float(getattr(player, "pos_y", 0.0)) + dir_y * 15.0
+            end_x = float(getattr(player, "pos_x", 0.0)) + dir_x * 512.0
+            end_y = float(getattr(player, "pos_y", 0.0)) + dir_y * 512.0
+
+            sx0 = (start_x + cam_x) * scale_x
+            sy0 = (start_y + cam_y) * scale_y
+            sx1 = (end_x + cam_x) * scale_x
+            sy1 = (end_y + cam_y) * scale_y
+
+            dx = sx1 - sx0
+            dy = sy1 - sy0
+            dist = math.hypot(dx, dy)
+            if dist <= 1e-3:
+                continue
+
+            thickness = max(1.0, 2.0 * scale)
+            half = thickness * 0.5
+            inv = 1.0 / dist
+            nx = dx * inv
+            ny = dy * inv
+            px = -ny
+            py = nx
+            ox = px * half
+            oy = py * half
+
+            x0 = sx0 - ox
+            y0 = sy0 - oy
+            x1 = sx0 + ox
+            y1 = sy0 + oy
+            x2 = sx1 + ox
+            y2 = sy1 + oy
+            x3 = sx1 - ox
+            y3 = sy1 - oy
+
+            rl.rl_color4ub(tail.r, tail.g, tail.b, tail.a)
+            rl.rl_tex_coord2f(0.0, 0.0)
+            rl.rl_vertex2f(x0, y0)
+            rl.rl_color4ub(tail.r, tail.g, tail.b, tail.a)
+            rl.rl_tex_coord2f(1.0, 0.0)
+            rl.rl_vertex2f(x1, y1)
+            rl.rl_color4ub(head.r, head.g, head.b, head.a)
+            rl.rl_tex_coord2f(1.0, 0.5)
+            rl.rl_vertex2f(x2, y2)
+            rl.rl_color4ub(head.r, head.g, head.b, head.a)
+            rl.rl_tex_coord2f(0.0, 0.5)
+            rl.rl_vertex2f(x3, y3)
+
+        rl.rl_end()
+        rl.rl_set_texture(0)
+        rl.end_blend_mode()
+
     def _draw_secondary_projectile(self, proj: object, *, scale: float, alpha: float = 1.0) -> None:
         alpha = clamp(float(alpha), 0.0, 1.0)
         if alpha <= 1e-3:
@@ -1436,11 +1525,53 @@ class WorldRenderer:
             rl.draw_circle(int(sx), int(sy), max(1.0, 12.0 * scale), rl.Color(200, 120, 255, int(255 * alpha + 0.5)))
             return
         if proj_type == 3:
-            t = clamp(float(getattr(proj, "lifetime", 0.0)), 0.0, 1.0)
-            radius = float(getattr(proj, "speed", 1.0)) * t * 80.0
-            alpha_byte = int(clamp((1.0 - t) * 180.0 * alpha, 0.0, 255.0) + 0.5)
-            color = rl.Color(200, 120, 255, alpha_byte)
-            rl.draw_circle_lines(int(sx), int(sy), max(1.0, radius * scale), color)
+            # Secondary projectile detonation visuals (secondary_projectile_update + render).
+            t = clamp(float(getattr(proj, "vel_x", 0.0)), 0.0, 1.0)
+            det_scale = float(getattr(proj, "vel_y", 1.0))
+            fade = (1.0 - t) * alpha
+            if fade <= 1e-3 or det_scale <= 1e-6:
+                return
+            if self.particles_texture is None:
+                radius = det_scale * t * 80.0
+                alpha_byte = int(clamp((1.0 - t) * 180.0 * alpha, 0.0, 255.0) + 0.5)
+                color = rl.Color(255, 180, 100, alpha_byte)
+                rl.draw_circle_lines(int(sx), int(sy), max(1.0, radius * scale), color)
+                return
+
+            atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x0D)
+            if atlas is None:
+                return
+            grid = SIZE_CODE_GRID.get(int(atlas.size_code))
+            if not grid:
+                return
+            frame = int(atlas.frame)
+            col = frame % grid
+            row = frame // grid
+            cell_w = float(self.particles_texture.width) / float(grid)
+            cell_h = float(self.particles_texture.height) / float(grid)
+            src = rl.Rectangle(
+                cell_w * float(col),
+                cell_h * float(row),
+                max(0.0, cell_w - 2.0),
+                max(0.0, cell_h - 2.0),
+            )
+
+            def _draw_detonation_quad(*, size: float, alpha_mul: float) -> None:
+                a = fade * alpha_mul
+                if a <= 1e-3:
+                    return
+                dst_size = size * scale
+                if dst_size <= 1e-3:
+                    return
+                tint = self._color_from_rgba((1.0, 0.6, 0.1, a))
+                dst = rl.Rectangle(float(sx), float(sy), float(dst_size), float(dst_size))
+                origin = rl.Vector2(float(dst_size) * 0.5, float(dst_size) * 0.5)
+                rl.draw_texture_pro(self.particles_texture, src, dst, origin, 0.0, tint)
+
+            rl.begin_blend_mode(rl.BLEND_ADDITIVE)
+            _draw_detonation_quad(size=det_scale * t * 64.0, alpha_mul=1.0)
+            _draw_detonation_quad(size=det_scale * t * 200.0, alpha_mul=0.3)
+            rl.end_blend_mode()
             return
         rl.draw_circle(int(sx), int(sy), max(1.0, 4.0 * scale), rl.Color(200, 200, 220, int(200 * alpha + 0.5)))
 
@@ -1488,7 +1619,7 @@ class WorldRenderer:
         rl.begin_blend_mode(rl.BLEND_ADDITIVE)
 
         if fx_detail_1 and src_large is not None:
-            alpha_byte = int(clamp(alpha * 0.04, 0.0, 1.0) * 255.0 + 0.5)
+            alpha_byte = int(clamp(alpha * 0.065, 0.0, 1.0) * 255.0 + 0.5)
             tint = rl.Color(255, 255, 255, alpha_byte)
             for idx, entry in enumerate(particles):
                 if not entry.active or (idx % 2) or int(entry.style_id) == 8:
@@ -1893,6 +2024,15 @@ class WorldRenderer:
                 if player.health > 0.0:
                     draw_player(player)
 
+            self._draw_sharpshooter_laser_sight(
+                cam_x=cam_x,
+                cam_y=cam_y,
+                scale_x=scale_x,
+                scale_y=scale_y,
+                scale=scale,
+                alpha=entity_alpha,
+            )
+
             for proj_index, proj in enumerate(self.state.projectiles.entries):
                 if not proj.active:
                     continue

{crimsonland-0.1.0.dev5.dist-info → crimsonland-0.1.0.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: crimsonland
-Version: 0.1.0.dev5
+Version: 0.1.0.dev6
 Requires-Dist: construct>=2.10.70
 Requires-Dist: pillow>=12.1.0
 Requires-Dist: platformdirs>=4.5.1

{crimsonland-0.1.0.dev5.dist-info → crimsonland-0.1.0.dev6.dist-info}/RECORD

@@ -12,9 +12,9 @@ crimson/creatures/damage.py,sha256=pjKIX32nGDVPnFaWCce0LNZ-UZXZqJpNvwHwq-DCWbE,3
 crimson/creatures/runtime.py,sha256=1FagJNwGWJuOXZEv4VaWak2IktNskSof82WCYJqui-U,40733
 crimson/creatures/spawn.py,sha256=ikgtr4sM2KdA2-eyxYdVmobcuZN6aA7xK7ceaIl7RSw,90059
 crimson/debug.py,sha256=vtfr0_HQHpiB5h57jAsl9cWyYxErSbZQ2uazcL1sJhU,127
-crimson/demo.py,sha256=rQG6Wdwy6t8sXZRt52vAmexpmgEyjRXuKs1sNx3wMoI,52500
+crimson/demo.py,sha256=IzBcqiIilzC4PAEH6VwMpfb6y13HfieUOOfL1_kUwe0,52497
 crimson/demo_trial.py,sha256=BuoKB1DB-cPZ8jBp4x9gmxWF6tvhXMYRqJ9hMYrhxH4,4651
-crimson/effects.py,sha256=6-v23jb5-Xs_gu3EezjRJLCGAU8obSUR6b2opdTLTvc,33999
+crimson/effects.py,sha256=tjOOZopqTI7TTOBREfIUfUhjoa3YqIoFJAPj5oJlW9Y,34056
 crimson/effects_atlas.py,sha256=Ko1O7z-1jGkH_KSeb8RrR2EtAs4V8vfo70ofhqbFak4,2104
 crimson/frontend/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 crimson/frontend/assets.py,sha256=JHxOID6Ti6bD2LercdRJ7sSSr0nRX3WWeuRPDQwwbsY,1343
@@ -31,7 +31,7 @@ crimson/frontend/transitions.py,sha256=-sAJUDqNZ943zXlqtvJ6jCg2YH8dSi8k7qK8caAfO
 crimson/game.py,sha256=_nPXvZDgu2sqEPk00ww9qx7nD8eQIXlIvU-yKfBuUA8,97537
 crimson/game_modes.py,sha256=qW7Tt97lSBmGrt0F17Ni5h8vRyngBzyS9XwWM1TFIEI,255
 crimson/game_world.py,sha256=nfKGcm3LHChPGLHJsurDFAATrHmhRvTmgxcLzUN9m5I,25440
-crimson/gameplay.py,sha256=QsxHKgGTp79jAOIRoUn_L1jbN9EK2MIdCksLQ-KCqY4,87575
+crimson/gameplay.py,sha256=CtTCxwXWa66RjQS7MKa240J4Mzmel68H0wP0lqOre1s,87546
 crimson/input_codes.py,sha256=PmSWFZIit8unTBWk3uwifpHWMuk0qMg1ueKX3MGC7D0,5379
 crimson/modes/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 crimson/modes/base_gameplay_mode.py,sha256=kmXJxkGnCKV5QZL_y5ML7r-p4bw7hMswKseG9XUn2jo,7555
@@ -46,7 +46,7 @@ crimson/persistence/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVO
 crimson/persistence/highscores.py,sha256=i3eU_Vlu-Bn6kZHDWNMzUoJXvzkqOnPp_UFOeZXclYU,13026
 crimson/persistence/save_status.py,sha256=s-FZONO6JVYRULewtlxoIwATTy3P7rLy-vsVBfSKPk4,7748
 crimson/player_damage.py,sha256=cECZO65NJwARoYdtsbvZBM8vQNs_8AVO4xa0omX0pGg,2215
-crimson/projectiles.py,sha256=44sL_2ElYAtNHHo8bzcx3t2NDq-yix56Pfui8zNGOeo,43644
+crimson/projectiles.py,sha256=56yocC2XYC69bixrmAgHud4YiSIgezMf2blCQw_YekM,51304
 crimson/quests/__init__.py,sha256=pKCkH0o1XIGDN9h6yNNaqvWek2CybEZRpejYRooULj8,375
 crimson/quests/helpers.py,sha256=TeZWhIy2x8Zs9S-vYRBOEZ7pkHNMr5YJ-wi4vYQ2q2M,3625
 crimson/quests/registry.py,sha256=Cees1QBN0VYTB-XyQtvZ1b4SykB-i4tAnWF6WSV-1pg,1478
@@ -61,7 +61,7 @@ crimson/quests/timeline.py,sha256=leK898fPt3zq52v-O6dK4c-wJBcY-E6v-y57Fk3kJ3Q,40
 crimson/quests/types.py,sha256=iSrz8VSiRZh1pUDSyq37ir7B28c0HF8DjdF6OJ3FoBo,1772
 crimson/render/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 crimson/render/terrain_fx.py,sha256=MpBV6ukGwGqDluIO86BQhHRVWUvcFOi8MV-z_TfLsiw,2705
-crimson/render/world_renderer.py,sha256=wSipGqm900eJaBNctXO9WDRSdM6ruOBXsG-TDXWSyCE,83776
+crimson/render/world_renderer.py,sha256=9Gq2uya5duQAv4ievnqbGjJ2kXSAohVUwC36poDAp8M,88852
 crimson/sim/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 crimson/sim/world_defs.py,sha256=HiMl--THnII3BTpt6mWAd20Xu-SRzCyHcs5pCR8aMbU,2195
 crimson/sim/world_state.py,sha256=h_PPaomj-1KPscPsW3zZ07tVFb3DYPM-FQq3pepMGng,15653
@@ -133,7 +133,7 @@ grim/sfx.py,sha256=cpn2Mmeio7BSDgbStSft-eZchO9Ot2MrK6iXJqxlLqU,7836
 grim/sfx_map.py,sha256=FM5iBzKkG30Vtu78SRavVNgXMbGK7ZFcQ8i6lgMlzVw,4697
 grim/terrain_render.py,sha256=EZ7ySYJyTZwXcrJx1mKbY3ewZtPi7Y270XnZgGJyZG8,31509
 grim/view.py,sha256=oF4pHZehBqOxPjKMU28TDg3qATh_amMIRJp-vMQnpn4,334
-crimsonland-0.1.0.dev5.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-crimsonland-0.1.0.dev5.dist-info/entry_points.txt,sha256=jzzcExxiE9xpt4Iw2nbB1lwTv2Zj4H14WJTIPMkAjoE,77
-crimsonland-0.1.0.dev5.dist-info/METADATA,sha256=kBl208VLbh6OZaSSjTWXJ3pMc2q9tFXkDEJYhjg1BZc,243
-crimsonland-0.1.0.dev5.dist-info/RECORD,,
+crimsonland-0.1.0.dev6.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+crimsonland-0.1.0.dev6.dist-info/entry_points.txt,sha256=jzzcExxiE9xpt4Iw2nbB1lwTv2Zj4H14WJTIPMkAjoE,77
+crimsonland-0.1.0.dev6.dist-info/METADATA,sha256=xh-O_q3NLT4mfdymSlZ0e6l0g08ACM5Fdd2IMZNqstg,243
+crimsonland-0.1.0.dev6.dist-info/RECORD,,