Add event moments: predation flashes and cull/bloom shockwaves

A lightweight cosmetic effects layer draws expanding glowing rings into the
HDR scene: hot-gold flashes at predation kill sites (subsampled so a busy
food web sparkles rather than strobes), a green seed-burst on bloom and on
each click-to-seed, and a red shockwave on cull. Effects are sim-side
side-data (capped, aged per tick, never read back so determinism holds) with
their own additive pipeline; the ring is interpolated between ticks for a
smooth 60fps expansion. Birth/death already read via the health-driven fade.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rgilks

src/lib.rs

@@ -21,12 +21,17 @@ const FLOATS_PER_ENTITY: usize = 10;
 /// Floats packed per food patch in the render buffer: x, y, radius, intensity_fraction.
 const FLOATS_PER_PATCH: usize = 4;
 
+/// Floats packed per visual effect in the render buffer:
+/// x, y, base_radius, life, life_step, kind.
+const FLOATS_PER_EFFECT: usize = 6;
+
 #[wasm_bindgen]
 pub struct WebSimulation {
     simulation: simulation::Simulation,
     seed: u64,
     entity_buffer: Vec<f32>, // Reusable buffer for entity data
     food_buffer: Vec<f32>,   // Reusable buffer for food-patch render data
+    effect_buffer: Vec<f32>, // Reusable buffer for transient visual effects
 }
 
 #[wasm_bindgen]
@@ -103,6 +108,27 @@ impl WebSimulation {
         (self.food_buffer.len() / FLOATS_PER_PATCH) as u32
     }
 
+    /// Update the effect buffer and return a pointer for the WebGPU renderer.
+    /// Layout per effect: x, y, base_radius, life, life_step, kind (6 floats).
+    pub fn update_effect_buffer(&mut self) -> *const f32 {
+        let effects = self.simulation.get_effects();
+        self.effect_buffer.clear();
+        for (x, y, radius, life, life_step, kind) in effects {
+            self.effect_buffer.push(x);
+            self.effect_buffer.push(y);
+            self.effect_buffer.push(radius);
+            self.effect_buffer.push(life);
+            self.effect_buffer.push(life_step);
+            self.effect_buffer.push(kind);
+        }
+        self.effect_buffer.as_ptr()
+    }
+
+    /// Number of effects in the last buffered frame (from `update_effect_buffer`).
+    pub fn effect_count(&self) -> u32 {
+        (self.effect_buffer.len() / FLOATS_PER_EFFECT) as u32
+    }
+
     pub fn get_stats(&self) -> JsValue {
         let config = self.simulation.config();
         let stats = stats::SimulationStats::from_world(
@@ -180,6 +206,7 @@ impl WebSimulation {
             seed,
             entity_buffer: Vec::with_capacity(100000), // 10000 entities * 10 floats
             food_buffer: Vec::with_capacity(64),       // a handful of patches * 4 floats
+            effect_buffer: Vec::with_capacity(2400),   // up to ~400 effects * 6 floats
         })
     }
 }

src/shader.wgsl

@@ -230,3 +230,79 @@ fn food_fs(in: FoodVertexOutput) -> @location(0) vec4<f32> {
 
     return vec4<f32>(rgb, soft);
 }
