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

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),
@@ -650,7 +650,7 @@ class WorldRenderer:
         )
         draw(frame, x=sx, y=sy, scale_mul=1.0, rotation=float(player.aim_heading), color=overlay_tint)
 
-    def _draw_projectile(self, proj: object, *, scale: float, alpha: float = 1.0) -> None:
+    def _draw_projectile(self, proj: object, *, proj_index: int = 0, scale: float, alpha: float = 1.0) -> None:
         alpha = clamp(float(alpha), 0.0, 1.0)
         if alpha <= 1e-3:
             return
@@ -831,20 +831,20 @@ class WorldRenderer:
             if any(perk_active(player, PerkId.ION_GUN_MASTER) for player in self.players):
                 perk_scale = 1.2
 
+            if type_id == int(ProjectileTypeId.ION_MINIGUN):
+                effect_scale = 1.05
+            elif type_id == int(ProjectileTypeId.ION_RIFLE):
+                effect_scale = 2.2
+            elif type_id == int(ProjectileTypeId.ION_CANNON):
+                effect_scale = 3.5
+            else:
+                effect_scale = 0.8
+
             if life >= 0.4:
                 base_alpha = alpha
-                effect_scale = 1.0
             else:
                 fade = clamp(life * 2.5, 0.0, 1.0)
                 base_alpha = fade * alpha
-                if type_id == int(ProjectileTypeId.ION_MINIGUN):
-                    effect_scale = 1.05
-                elif type_id == int(ProjectileTypeId.ION_RIFLE):
-                    effect_scale = 2.2
-                elif type_id == int(ProjectileTypeId.ION_CANNON):
-                    effect_scale = 3.5
-                else:
-                    effect_scale = 0.8
 
             if base_alpha <= 1e-3:
                 return
@@ -885,43 +885,44 @@ class WorldRenderer:
                     )
                 s += step
 
-            head_tint = self._color_from_rgba((head_rgb[0], head_rgb[1], head_rgb[2], base_alpha))
-            self._draw_atlas_sprite(
-                texture,
-                grid=grid,
-                frame=frame,
-                x=sx,
-                y=sy,
-                scale=sprite_scale,
-                rotation_rad=angle,
-                tint=head_tint,
-            )
-
-            # Ion-only: impact core + chain arcs. (Fire Bullets renders an extra particles.png overlay in a later pass.)
-            if is_fire_bullets and life >= 0.4 and self.particles_texture is not None:
-                particles_texture = self.particles_texture
-                atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x0D)
-                if atlas is not None:
-                    grid = SIZE_CODE_GRID.get(int(atlas.size_code))
-                    if grid:
-                        cell_w = float(particles_texture.width) / float(grid)
-                        cell_h = float(particles_texture.height) / float(grid)
-                        frame = int(atlas.frame)
-                        col = frame % grid
-                        row = frame // 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),
-                        )
-                        tint = self._color_from_rgba((1.0, 1.0, 1.0, alpha))
-                        size = 64.0 * scale
-                        dst = rl.Rectangle(float(sx), float(sy), float(size), float(size))
-                        origin = rl.Vector2(size * 0.5, size * 0.5)
-                        rl.draw_texture_pro(particles_texture, src, dst, origin, float(angle * _RAD_TO_DEG), tint)
+            if life >= 0.4:
+                head_tint = self._color_from_rgba((head_rgb[0], head_rgb[1], head_rgb[2], base_alpha))
+                self._draw_atlas_sprite(
+                    texture,
+                    grid=grid,
+                    frame=frame,
+                    x=sx,
+                    y=sy,
+                    scale=sprite_scale,
+                    rotation_rad=angle,
+                    tint=head_tint,
+                )
 
