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

crimson/render/world_renderer.py

@@ -18,14 +18,14 @@ from ..gameplay import bonus_find_aim_hover_entry, perk_active
 from ..perks import PerkId
 from ..projectiles import ProjectileTypeId
 from ..sim.world_defs import (
-    BEAM_TYPES,
     CREATURE_ANIM,
     CREATURE_ASSET,
-    ION_TYPES,
     KNOWN_PROJ_FRAMES,
-    PLASMA_PARTICLE_TYPES,
 )
 from ..weapons import WEAPON_BY_ID
+from .projectile_draw_registry import ProjectileDrawCtx, draw_projectile_from_registry
+from .projectile_render_registry import known_proj_rgb
+from .secondary_projectile_draw_registry import SecondaryProjectileDrawCtx, draw_secondary_projectile_from_registry
 
 if TYPE_CHECKING:
     from ..game_world import GameWorld
@@ -662,570 +662,22 @@ class WorldRenderer:
         life = float(getattr(proj, "life_timer", 0.0))
         angle = float(getattr(proj, "angle", 0.0))
 
-        if self._is_bullet_trail_type(type_id):
-            life_alpha = int(clamp(life, 0.0, 1.0) * 255)
-            alpha_byte = int(clamp(float(life_alpha) * alpha, 0.0, 255.0) + 0.5)
-            drawn = False
-            if self.bullet_trail_texture is not None:
-                ox = float(getattr(proj, "origin_x", pos_x))
-                oy = float(getattr(proj, "origin_y", pos_y))
-                sx0, sy0 = self.world_to_screen(ox, oy)
-                sx1, sy1 = sx, sy
-                drawn = self._draw_bullet_trail(sx0, sy0, sx1, sy1, type_id=type_id, alpha=alpha_byte, scale=scale)
-
-            if self.bullet_texture is not None and life >= 0.39:
-                size = self._bullet_sprite_size(type_id, scale=scale)
-                src = rl.Rectangle(
-                    0.0,
-                    0.0,
-                    float(self.bullet_texture.width),
-                    float(self.bullet_texture.height),
-                )
-                dst = rl.Rectangle(float(sx), float(sy), size, size)
-                origin = rl.Vector2(size * 0.5, size * 0.5)
-                tint = rl.Color(220, 220, 220, alpha_byte)
-                rl.draw_texture_pro(self.bullet_texture, src, dst, origin, float(angle * _RAD_TO_DEG), tint)
-                drawn = True
-
-            if drawn:
-                return
-
-        if type_id in PLASMA_PARTICLE_TYPES 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),
-                    )
-
-                    speed_scale = float(getattr(proj, "speed_scale", 1.0))
-                    fx_detail_1 = bool(self.config.data.get("fx_detail_1", 0)) if self.config is not None else True
-
-                    rgb = (1.0, 1.0, 1.0)
-                    spacing = 2.1
-                    seg_limit = 3
-                    tail_size = 12.0
-                    head_size = 16.0
-                    head_alpha_mul = 0.45
-                    aura_rgb = rgb
-                    aura_size = 120.0
-                    aura_alpha_mul = 0.15
-
-                    if type_id == int(ProjectileTypeId.PLASMA_RIFLE):
-                        spacing = 2.5
-                        seg_limit = 8
-                        tail_size = 22.0
-                        head_size = 56.0
-                        aura_size = 256.0
-                        aura_alpha_mul = 0.3
-                    elif type_id == int(ProjectileTypeId.PLASMA_MINIGUN):
-                        spacing = 2.1
-                        seg_limit = 3
-                        tail_size = 12.0
-                        head_size = 16.0
-                        aura_size = 120.0
-                        aura_alpha_mul = 0.15
-                    elif type_id == int(ProjectileTypeId.PLASMA_CANNON):
-                        spacing = 2.6
-                        seg_limit = 18
-                        tail_size = 44.0
-                        head_size = 84.0
-                        aura_size = 256.0
-                        # In the decompile, cannon reuses the tail alpha for the aura (0.4).
-                        aura_alpha_mul = 0.4
-                    elif type_id == int(ProjectileTypeId.SPIDER_PLASMA):
-                        rgb = (0.3, 1.0, 0.3)
-                        aura_rgb = rgb
-                    elif type_id == int(ProjectileTypeId.SHRINKIFIER):
-                        rgb = (0.3, 0.3, 1.0)
-                        aura_rgb = rgb
-
-                    if life >= 0.4:
-                        # Reconstruct the tail length heuristic used by the native render path.
-                        seg_count = int(float(getattr(proj, "base_damage", 0.0)))
-                        if seg_count < 0:
-                            seg_count = 0
-                        seg_count //= 5
-                        if seg_count > seg_limit:
-                            seg_count = seg_limit
-
-                        # The stored projectile angle is rotated by +pi/2 vs travel direction.
-                        dir_x = math.cos(angle + math.pi / 2.0) * speed_scale
-                        dir_y = math.sin(angle + math.pi / 2.0) * speed_scale
-
-                        tail_tint = self._color_from_rgba((rgb[0], rgb[1], rgb[2], alpha * 0.4))
-                        head_tint = self._color_from_rgba((rgb[0], rgb[1], rgb[2], alpha * head_alpha_mul))
-                        aura_tint = self._color_from_rgba((aura_rgb[0], aura_rgb[1], aura_rgb[2], alpha * aura_alpha_mul))
-
-                        rl.begin_blend_mode(rl.BLEND_ADDITIVE)
-
-                        if seg_count > 0:
-                            size = tail_size * scale
-                            origin = rl.Vector2(size * 0.5, size * 0.5)
-                            step_x = dir_x * spacing
-                            step_y = dir_y * spacing
-                            for idx in range(seg_count):
-                                px = pos_x + float(idx) * step_x
-                                py = pos_y + float(idx) * step_y
-                                psx, psy = self.world_to_screen(px, py)
-                                dst = rl.Rectangle(float(psx), float(psy), float(size), float(size))
-                                rl.draw_texture_pro(particles_texture, src, dst, origin, 0.0, tail_tint)
-
-                        size = head_size * scale
-                        origin = rl.Vector2(size * 0.5, size * 0.5)
-                        dst = rl.Rectangle(float(sx), float(sy), float(size), float(size))
-                        rl.draw_texture_pro(particles_texture, src, dst, origin, 0.0, head_tint)
-
-                        if fx_detail_1:
-                            size = aura_size * scale
-                            origin = rl.Vector2(size * 0.5, size * 0.5)
-                            dst = rl.Rectangle(float(sx), float(sy), float(size), float(size))
-                            rl.draw_texture_pro(particles_texture, src, dst, origin, 0.0, aura_tint)
-
-                        rl.end_blend_mode()
-                        return
-
-                    fade = clamp(life * 2.5, 0.0, 1.0)
-                    fade_alpha = fade * alpha
-                    if fade_alpha > 1e-3:
-                        tint = self._color_from_rgba((1.0, 1.0, 1.0, fade_alpha))
-                        size = 56.0 * scale
-                        dst = rl.Rectangle(float(sx), float(sy), float(size), float(size))
-                        origin = rl.Vector2(size * 0.5, size * 0.5)
-                        rl.begin_blend_mode(rl.BLEND_ADDITIVE)
-                        rl.draw_texture_pro(particles_texture, src, dst, origin, 0.0, tint)
-                        rl.end_blend_mode()
-                    return
-
-        if type_id in BEAM_TYPES and texture is not None:
-            # Ion weapons and Fire Bullets use the projs.png streak effect (and Ion adds chain arcs on impact).
-            grid = 4
-            frame = 2
-
-            is_fire_bullets = type_id == int(ProjectileTypeId.FIRE_BULLETS)
-            is_ion = type_id in ION_TYPES
-
-            ox = float(getattr(proj, "origin_x", pos_x))
-            oy = float(getattr(proj, "origin_y", pos_y))
-            dx = pos_x - ox
-            dy = pos_y - oy
-            dist = math.hypot(dx, dy)
-            if dist <= 1e-6:
-                return
-
-            dir_x = dx / dist
-            dir_y = dy / dist
-
-            # In the native renderer, Ion Gun Master increases the chain effect thickness and reach.
-            perk_scale = 1.0
-            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
-            else:
-                fade = clamp(life * 2.5, 0.0, 1.0)
-                base_alpha = fade * alpha
-
-            if base_alpha <= 1e-3:
-                return
-
-            streak_rgb = (1.0, 0.6, 0.1) if is_fire_bullets else (0.5, 0.6, 1.0)
-            head_rgb = (1.0, 1.0, 0.7)
-
-            # Only draw the last 256 units of the path.
-            start = 0.0
-            span = dist
-            if dist > 256.0:
-                start = dist - 256.0
-                span = 256.0
-
-            step = min(effect_scale * 3.1, 9.0)
-            sprite_scale = effect_scale * scale
-
-            rl.begin_blend_mode(rl.BLEND_ADDITIVE)
-
-            s = start
-            while s < dist:
-                t = (s - start) / span if span > 1e-6 else 1.0
-                seg_alpha = t * base_alpha
-                if seg_alpha > 1e-3:
-                    px = ox + dir_x * s
-                    py = oy + dir_y * s
-                    psx, psy = self.world_to_screen(px, py)
-                    tint = self._color_from_rgba((streak_rgb[0], streak_rgb[1], streak_rgb[2], seg_alpha))
-                    self._draw_atlas_sprite(
-                        texture,
-                        grid=grid,
-                        frame=frame,
-                        x=psx,
-                        y=psy,
-                        scale=sprite_scale,
-                        rotation_rad=angle,
-                        tint=tint,
-                    )
-                s += step
-
-            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,
-                )
-
-                # 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,
-                    grid=grid,
-                    frame=frame,
-                    x=sx,
-                    y=sy,
-                    scale=1.0 * scale,
-                    rotation_rad=angle,
-                    tint=core_tint,
-                )
-
-                if is_ion:
-                    # Native: chain reach is derived from the streak scale (`fVar29 * perk_scale * 40.0`).
-                    radius = effect_scale * perk_scale * 40.0
-
-                    # Native iterates via creature_find_in_radius(pos, radius, start_index) in pool order.
-                    targets: list[object] = []
-                    for creature in self.creatures.entries[1:]:
-                        if not creature.active:
-                            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.14285715 + 3.0
-                        if d - radius < threshold:
-                            targets.append(creature)
-
-                    inner_half = 10.0 * perk_scale * scale
-                    outer_half = 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_half
-                        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))
-                        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_half
-                        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=psx,
-                        y=psy,
-                        scale=sprite_scale,
-                        rotation_rad=0.0,
-                        tint=tint,
-                    )
-
-                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,
-            )
+        ctx = ProjectileDrawCtx(
+            renderer=self,
+            proj=proj,
+            proj_index=int(proj_index),
+            texture=texture,
+            type_id=int(type_id),
+            pos_x=float(pos_x),
+            pos_y=float(pos_y),
+            sx=float(sx),
+            sy=float(sy),
+            life=float(life),
+            angle=float(angle),
+            scale=float(scale),
+            alpha=float(alpha),
+        )
+        if draw_projectile_from_registry(ctx):
             return
 
         mapping = KNOWN_PROJ_FRAMES.get(type_id)
