crimsonland 0.1.0.dev5__py3-none-any.whl → 0.1.0.dev11__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),
@@ -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,32 +936,23 @@ 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
-
-                    # 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:
+                    # 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:
+                        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]]
+                        if d - radius < threshold:
+                            targets.append(creature)
 
-                    inner = 10.0 * perk_scale * scale
-                    outer = 14.0 * perk_scale * scale
+                    inner_half = 10.0 * perk_scale * scale
+                    outer_half = 14.0 * perk_scale * scale
                     u = 0.625
                     v0 = 0.0
                     v1 = 0.25
@@ -984,7 +976,7 @@ class WorldRenderer:
                         py = nx
 
                         # Outer strip (softer).
-                        half = outer * 0.5
+                        half = outer_half
                         off_x = px * half
                         off_y = py * half
                         x0 = sx - off_x
@@ -996,7 +988,7 @@ class WorldRenderer:
                         x3 = tx - off_x
                         y3 = ty - off_y
 
-                        outer_tint = self._color_from_rgba((0.5, 0.6, 1.0, base_alpha * 0.5))
+                        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)
@@ -1008,7 +1000,7 @@ class WorldRenderer:
                         rl.rl_vertex2f(x3, y3)
 
                         # Inner strip (brighter).
-                        half = inner * 0.5
+                        half = inner_half
                         off_x = px * half
                         off_y = py * half
                         x0 = sx - off_x
@@ -1346,6 +1338,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 +1521,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 +1615,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 +2020,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