-            if is_ion and life < 0.4:
+                # Fire Bullets renders an extra particles.png overlay in a later pass.
+                if is_fire_bullets and self.particles_texture is not None:
+                    particles_texture = self.particles_texture
+                    atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x0D)
+                    if atlas is not None:
+                        grid = SIZE_CODE_GRID.get(int(atlas.size_code))
+                        if grid:
+                            cell_w = float(particles_texture.width) / float(grid)
+                            cell_h = float(particles_texture.height) / float(grid)
+                            frame = int(atlas.frame)
+                            col = frame % grid
+                            row = frame // 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),
+                            )
+                            tint = self._color_from_rgba((1.0, 1.0, 1.0, alpha))
+                            size = 64.0 * scale
+                            dst = rl.Rectangle(float(sx), float(sy), float(size), float(size))
+                            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,
@@ -934,120 +935,301 @@ class WorldRenderer:
                     tint=core_tint,
                 )
 
-                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
-
-                # Pick a stable set of targets so the arc visuals don't flicker.
-                candidates: list[tuple[float, object]] = []
-                for creature in self.creatures.entries:
-                    if not creature.active or float(creature.hp) <= 0.0:
-                        continue
-                    if float(getattr(creature, "hitbox_size", 0.0)) < 5.0:
-                        continue
-                    d = math.hypot(float(creature.x) - pos_x, float(creature.y) - pos_y)
-                    threshold = float(creature.size) * 0.142857149 + 3.0
-                    if d > radius + threshold:
-                        continue
-                    candidates.append((d, creature))
-
-                candidates.sort(key=lambda item: item[0])
-                targets = [creature for _d, creature in candidates[:8]]
-
-                inner = 10.0 * perk_scale * scale
-                outer = 14.0 * perk_scale * scale
-                u = 0.625
-                v0 = 0.0
-                v1 = 0.25
-
-                glow_targets: list[object] = []
-                rl.rl_set_texture(texture.id)
-                rl.rl_begin(rl.RL_QUADS)
-
-                for creature in targets:
-                    tx, ty = self.world_to_screen(float(creature.x), float(creature.y))
-                    ddx = tx - sx
-                    ddy = ty - sy
-                    dlen = math.hypot(ddx, ddy)
-                    if dlen <= 1e-3:
-                        continue
-                    glow_targets.append(creature)
-                    inv = 1.0 / dlen
-                    nx = ddx * inv
-                    ny = ddy * inv
-                    px = -ny
-                    py = nx
-
-                    # Outer strip (softer).
-                    half = outer * 0.5
-                    off_x = px * half
-                    off_y = py * half
-                    x0 = sx - off_x
-                    y0 = sy - off_y
-                    x1 = sx + off_x
-                    y1 = sy + off_y
-                    x2 = tx + off_x
-                    y2 = ty + off_y
-                    x3 = tx - off_x
-                    y3 = ty - off_y
-
-                    outer_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha * 0.5))
-                    rl.rl_color4ub(outer_tint.r, outer_tint.g, outer_tint.b, outer_tint.a)
-                    rl.rl_tex_coord2f(u, v0)
-                    rl.rl_vertex2f(x0, y0)
-                    rl.rl_tex_coord2f(u, v1)
-                    rl.rl_vertex2f(x1, y1)
-                    rl.rl_tex_coord2f(u, v1)
-                    rl.rl_vertex2f(x2, y2)
-                    rl.rl_tex_coord2f(u, v0)
-                    rl.rl_vertex2f(x3, y3)
-
-                    # Inner strip (brighter).
-                    half = inner * 0.5
-                    off_x = px * half
-                    off_y = py * half
-                    x0 = sx - off_x
-                    y0 = sy - off_y
-                    x1 = sx + off_x
-                    y1 = sy + off_y
-                    x2 = tx + off_x
-                    y2 = ty + off_y
-                    x3 = tx - off_x
-                    y3 = ty - off_y
-
-                    inner_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha))
-                    rl.rl_color4ub(inner_tint.r, inner_tint.g, inner_tint.b, inner_tint.a)
-                    rl.rl_tex_coord2f(u, v0)
-                    rl.rl_vertex2f(x0, y0)
-                    rl.rl_tex_coord2f(u, v1)
-                    rl.rl_vertex2f(x1, y1)
-                    rl.rl_tex_coord2f(u, v1)
-                    rl.rl_vertex2f(x2, y2)
-                    rl.rl_tex_coord2f(u, v0)
-                    rl.rl_vertex2f(x3, y3)
-
-                rl.rl_end()
-                rl.rl_set_texture(0)
-
-                for creature in glow_targets:
-                    tx, ty = self.world_to_screen(float(creature.x), float(creature.y))
-                    target_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha))
+                if is_ion:
+                    # 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]] = []
+                    for creature in self.creatures.entries:
+                        if not creature.active or float(creature.hp) <= 0.0:
+                            continue
+                        if float(getattr(creature, "hitbox_size", 0.0)) < 5.0:
+                            continue
+                        d = math.hypot(float(creature.x) - pos_x, float(creature.y) - pos_y)
+                        threshold = float(creature.size) * 0.142857149 + 3.0
+                        if d > radius + threshold:
+                            continue
+                        candidates.append((d, creature))
+
+                    candidates.sort(key=lambda item: item[0])
+                    targets = [creature for _d, creature in candidates[:8]]
+
+                    inner = 10.0 * perk_scale * scale
+                    outer = 14.0 * perk_scale * scale
+                    u = 0.625
+                    v0 = 0.0
+                    v1 = 0.25
+
+                    glow_targets: list[object] = []
+                    rl.rl_set_texture(texture.id)
+                    rl.rl_begin(rl.RL_QUADS)
+
+                    for creature in targets:
+                        tx, ty = self.world_to_screen(float(creature.x), float(creature.y))
+                        ddx = tx - sx
+                        ddy = ty - sy
+                        dlen = math.hypot(ddx, ddy)
+                        if dlen <= 1e-3:
+                            continue
+                        glow_targets.append(creature)
+                        inv = 1.0 / dlen
+                        nx = ddx * inv
+                        ny = ddy * inv
+                        px = -ny
+                        py = nx
+
+                        # Outer strip (softer).
+                        half = outer * 0.5
+                        off_x = px * half
+                        off_y = py * half
+                        x0 = sx - off_x
+                        y0 = sy - off_y
+                        x1 = sx + off_x
+                        y1 = sy + off_y
+                        x2 = tx + off_x
+                        y2 = ty + off_y
+                        x3 = tx - off_x
+                        y3 = ty - off_y
+
+                        outer_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha * 0.5))
+                        rl.rl_color4ub(outer_tint.r, outer_tint.g, outer_tint.b, outer_tint.a)
+                        rl.rl_tex_coord2f(u, v0)
+                        rl.rl_vertex2f(x0, y0)
+                        rl.rl_tex_coord2f(u, v1)
+                        rl.rl_vertex2f(x1, y1)
+                        rl.rl_tex_coord2f(u, v1)
+                        rl.rl_vertex2f(x2, y2)
+                        rl.rl_tex_coord2f(u, v0)
+                        rl.rl_vertex2f(x3, y3)
+
+                        # Inner strip (brighter).
+                        half = inner * 0.5
+                        off_x = px * half
+                        off_y = py * half
+                        x0 = sx - off_x
+                        y0 = sy - off_y
+                        x1 = sx + off_x
+                        y1 = sy + off_y
+                        x2 = tx + off_x
+                        y2 = ty + off_y
+                        x3 = tx - off_x
+                        y3 = ty - off_y
+
+                        inner_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha))
+                        rl.rl_color4ub(inner_tint.r, inner_tint.g, inner_tint.b, inner_tint.a)
+                        rl.rl_tex_coord2f(u, v0)
+                        rl.rl_vertex2f(x0, y0)
+                        rl.rl_tex_coord2f(u, v1)
+                        rl.rl_vertex2f(x1, y1)
+                        rl.rl_tex_coord2f(u, v1)
+                        rl.rl_vertex2f(x2, y2)
+                        rl.rl_tex_coord2f(u, v0)
+                        rl.rl_vertex2f(x3, y3)
+
+                    rl.rl_end()
+                    rl.rl_set_texture(0)
+
+                    for creature in glow_targets:
+                        tx, ty = self.world_to_screen(float(creature.x), float(creature.y))
+                        target_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha))
+                        self._draw_atlas_sprite(
+                            texture,
+                            grid=grid,
+                            frame=frame,
+                            x=tx,
+                            y=ty,
+                            scale=sprite_scale,
+                            rotation_rad=0.0,
+                            tint=target_tint,
+                        )
+
+            rl.end_blend_mode()
+            return
+
+        if type_id == int(ProjectileTypeId.PULSE_GUN) and texture is not None:
+            mapping = KNOWN_PROJ_FRAMES.get(type_id)
+            if mapping is None:
+                return
+            grid, frame = mapping
+            cell_w = float(texture.width) / float(grid)
+
+            if life >= 0.4:
+                ox = float(getattr(proj, "origin_x", pos_x))
+                oy = float(getattr(proj, "origin_y", pos_y))
+                dist = math.hypot(pos_x - ox, pos_y - oy)
+
+                desired_size = dist * 0.16 * scale
+                if desired_size <= 1e-3:
+                    return
+                sprite_scale = desired_size / cell_w if cell_w > 1e-6 else 0.0
+                if sprite_scale <= 1e-6:
+                    return
+
+                tint = self._color_from_rgba((0.1, 0.6, 0.2, alpha * 0.7))
+                rl.begin_blend_mode(rl.BLEND_ADDITIVE)
+                self._draw_atlas_sprite(
+                    texture,
+                    grid=grid,
+                    frame=frame,
+                    x=sx,
+                    y=sy,
+                    scale=sprite_scale,
+                    rotation_rad=angle,
+                    tint=tint,
+                )
+                rl.end_blend_mode()
+                return
+
+            fade = clamp(life * 2.5, 0.0, 1.0)
+            fade_alpha = fade * alpha
+            if fade_alpha <= 1e-3:
+                return
+
+            desired_size = 56.0 * scale
+            sprite_scale = desired_size / cell_w if cell_w > 1e-6 else 0.0
+            if sprite_scale <= 1e-6:
+                return
+
+            tint = self._color_from_rgba((1.0, 1.0, 1.0, fade_alpha))
+            rl.begin_blend_mode(rl.BLEND_ADDITIVE)
+            self._draw_atlas_sprite(
+                texture,
+                grid=grid,
+                frame=frame,
+                x=sx,
+                y=sy,
+                scale=sprite_scale,
+                rotation_rad=angle,
+                tint=tint,
+            )
+            rl.end_blend_mode()
+            return
+
+        if type_id in (int(ProjectileTypeId.SPLITTER_GUN), int(ProjectileTypeId.BLADE_GUN)) and texture is not None:
+            mapping = KNOWN_PROJ_FRAMES.get(type_id)
+            if mapping is None:
+                return
+            grid, frame = mapping
+            cell_w = float(texture.width) / float(grid)
+
+            if life < 0.4:
+                return
+
+            ox = float(getattr(proj, "origin_x", pos_x))
+            oy = float(getattr(proj, "origin_y", pos_y))
+            dist = math.hypot(pos_x - ox, pos_y - oy)
+
+            desired_size = min(dist, 20.0) * scale
+            if desired_size <= 1e-3:
+                return
+
+            sprite_scale = desired_size / cell_w if cell_w > 1e-6 else 0.0
+            if sprite_scale <= 1e-6:
+                return
+
+            rotation_rad = angle
+            rgb = (1.0, 1.0, 1.0)
+            if type_id == int(ProjectileTypeId.BLADE_GUN):
+                rotation_rad = float(int(proj_index)) * 0.1 - float(self._elapsed_ms) * 0.1
+                rgb = (0.8, 0.8, 0.8)
+
+            tint = self._color_from_rgba((rgb[0], rgb[1], rgb[2], alpha))
+            self._draw_atlas_sprite(
+                texture,
+                grid=grid,
+                frame=frame,
+                x=sx,
+                y=sy,
+                scale=sprite_scale,
+                rotation_rad=rotation_rad,
+                tint=tint,
+            )
+            return
+
+        if type_id == int(ProjectileTypeId.PLAGUE_SPREADER) and texture is not None:
+            grid = 4
+            frame = 2
+            cell_w = float(texture.width) / float(grid)
+
+            if life >= 0.4:
+                tint = self._color_from_rgba((1.0, 1.0, 1.0, alpha))
+
+                def draw_plague_quad(*, px: float, py: float, size: float) -> None:
+                    size = float(size)
+                    if size <= 1e-3:
+                        return
+                    desired_size = size * scale
+                    sprite_scale = desired_size / cell_w if cell_w > 1e-6 else 0.0
+                    if sprite_scale <= 1e-6:
+                        return
+                    psx, psy = self.world_to_screen(px, py)
                     self._draw_atlas_sprite(
                         texture,
                         grid=grid,
                         frame=frame,
-                        x=tx,
-                        y=ty,
+                        x=psx,
+                        y=psy,
                         scale=sprite_scale,
                         rotation_rad=0.0,
-                        tint=target_tint,
+                        tint=tint,
                     )
 