+
+// ---------------------------------------------------------------------------
+// Transient effects: expanding glowing rings for predation flashes (kind 0),
+// bloom/seed bursts (kind 1), and cull shockwaves (kind 2). Drawn additively
+// into the HDR scene AFTER the creatures so they read as flashes on top. The
+// ring animation is interpolated between sim ticks via the shared
+// interpolation_factor, so it stays smooth even though effects age at the
+// (slower) tick rate.
+// ---------------------------------------------------------------------------
+
+struct EffectInstance {
+    // x = world x, y = world y, z = base radius (world), w = life (age/max_age, 0..1)
+    @location(0) a: vec4<f32>,
+    // x = life_step (1/max_age), y = kind (0..2)
+    @location(1) b: vec2<f32>,
+}
+
+struct EffectVertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) life: f32,
+    @location(2) kind: f32,
+}
+
+@vertex
+fn effect_vs(
+    instance: EffectInstance,
+    @builtin(vertex_index) vertex_index: u32,
+) -> EffectVertexOutput {
+    var out: EffectVertexOutput;
+
+    let quad_pos = QUAD_VERTICES[vertex_index];
+    let world_pos = instance.a.xy;
+    let base_radius = instance.a.z;
+    // Interpolate life between ticks for a smooth 60fps expansion.
+    let life = clamp(instance.a.w + uniforms.interpolation_factor * instance.b.x, 0.0, 1.0);
+    let world_size = uniforms.world_size;
+
+    let world_to_screen_x = (world_pos.x + world_size / 2.0) / world_size * 2.0 - 1.0;
+    let world_to_screen_y = -((world_pos.y + world_size / 2.0) / world_size * 2.0 - 1.0);
+    let screen_x = (world_to_screen_x + uniforms.camera_x) * uniforms.camera_zoom;
+    let screen_y = (world_to_screen_y + uniforms.camera_y) * uniforms.camera_zoom;
+    let screen_pos = vec2<f32>(screen_x, screen_y);
+
+    let screen_radius = base_radius / world_size * 2.0 * uniforms.camera_zoom;
+
+    out.position = vec4<f32>(screen_pos + quad_pos * screen_radius, 0.0, 1.0);
+    out.uv = quad_pos;
+    out.life = life;
+    out.kind = instance.b.y;
+    return out;
+}
+
+@fragment
+fn effect_fs(in: EffectVertexOutput) -> @location(0) vec4<f32> {
+    let d = length(in.uv);
+    let life = in.life;
+    // A ring expanding from centre to rim over its life, widening as it goes.
+    let r = life;
+    let thickness = 0.10 + 0.12 * life;
+    let ring = exp(-pow((d - r) / thickness, 2.0));
+    // Dissolve as it reaches the rim.
+    let fade = pow(1.0 - life, 1.5);
+    let intensity = ring * fade;
+
+    // Colour by kind: hot gold flash, green seed-burst, red cull ripple.
+    var col = vec3<f32>(1.0, 0.85, 0.5);
+    if (in.kind > 1.5) {
+        col = vec3<f32>(1.0, 0.4, 0.45);
+    } else if (in.kind > 0.5) {
+        col = vec3<f32>(0.5, 1.0, 0.6);
+    }
+
+    let rgb = col * intensity * 1.7;
+    return vec4<f32>(rgb, intensity);
+}

src/simulation/mod.rs

@@ -23,6 +23,26 @@ use rng::{
     generate_particle_matrix, mix_seed, BLOOM_SALT, CULL_SALT, DEFAULT_SEED, OFFSPRING_SALT,
 };
 
+/// Max simultaneous visual effects. Effects are short-lived, so the live set
+/// stays well under this; new ones past the cap are dropped (purely cosmetic).
+const EFFECT_CAP: usize = 400;
+
+/// A transient visual flourish (predation flash, bloom burst, cull shockwave) —
+/// an expanding glowing ring the renderer draws. Pure cosmetic side-data derived
+/// from events that already happen deterministically; never read back into the
+/// simulation, so it can't affect determinism.
+#[derive(Clone)]
+struct Effect {
+    x: f32,
+    y: f32,
+    /// Final ring radius in world units.
+    base_radius: f32,
+    age: u32,
+    max_age: u32,
+    /// 0 = predation flash, 1 = bloom/seed burst, 2 = cull shockwave.
+    kind: f32,
+}
+
 /// Stable numeric id for a movement style, packed into the render buffer so the
 /// shader can vary a creature's look by behaviour (e.g. mark predators).
 fn movement_style_id(style: &MovementType) -> f32 {
@@ -70,6 +90,9 @@ pub struct Simulation {
     /// the engine of the boom/bust waves. Updated once per tick in the serial
     /// phase; read immutably by the parallel compute.
     crowding_pressure: f32,
+    /// Transient visual effects (flashes/rings) drawn by the renderer. Cosmetic
+    /// side-data only; aged each tick and never read back into the sim.
+    effects: Vec<Effect>,
 
     // System instances
     movement_system: MovementSystem,
@@ -127,6 +150,7 @@ impl Simulation {
             particle_matrix: generate_particle_matrix(seed),
             food_field,
             crowding_pressure,
+            effects: Vec::new(),
             movement_system: MovementSystem,
             interaction_system: InteractionSystem,
             energy_system: EnergySystem,
@@ -218,6 +242,8 @@ impl Simulation {
         for entity in doomed {
             let _ = self.world.despawn(entity);
         }
+        // A cool shockwave ripple radiating from the centre.
+        self.add_effect(0.0, 0.0, self.world_size * 0.6, 45, 2.0);
     }
 
     /// Instantly spawn a burst of `count` fresh random creatures near the centre
@@ -250,6 +276,8 @@ impl Simulation {
                 self.config.physics.min_entity_radius,
             ));
         }
+        // A bright burst of life at the centre.
+        self.add_effect(0.0, 0.0, self.world_size * 0.14, 30, 1.0);
     }
 
     /// Spawn a tight burst of `count` fresh creatures around world `(x, y)` — the
