audubon/src/lib.rs

use argh::FromArgs;
use bevy::prelude::*;

const SPEED: f32 = 20.0;
const SPEED_DIFF_RANGE: f32 = 0.08; // +/- 8%

#[derive(Debug, FromArgs, Resource)]
/// Toid Watching
pub struct Config {
    /// how many Toids to spawn
    #[argh(option, short = 't', default = "100")]
    pub toids: usize,
}

pub type Point = (f32, f32, f32);

pub type Toint = rstar::primitives::GeomWithData<Point, Entity>;

pub trait Pointable {
    fn to_point(&self) -> Point;
}

impl Pointable for Vec3 {
    fn to_point(&self) -> Point {
        (self.x, self.y, self.z)
    }
}

#[derive(Resource, Deref, DerefMut)]
pub struct Index(pub rstar::RTree<Toint>);

#[derive(Resource, Deref, DerefMut)]
pub struct Positions(pub std::collections::HashMap<Entity, Vec3>);

#[derive(Component, Debug, Clone, Deref, DerefMut, Default)]
pub struct Buddies(Vec<Entity>);

#[derive(Component, Debug, Clone, Deref, DerefMut, Default)]
pub struct Velocity(Vec3);

#[derive(Component)]
pub struct Toid {
    pub speed: f32,
}

pub fn turkey_time(
    commands: &mut Commands,
    scene: &Handle<Scene>,
    r: &mut impl rand::prelude::Rng,
) -> Entity {
    let speed_diff = r.gen_range(-SPEED_DIFF_RANGE..=SPEED_DIFF_RANGE);
    let speed = SPEED + (SPEED * speed_diff);
    let vel = unit_vec(r) * speed;
    commands
        .spawn(SpatialBundle::default())
        .insert((Velocity(vel), Buddies::default(), Toid { speed }))
        .with_children(|t| {
            t.spawn(SceneBundle {
                scene: scene.to_owned(),
                ..Default::default()
            })
            .insert(Transform::from_rotation(Quat::from_axis_angle(
                Vec3::Y,
                -std::f32::consts::FRAC_PI_2,
            )));
        })
        .id()
}

pub fn add_gizmos(mut gizmos: Gizmos, toids: Query<(&Transform, Entity), With<Toid>>) {
    let gizmos = &mut gizmos;
    for (pos, _entity) in toids.iter() {
        let nudge = pos.up() * 0.15;
        let rpos = pos.translation + nudge;
        gizmos.ray(rpos, pos.forward(), Color::RED);
    }
}

pub fn update_pos(
    mut toids: Query<(&mut Transform, &Velocity, Entity)>,
    time: Res<Time>,
    mut index: Res<Index>,
) {
    let dt = time.delta_seconds();
    for (mut xform, vel, _entity) in toids.iter_mut() {
        let vel = vel.0;
        xform.translation += vel * dt;
    }
}

pub fn update_vel(
    mut toids: Query<(&Transform, &mut Velocity, &Toid), With<Toid>>,
    time: Res<Time>,
) {
    let dt = time.delta_seconds();
    for (xform, mut vel, toid) in toids.iter_mut() {
        let speed = toid.speed;
        let mut dir = xform.forward();

        // nudge up if too low

        // nudge toward origin if too far

        // find buddies and orient: point more towards further-away buddies
    }
}

pub fn update_buddies(mut toids: Query<(&Transform, Entity, &mut Buddies)>, index: Res<Index>) {}

//-************************************************************************
// util
//-************************************************************************

pub fn unit_vec(r: &mut impl rand::prelude::Rng) -> Vec3 {
    let mut x1: f32 = 0.0;
    let mut x2: f32 = 0.0;
    let mut ssum = std::f32::MAX;
    while ssum >= 1.0 {
        x1 = r.gen_range(-1.0..=1.0);
        x2 = r.gen_range(-1.0..=1.0);
        ssum = x1.powi(2) + x2.powi(2);
    }
    let sqrt = (1.0 - ssum).sqrt();
    let x = 2.0 * x1 * sqrt;
    let y = 2.0 * x2 * sqrt;
    let z = 1.0 - 2.0 * ssum;
    Vec3::new(x, y, z).normalize()
}