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

crimson/render/projectile_render_registry.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..projectiles import ProjectileTypeId
+
+
+@dataclass(frozen=True, slots=True)
+class PlasmaProjectileRenderConfig:
+    rgb: tuple[float, float, float]
+    spacing: float
+    seg_limit: int
+    tail_size: float
+    head_size: float
+    head_alpha_mul: float
+    aura_rgb: tuple[float, float, float]
+    aura_size: float
+    aura_alpha_mul: float
+
+
+_DEFAULT_PLASMA_RENDER_CONFIG = PlasmaProjectileRenderConfig(
+    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=(1.0, 1.0, 1.0),
+    aura_size=120.0,
+    aura_alpha_mul=0.15,
+)
+
+
+PLASMA_PROJECTILE_RENDER_CONFIG_BY_TYPE_ID: dict[int, PlasmaProjectileRenderConfig] = {
+    int(ProjectileTypeId.PLASMA_RIFLE): PlasmaProjectileRenderConfig(
+        rgb=(1.0, 1.0, 1.0),
+        spacing=2.5,
+        seg_limit=8,
+        tail_size=22.0,
+        head_size=56.0,
+        head_alpha_mul=0.45,
+        aura_rgb=(1.0, 1.0, 1.0),
+        aura_size=256.0,
+        aura_alpha_mul=0.3,
+    ),
+    int(ProjectileTypeId.PLASMA_MINIGUN): _DEFAULT_PLASMA_RENDER_CONFIG,
+    int(ProjectileTypeId.PLASMA_CANNON): PlasmaProjectileRenderConfig(
+        rgb=(1.0, 1.0, 1.0),
+        spacing=2.6,
+        seg_limit=18,
+        tail_size=44.0,
+        head_size=84.0,
+        head_alpha_mul=0.45,
+        aura_rgb=(1.0, 1.0, 1.0),
+        aura_size=256.0,
+        aura_alpha_mul=0.4,
+    ),
+    int(ProjectileTypeId.SPIDER_PLASMA): PlasmaProjectileRenderConfig(
+        rgb=(0.3, 1.0, 0.3),
+        spacing=_DEFAULT_PLASMA_RENDER_CONFIG.spacing,
+        seg_limit=_DEFAULT_PLASMA_RENDER_CONFIG.seg_limit,
+        tail_size=_DEFAULT_PLASMA_RENDER_CONFIG.tail_size,
+        head_size=_DEFAULT_PLASMA_RENDER_CONFIG.head_size,
+        head_alpha_mul=_DEFAULT_PLASMA_RENDER_CONFIG.head_alpha_mul,
+        aura_rgb=(0.3, 1.0, 0.3),
+        aura_size=_DEFAULT_PLASMA_RENDER_CONFIG.aura_size,
+        aura_alpha_mul=_DEFAULT_PLASMA_RENDER_CONFIG.aura_alpha_mul,
+    ),
+    int(ProjectileTypeId.SHRINKIFIER): PlasmaProjectileRenderConfig(
+        rgb=(0.3, 0.3, 1.0),
+        spacing=_DEFAULT_PLASMA_RENDER_CONFIG.spacing,
+        seg_limit=_DEFAULT_PLASMA_RENDER_CONFIG.seg_limit,
+        tail_size=_DEFAULT_PLASMA_RENDER_CONFIG.tail_size,
+        head_size=_DEFAULT_PLASMA_RENDER_CONFIG.head_size,
+        head_alpha_mul=_DEFAULT_PLASMA_RENDER_CONFIG.head_alpha_mul,
+        aura_rgb=(0.3, 0.3, 1.0),
+        aura_size=_DEFAULT_PLASMA_RENDER_CONFIG.aura_size,
+        aura_alpha_mul=_DEFAULT_PLASMA_RENDER_CONFIG.aura_alpha_mul,
+    ),
+}
+
+
+def plasma_projectile_render_config(type_id: int) -> PlasmaProjectileRenderConfig:
+    return PLASMA_PROJECTILE_RENDER_CONFIG_BY_TYPE_ID.get(int(type_id), _DEFAULT_PLASMA_RENDER_CONFIG)
+
+
+BEAM_EFFECT_SCALE_BY_TYPE_ID: dict[int, float] = {
+    int(ProjectileTypeId.ION_MINIGUN): 1.05,
+    int(ProjectileTypeId.ION_RIFLE): 2.2,
+    int(ProjectileTypeId.ION_CANNON): 3.5,
+}
+
+
+def beam_effect_scale(type_id: int) -> float:
+    return float(BEAM_EFFECT_SCALE_BY_TYPE_ID.get(int(type_id), 0.8))
+
+
+KNOWN_PROJ_RGB_BY_TYPE_ID: dict[int, tuple[int, int, int]] = {
+    int(ProjectileTypeId.ION_RIFLE): (120, 200, 255),
+    int(ProjectileTypeId.ION_MINIGUN): (120, 200, 255),
+    int(ProjectileTypeId.ION_CANNON): (120, 200, 255),
+    int(ProjectileTypeId.FIRE_BULLETS): (255, 170, 90),
+    int(ProjectileTypeId.SHRINKIFIER): (160, 255, 170),
+    int(ProjectileTypeId.BLADE_GUN): (240, 120, 255),
+}
+
+
+def known_proj_rgb(type_id: int) -> tuple[int, int, int]:
+    return KNOWN_PROJ_RGB_BY_TYPE_ID.get(int(type_id), (240, 220, 160))
+