@@ -285,6 +313,32 @@ impl Simulation {
                 self.config.physics.min_entity_radius,
             ));
         }
+        // A seed-of-life burst at the cursor, even if the cap left no room.
+        self.add_effect(x, y, self.world_size * 0.08, 26, 1.0);
+    }
+
+    /// Queue a transient visual effect (cosmetic ring/flash). Dropped silently
+    /// once the active set hits `EFFECT_CAP`.
+    fn add_effect(&mut self, x: f32, y: f32, base_radius: f32, max_age: u32, kind: f32) {
+        if self.effects.len() >= EFFECT_CAP {
+            return;
+        }
+        self.effects.push(Effect {
+            x,
+            y,
+            base_radius,
+            age: 0,
+            max_age,
+            kind,
+        });
+    }
+
+    /// Advance every effect by one tick and drop the expired ones.
+    fn age_effects(&mut self) {
+        for e in &mut self.effects {
+            e.age += 1;
+        }
+        self.effects.retain(|e| e.age < e.max_age);
     }
 
     pub fn update(&mut self) {
@@ -330,6 +384,7 @@ impl Simulation {
         self.rebuild_spatial_grid();
         let updates = self.process_entities_parallel();
         self.apply_entity_updates(updates);
+        self.age_effects();
     }
 
     /// The initial population density (used to seed the crowding pressure).
@@ -596,6 +651,18 @@ impl Simulation {
         for bundle in offspring {
             self.world.spawn(bundle);
         }
+
+        // Record a few predation flashes at the kill sites — subsampled so a
+        // churning food web sparkles rather than strobes. Purely cosmetic.
+        let mut pred_seen = 0u32;
+        for update in &updates {
+            if update.eaten_entity.is_some() && update.energy.current > 0.0 {
+                if pred_seen.is_multiple_of(3) {
+                    self.add_effect(update.pos.x, update.pos.y, self.world_size * 0.022, 12, 0.0);
+                }
+                pred_seen += 1;
+            }
+        }
     }
 
     /// Per-entity render data:
@@ -650,6 +717,24 @@ impl Simulation {
             .collect()
     }
 
+    /// Render data for the transient visual effects:
+    /// `(x, y, base_radius, life, life_step, kind)` per effect, where `life` is
+    /// `age/max_age` (0..1) and `life_step` is `1/max_age` so the renderer can
+    /// interpolate the ring animation smoothly between ticks.
+    pub fn get_effects(&self) -> Vec<(f32, f32, f32, f32, f32, f32)> {
+        self.effects
+            .iter()
+            .map(|e| {
+                let (life, step) = if e.max_age > 0 {
+                    (e.age as f32 / e.max_age as f32, 1.0 / e.max_age as f32)
+                } else {
+                    (1.0, 0.0)
+                };
+                (e.x, e.y, e.base_radius, life, step, e.kind)
+            })
+            .collect()
+    }
+
     /// Centroid and a robust focus radius of the live population, in world units,
     /// so the UI can frame the swarm. The radius is ~2.4× the RMS distance from
     /// the centroid (a handful of stragglers can't blow it up), clamped to a sane