-            rl.end_blend_mode()
+                draw_plague_quad(px=pos_x, py=pos_y, size=60.0)
+
+                offset_angle = angle + math.pi / 2.0
+                draw_plague_quad(
+                    px=pos_x + math.cos(offset_angle) * 15.0,
+                    py=pos_y + math.sin(offset_angle) * 15.0,
+                    size=60.0,
+                )
+
+                phase = float(int(proj_index)) + float(self._elapsed_ms) * 0.01
+                cos_phase = math.cos(phase)
+                sin_phase = math.sin(phase)
+                draw_plague_quad(
+                    px=pos_x + cos_phase * cos_phase - 5.0,
+                    py=pos_y + sin_phase * 11.0 - 5.0,
+                    size=52.0,
+                )
+
+                phase_120 = phase + 2.0943952
+                sin_phase_120 = math.sin(phase_120)
+                draw_plague_quad(
+                    px=pos_x + math.cos(phase_120) * 10.0,
+                    py=pos_y + sin_phase_120 * 10.0,
+                    size=62.0,
+                )
+
+                phase_240 = phase + 4.1887903
+                draw_plague_quad(
+                    px=pos_x + math.cos(phase_240) * 10.0,
+                    py=pos_y + math.sin(phase_240) * sin_phase_120,
+                    size=62.0,
+                )
+                return
+
+            fade = clamp(life * 2.5, 0.0, 1.0)
+            fade_alpha = fade * alpha
+            if fade_alpha <= 1e-3:
+                return
+
+            desired_size = (fade * 40.0 + 32.0) * scale
+            sprite_scale = desired_size / cell_w if cell_w > 1e-6 else 0.0
+            if sprite_scale <= 1e-6:
+                return
+
+            tint = self._color_from_rgba((1.0, 1.0, 1.0, fade_alpha))
+            self._draw_atlas_sprite(
+                texture,
+                grid=grid,
+                frame=frame,
+                x=sx,
+                y=sy,
+                scale=sprite_scale,
+                rotation_rad=0.0,
+                tint=tint,
+            )
             return
 
         mapping = KNOWN_PROJ_FRAMES.get(type_id)
