Confetti!

use std::ops::Range;

use bevy::{

app::{App, Update},

asset::Assets,

camera::Camera3d,

color::Color,

ecs::{

component::Component,

entity::Entity,

event::Event,

observer::On,

query::With,

system::{Commands, Query, Res, ResMut, Single},

},

math::{Dir3, FloatPow, Quat, Vec3, primitives::Plane3d},

mesh::{Mesh, Mesh3d, Meshable},

pbr::{MeshMaterial3d, StandardMaterial},

time::Time,

transform::components::Transform,

};

use rand::RngExt;

use crate::Rng;

pub trait ConfettiSystems {

fn add_confetti_systems(&mut self) -> &mut Self;

}

impl ConfettiSystems for App {

fn add_confetti_systems(&mut self) -> &mut Self {

self.add_observer(spawn_confetti)

.add_systems(Update, update)

}

}

#[derive(Event)]

pub struct SpawnConfetti {

pub origin: Vec3,

pub direction: Dir3,

pub count: usize,

}

#[derive(Component)]

struct Confetti {

velocity: Vec3,

rotation: Quat,

}

const CONE_ANGLE: f32 = std::f32::consts::FRAC_PI_8;

const INITIAL_VELOCITY: Range<f32> = 7.5..12.5;

const ROTATION_VELOCITY: Range<f32> = std::f32::consts::FRAC_PI_8..std::f32::consts::PI;

fn spawn_confetti(

confetti: On<SpawnConfetti>,

camera: Single<&Transform, With<Camera3d>>,

mut rng: ResMut<Rng>,

mut commands: Commands,

mut meshes: ResMut<Assets<Mesh>>,

mut materials: ResMut<Assets<StandardMaterial>>,

) {

(0..confetti.count).for_each(|_| {

let velocity = sample_cone(&mut rng, confetti.direction, CONE_ANGLE)

* rng.random_range(INITIAL_VELOCITY);

let rotation = Quat::from_axis_angle(

(camera.translation - confetti.origin).normalize(),

rng.random_range(ROTATION_VELOCITY),

);

commands.spawn((

Confetti { velocity, rotation },

Transform::from_translation(confetti.origin).with_rotation(rotation),

Mesh3d(meshes.add(Plane3d::default().mesh().size(0.1, 0.2))),

MeshMaterial3d(materials.add(StandardMaterial::from_color(Color::hsl(

rng.random_range(0.0..360.0),

1.0,

0.5,

)))),

));

});

}

fn sample_cone(rng: &mut Rng, direction: Dir3, angle: f32) -> Dir3 {

let rotation = Quat::from_rotation_arc(Vec3::Z, *direction);

let z = rng.random_range(angle.cos()..=1.0);

let theta = rng.random_range(0.0..std::f32::consts::TAU);

rotation

* Dir3::new_unchecked(Vec3::new(

(1.0 - z.squared()).sqrt() * theta.cos(),

(1.0 - z.squared()).sqrt() * theta.sin(),

z,

))

}

fn update(

mut commands: Commands,

time: Res<Time>,

mut confetti: Query<(Entity, &mut Transform, &mut Confetti)>,

) {

confetti

.iter_mut()

.for_each(|(entity, mut transform, mut confetti)| {

if transform.translation.y < 0.0 {

commands.entity(entity).despawn();

return;

}

transform.translation += confetti.velocity * time.delta_secs();

transform.rotation *= confetti.rotation;

confetti.velocity.y -= 9.82 * time.delta_secs();

});

}

use std::{

ops::{Add, DerefMut, RangeInclusive},

time::Duration,

};

children,

hierarchy::Children,

query::{With, Without},

log::warn,

math::{Dir3, Quat, Vec3, primitives::Circle},

time::Time,

confetti::SpawnConfetti,

const GOAL_AREA_WIDTH: RangeInclusive<f32> = -10.0..=10.0;

const GOAL_AREA_HEIGHT: RangeInclusive<f32> = -10.0..=10.0;

const GOAL_DURATION: f32 = 1.0;

const CELEBRATION_DURATION: f32 = 3.0;

#[derive(Component, Default)]

enum Goal {

#[default]

NotAchieved,

InProgress {

start: Duration,

},

Achieved {

start: Duration,

},

}

Transform::from_xyz(10.0, 0.0, 10.0)

.with_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),

Goal::default(),

children![(

Mesh3d(meshes.add(Circle::new(GOAL_RADIUS))),

MeshMaterial3d(materials.add(Color::linear_rgb(0.0, 0.0, 1.0))),

Transform::from_xyz(0.0, 0.0, 0.1).with_scale(Vec3::new(0.0, 0.0, 1.0)),

)],

mut commands: Commands,

time: Res<Time>,

mut rng: ResMut<Rng>,

mut goal: Single<(&mut Transform, &mut Goal, &Children)>,

mut transforms: Query<&mut Transform, Without<Goal>>,

let (transform, goal, children) = goal.deref_mut();

let in_goal = locator.get_nearby_count(transform.translation, GOAL_RADIUS);

match (in_goal == count, goal.as_ref()) {

(_, Goal::Achieved { start }) => {

if start.add(Duration::from_secs_f32(CELEBRATION_DURATION)) < time.elapsed() {

**goal = Goal::NotAchieved;

transform.translation = Vec3::new(

rng.random_range(GOAL_AREA_WIDTH),

0.0,

rng.random_range(GOAL_AREA_HEIGHT),

);

}

}

(true, Goal::NotAchieved) => {

**goal = Goal::InProgress {

start: time.elapsed(),

}

}

(true, Goal::InProgress { start }) => {

let Some(Ok(mut child)) = children.first().map(|c| transforms.get_mut(*c)) else {

warn!("Cannot get child of goal");

return;

};

if start.add(Duration::from_secs_f32(GOAL_DURATION)) < time.elapsed() {

commands.trigger(SpawnConfetti {

origin: transform.translation,

direction: Dir3::Y,

count: 1000,

});

**goal = Goal::Achieved {

start: time.elapsed(),

};

child.scale = Vec3::ZERO;

} else {

let scale = 1.0

- (start.add(Duration::from_secs_f32(GOAL_DURATION)) - time.elapsed())

.as_secs_f32()

/ GOAL_DURATION;

child.scale = Vec3::new(scale, scale, 1.0);

}

}

(false, Goal::NotAchieved) => {}

(false, Goal::InProgress { .. }) => {

let Some(Ok(mut child)) = children.first().map(|c| transforms.get_mut(*c)) else {

warn!("Cannot get child of goal");

return;

};

**goal = Goal::NotAchieved;

child.scale = Vec3::new(0.0, 0.0, 1.0);

}

}

mod confetti;

use crate::{bunnies::BunnySystems, confetti::ConfettiSystems, dog::DogSystems, goal::GoalSystems};

.add_confetti_systems()