@@ -1234,18 +686,9 @@ class WorldRenderer:
             return
         grid, frame = mapping
 
-        color = rl.Color(240, 220, 160, 255)
-        if type_id in (ProjectileTypeId.ION_RIFLE, ProjectileTypeId.ION_MINIGUN, ProjectileTypeId.ION_CANNON):
-            color = rl.Color(120, 200, 255, 255)
-        elif type_id == ProjectileTypeId.FIRE_BULLETS:
-            color = rl.Color(255, 170, 90, 255)
-        elif type_id == ProjectileTypeId.SHRINKIFIER:
-            color = rl.Color(160, 255, 170, 255)
-        elif type_id == ProjectileTypeId.BLADE_GUN:
-            color = rl.Color(240, 120, 255, 255)
-
         alpha_byte = int(clamp(clamp(life / 0.4, 0.0, 1.0) * 255.0 * alpha, 0.0, 255.0) + 0.5)
-        tint = rl.Color(color.r, color.g, color.b, alpha_byte)
+        r, g, b = known_proj_rgb(type_id)
+        tint = rl.Color(int(r), int(g), int(b), alpha_byte)
         self._draw_atlas_sprite(
             texture,
             grid=grid,
@@ -1439,135 +882,17 @@ class WorldRenderer:
         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:
-            # 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()
+        ctx = SecondaryProjectileDrawCtx(
+            renderer=self,
+            proj=proj,
+            proj_type=int(proj_type),
+            sx=float(sx),
+            sy=float(sy),
+            angle=float(angle),
+            scale=float(scale),
+            alpha=float(alpha),
+        )
+        if draw_secondary_projectile_from_registry(ctx):
             return
         rl.draw_circle(int(sx), int(sy), max(1.0, 4.0 * scale), rl.Color(200, 200, 220, int(200 * alpha + 0.5)))
 
@@ -1865,6 +1190,23 @@ class WorldRenderer:
                             max(0.0, cell_w - 2.0),
                             max(0.0, cell_h - 2.0),
                         )