@@ -1160,21 +1342,236 @@ 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:
             return
         sx, sy = self.world_to_screen(float(getattr(proj, "pos_x", 0.0)), float(getattr(proj, "pos_y", 0.0)))
         proj_type = int(getattr(proj, "type_id", 0))
+        angle = float(getattr(proj, "angle", 0.0))
+
+        if proj_type in (1, 2, 4) and self.projs_texture is not None:
+            texture = self.projs_texture
+            cell_w = float(texture.width) / 4.0
+            if cell_w <= 1e-6:
+                return
+
+            base_alpha = clamp(alpha * 0.9, 0.0, 1.0)
+            base_tint = self._color_from_rgba((0.8, 0.8, 0.8, base_alpha))
+            base_size = 14.0
+            if proj_type == 2:
+                base_size = 10.0
+            elif proj_type == 4:
+                base_size = 8.0
+            sprite_scale = (base_size * scale) / cell_w
+
+            fx_detail_1 = bool(self.config.data.get("fx_detail_1", 0)) if self.config is not None else True
+            if fx_detail_1 and self.particles_texture is not None:
+                particles_texture = self.particles_texture
+                atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x0D)
+                if atlas is not None:
+                    grid = SIZE_CODE_GRID.get(int(atlas.size_code))
+                    if grid:
+                        particle_cell_w = float(particles_texture.width) / float(grid)
+                        particle_cell_h = float(particles_texture.height) / float(grid)
+                        frame = int(atlas.frame)
+                        col = frame % grid
+                        row = frame // grid
+                        src = rl.Rectangle(
+                            particle_cell_w * float(col),
+                            particle_cell_h * float(row),
+                            max(0.0, particle_cell_w - 2.0),
+                            max(0.0, particle_cell_h - 2.0),
+                        )
+
+                        dir_x = math.cos(angle - math.pi / 2.0)
+                        dir_y = math.sin(angle - math.pi / 2.0)
+
+                        def _draw_rocket_fx(
+                            *,
+                            size: float,
+                            offset: float,
+                            rgba: tuple[float, float, float, float],
+                        ) -> None:
+                            fx_alpha = rgba[3]
+                            if fx_alpha <= 1e-3:
+                                return
+                            tint = self._color_from_rgba(rgba)
+                            fx_sx = sx - dir_x * offset * scale
+                            fx_sy = sy - dir_y * offset * scale
+                            dst_size = size * scale
+                            dst = rl.Rectangle(float(fx_sx), float(fx_sy), float(dst_size), float(dst_size))
+                            origin = rl.Vector2(dst_size * 0.5, dst_size * 0.5)
+                            rl.draw_texture_pro(particles_texture, src, dst, origin, 0.0, tint)
+
+                        rl.begin_blend_mode(rl.BLEND_ADDITIVE)
+                        # Large bloom around the rocket (effect_id=0x0D).
+                        _draw_rocket_fx(size=140.0, offset=5.0, rgba=(1.0, 1.0, 1.0, alpha * 0.48))
+
+                        if proj_type == 4:
+                            _draw_rocket_fx(size=30.0, offset=9.0, rgba=(0.7, 0.7, 1.0, alpha * 0.158))
+                        elif proj_type == 2:
+                            _draw_rocket_fx(size=40.0, offset=9.0, rgba=(1.0, 1.0, 1.0, alpha * 0.58))
+                        else:
+                            _draw_rocket_fx(size=60.0, offset=9.0, rgba=(1.0, 1.0, 1.0, alpha * 0.68))
+
+                        rl.end_blend_mode()
+            self._draw_atlas_sprite(
+                texture,
+                grid=4,
+                frame=3,
+                x=sx,
+                y=sy,
+                scale=sprite_scale,
+                rotation_rad=angle,
+                tint=base_tint,
+            )
+            return
+
         if proj_type == 4:
             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)))
 
@@ -1222,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:
@@ -1627,10 +2024,19 @@ class WorldRenderer:
                 if player.health > 0.0:
                     draw_player(player)
 
-            for proj in self.state.projectiles.entries:
+            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
-                self._draw_projectile(proj, scale=scale, alpha=entity_alpha)
+                self._draw_projectile(proj, proj_index=proj_index, scale=scale, alpha=entity_alpha)
 
             self._draw_particle_pool(cam_x=cam_x, cam_y=cam_y, scale_x=scale_x, scale_y=scale_y, alpha=entity_alpha)