crimson/render/secondary_projectile_draw_registry.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+from typing import TYPE_CHECKING
+
+import pyray as rl
+
+from grim.math import clamp
+
+from ..effects_atlas import EFFECT_ID_ATLAS_TABLE_BY_ID, SIZE_CODE_GRID
+
+if TYPE_CHECKING:
+    from .world_renderer import WorldRenderer
+
+
+@dataclass(frozen=True, slots=True)
+class SecondaryProjectileDrawCtx:
+    renderer: WorldRenderer
+    proj: object
+    proj_type: int
+    sx: float
+    sy: float
+    angle: float
+    scale: float
+    alpha: float
+
+
+def _draw_secondary_rocket_like(ctx: SecondaryProjectileDrawCtx) -> bool:
+    renderer = ctx.renderer
+    proj_type = int(ctx.proj_type)
+    if proj_type not in (1, 2, 4):
+        return False
+
+    texture = renderer.projs_texture
+    if texture is None:
+        return False
+
+    cell_w = float(texture.width) / 4.0
+    if cell_w <= 1e-6:
+        return True
+
+    alpha = float(ctx.alpha)
+    base_alpha = clamp(alpha * 0.9, 0.0, 1.0)
+    base_tint = renderer._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 * float(ctx.scale)) / cell_w
+
+    fx_detail_1 = bool(renderer.config.data.get("fx_detail_1", 0)) if renderer.config is not None else True
+    if fx_detail_1 and renderer.particles_texture is not None:
+        particles_texture = renderer.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),
+                )
+
+                angle = float(ctx.angle)
+                dir_x = math.cos(angle - math.pi / 2.0)
+                dir_y = math.sin(angle - math.pi / 2.0)
+
+                sx = float(ctx.sx)
+                sy = float(ctx.sy)
+                scale = float(ctx.scale)
+
+                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 = renderer._color_from_rgba(rgba)
+                    fx_sx = sx - dir_x * offset * scale
+                    fx_sy = sy - dir_y * offset * scale
+                    dst_size = float(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()
+
+    renderer._draw_atlas_sprite(
+        texture,
+        grid=4,
+        frame=3,
+        x=float(ctx.sx),
+        y=float(ctx.sy),
+        scale=sprite_scale,
+        rotation_rad=float(ctx.angle),
+        tint=base_tint,
+    )
+    return True
+
+
+def _draw_secondary_type4_fallback(ctx: SecondaryProjectileDrawCtx) -> bool:
+    if int(ctx.proj_type) != 4:
+        return False
+    rl.draw_circle(
+        int(ctx.sx),
+        int(ctx.sy),
+        max(1.0, 12.0 * float(ctx.scale)),
+        rl.Color(200, 120, 255, int(255 * float(ctx.alpha) + 0.5)),
+    )
+    return True
+
+
+def _draw_secondary_detonation(ctx: SecondaryProjectileDrawCtx) -> bool:
+    renderer = ctx.renderer
+    if int(ctx.proj_type) != 3:
+        return False
+
+    # Secondary projectile detonation visuals (secondary_projectile_update + render).
+    t = clamp(float(getattr(ctx.proj, "vel_x", 0.0)), 0.0, 1.0)
+    det_scale = float(getattr(ctx.proj, "vel_y", 1.0))
+    fade = (1.0 - t) * float(ctx.alpha)
+    if fade <= 1e-3 or det_scale <= 1e-6:
+        return True
+
+    sx = float(ctx.sx)
+    sy = float(ctx.sy)
+    scale = float(ctx.scale)
+    if renderer.particles_texture is None:
+        radius = det_scale * t * 80.0
+        alpha_byte = int(clamp((1.0 - t) * 180.0 * float(ctx.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 True
+
+    atlas = EFFECT_ID_ATLAS_TABLE_BY_ID.get(0x0D)
+    if atlas is None:
+        return True
+    grid = SIZE_CODE_GRID.get(int(atlas.size_code))
+    if not grid:
+        return True
+    frame = int(atlas.frame)
+    col = frame % grid
+    row = frame // grid
+    cell_w = float(renderer.particles_texture.width) / float(grid)
+    cell_h = float(renderer.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 = float(size) * scale
+        if dst_size <= 1e-3:
+            return
+        tint = renderer._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(renderer.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 True
+
+
+SECONDARY_PROJECTILE_DRAW_HANDLERS = (
+    _draw_secondary_rocket_like,
+    _draw_secondary_type4_fallback,
+    _draw_secondary_detonation,
+)
+
+
+def draw_secondary_projectile_from_registry(ctx: SecondaryProjectileDrawCtx) -> bool:
+    for handler in SECONDARY_PROJECTILE_DRAW_HANDLERS:
+        if handler(ctx):
+            return True
+    return False
+