+            poison_src: rl.Rectangle | None = None
+            if particles_texture is not None:
+                atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x12)
+                if atlas is not None:
+                    grid = SIZE_CODE_GRID.get(int(atlas.size_code))
+                    if grid:
+                        frame = int(atlas.frame)
+                        col = frame % grid
+                        row = frame // grid
+                        cell_w = float(particles_texture.width) / float(grid)
+                        cell_h = float(particles_texture.height) / float(grid)
+                        poison_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_player(player: object) -> None:
                 if trooper_texture is not None:
@@ -1912,6 +1254,15 @@ class WorldRenderer:
                     type_id = None
                 asset = CREATURE_ASSET.get(type_id) if type_id is not None else None
                 texture = self.creature_textures.get(asset) if asset is not None else None
+                if particles_texture is not None and poison_src is not None and (creature.flags & CreatureFlags.SELF_DAMAGE_TICK):
+                    fade = monster_vision_fade_alpha(hitbox_size)
+                    poison_alpha = fade * entity_alpha
+                    if poison_alpha > 1e-3:
+                        size = 60.0 * scale
+                        dst = rl.Rectangle(float(sx), float(sy), float(size), float(size))
+                        origin = rl.Vector2(size * 0.5, size * 0.5)
+                        tint = rl.Color(255, 0, 0, int(clamp(poison_alpha, 0.0, 1.0) * 255.0 + 0.5))
+                        rl.draw_texture_pro(particles_texture, poison_src, dst, origin, 0.0, tint)
                 if monster_vision and particles_texture is not None and monster_vision_src is not None:
                     fade = monster_vision_fade_alpha(hitbox_size)
                     mv_alpha = fade * entity_alpha