use bevy::prelude::*;
use crate::generator::GeneratorSystems;
use crate::world::VoxelBroken;
#[derive(Resource, Debug, Clone)]
pub struct FragmentConfig {
pub count: u32,
pub initial_speed: f32,
pub gravity: f32,
pub lifetime: f32,
pub size: f32,
}
impl Default for FragmentConfig {
fn default() -> Self {
Self {
count: 6,
initial_speed: 4.0,
gravity: 9.8,
lifetime: 1.5,
size: 0.2,
}
}
}
#[derive(Resource)]
pub struct FragmentAssets {
pub mesh: Handle<Mesh>,
pub material: Handle<StandardMaterial>,
}
#[derive(Component)]
pub struct Fragment {
pub velocity: Vec3,
pub lifetime_remaining: f32,
}
#[inline]
fn pseudo_rand(mut seed: u32) -> f32 {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
(seed as f32) / (u32::MAX as f32)
}
#[inline]
fn position_seed(world_pos: Vec3, index: u32) -> u32 {
let ix = (world_pos.x * 1000.0) as i32 as u32;
let iy = (world_pos.y * 1000.0) as i32 as u32;
let iz = (world_pos.z * 1000.0) as i32 as u32;
let h = ix.wrapping_mul(2654435761)
^ iy.wrapping_mul(2246822519)
^ iz.wrapping_mul(3266489917)
^ index.wrapping_mul(1013904223);
h ^ (h >> 16)
}
fn fragment_direction(world_pos: Vec3, index: u32, count: u32) -> Vec3 {
const GOLDEN_ANGLE: f32 = 2.399_963;
let seed_a = position_seed(world_pos, index * 3);
let seed_b = position_seed(world_pos, index * 3 + 1);
let seed_c = position_seed(world_pos, index * 3 + 2);
let t = if count > 1 {
index as f32 / (count - 1) as f32
} else {
0.5
};
let elevation = std::f32::consts::FRAC_PI_8
+ t * (std::f32::consts::FRAC_PI_2 - std::f32::consts::FRAC_PI_4);
let azimuth = index as f32 * GOLDEN_ANGLE + pseudo_rand(seed_a) * 0.3;
let elevation_jitter = (pseudo_rand(seed_b) - 0.5) * 0.4;
let final_elevation = (elevation + elevation_jitter).clamp(0.05, std::f32::consts::FRAC_PI_2);
let _speed_jitter = 0.7 + pseudo_rand(seed_c) * 0.6;
let (sin_el, cos_el) = final_elevation.sin_cos();
let (sin_az, cos_az) = azimuth.sin_cos();
Vec3::new(cos_el * cos_az, sin_el, cos_el * sin_az).normalize()
}
fn setup_fragment_assets(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
config: Res<FragmentConfig>,
) {
let mesh = meshes.add(Cuboid::new(config.size, config.size, config.size));
let material = materials.add(StandardMaterial {
base_color: Color::srgb(0.55, 0.50, 0.47),
unlit: true,
..default()
});
commands.insert_resource(FragmentAssets { mesh, material });
}
fn spawn_fragments_system(
mut commands: Commands,
mut reader: MessageReader<VoxelBroken>,
config: Res<FragmentConfig>,
assets: Res<FragmentAssets>,
) {
for event in reader.read() {
let origin = event.world_pos;
for i in 0..config.count {
let dir = fragment_direction(origin, i, config.count);
let seed = position_seed(origin, i * 3 + 2);
let speed_scale = 0.7 + pseudo_rand(seed) * 0.6;
let velocity = dir * config.initial_speed * speed_scale;
let offset_seed_x = position_seed(origin, i * 7);
let offset_seed_y = position_seed(origin, i * 7 + 1);
let offset_seed_z = position_seed(origin, i * 7 + 2);
let offset = Vec3::new(
(pseudo_rand(offset_seed_x) - 0.5) * config.size * 2.0,
(pseudo_rand(offset_seed_y) - 0.5) * config.size * 2.0,
(pseudo_rand(offset_seed_z) - 0.5) * config.size * 2.0,
);
commands.spawn((
Mesh3d(assets.mesh.clone()),
MeshMaterial3d(assets.material.clone()),
Transform::from_translation(origin + offset),
Fragment {
velocity,
lifetime_remaining: config.lifetime,
},
));
}
}
}
fn update_fragments_system(
mut commands: Commands,
time: Res<Time>,
mut query: Query<(Entity, &mut Transform, &mut Fragment)>,
config: Res<FragmentConfig>,
) {
let delta = time.delta_secs();
for (entity, mut transform, mut fragment) in &mut query {
fragment.velocity.y -= config.gravity * delta;
transform.translation += fragment.velocity * delta;
fragment.lifetime_remaining -= delta;
if fragment.lifetime_remaining <= 0.0 {
commands.entity(entity).despawn();
}
}
}
pub struct FragmentPlugin;
impl Plugin for FragmentPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<FragmentConfig>();
app.add_systems(Startup, setup_fragment_assets);
app.add_systems(Update, spawn_fragments_system.after(GeneratorSystems));
app.add_systems(Update, update_fragments_system);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_fragment_config_defaults() {
let config = FragmentConfig::default();
assert_eq!(config.count, 6);
assert!((config.initial_speed - 4.0).abs() < f32::EPSILON);
assert!((config.gravity - 9.8).abs() < f32::EPSILON);
assert!((config.lifetime - 1.5).abs() < f32::EPSILON);
assert!((config.size - 0.2).abs() < f32::EPSILON);
}
#[test]
fn test_fragment_despawns_after_lifetime() {
let config = FragmentConfig::default();
let mut lifetime_remaining = config.lifetime;
let velocity = Vec3::new(1.0, 2.0, 0.5);
let gravity = config.gravity;
let mut translation = Vec3::ZERO;
let mut vel = velocity;
let delta = 0.1_f32;
let mut despawned = false;
for _ in 0..100 {
vel.y -= gravity * delta;
translation += vel * delta;
lifetime_remaining -= delta;
if lifetime_remaining <= 0.0 {
despawned = true;
break;
}
}
assert!(despawned, "fragment should despawn when lifetime expires");
assert!(lifetime_remaining <= 0.0, "lifetime must reach zero");
assert!(
translation.length() > 0.0,
"fragment should have moved before despawning"
);
}
}