Some kind of directional boid behaviour

"rand 0.9.4",

"rand 0.10.1",

"rand_chacha 0.10.0",

name = "chacha20"

version = "0.10.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"

dependencies = [

"cfg-if",

"cpufeatures",

"rand_core 0.10.1",

]

[[package]]

"rand_core 0.10.1",

"rand 0.9.4",

"rand_chacha 0.9.0",

"rand_core 0.9.5",

]

[[package]]

name = "rand"

version = "0.10.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"

dependencies = [

"chacha20",

"getrandom 0.4.2",

"rand_core 0.10.1",

"rand_core 0.9.5",

]

[[package]]

name = "rand_chacha"

version = "0.10.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb"

dependencies = [

"ppv-lite86",

"rand_core 0.10.1",

name = "rand_core"

version = "0.10.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"

[[package]]

"rand 0.9.4",

bevy = { version = "0.18.1", features = ["debug"] }

rand = "0.10.1"

rand_chacha = "0.10.0"

use std::{ops::DerefMut, time::Duration};

use bevy::{

app::{App, Startup, Update},

asset::{AssetServer, Assets},

ecs::{

component::Component,

entity::Entity,

query::{With, Without},

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

},

gltf::GltfAssetLabel,

math::{Dir3, Vec3, primitives::Cuboid},

mesh::{Mesh, Mesh3d, MeshBuilder, Meshable},

scene::SceneRoot,

time::Time,

transform::components::Transform,

};

use rand::RngExt;

use crate::{Rng, bunnies::locator::Locator, dog::Dog, obstacles::Obstacles};

pub(super) fn add_bunny_systems(app: &mut App) -> &mut App {

app.add_systems(Startup, setup)

.add_systems(Update, (calculate, jump))

}

#[derive(Component)]

pub(super) struct Bunny;

#[derive(Component)]

enum JumpState {

Jumping { from: Vec3, to: Vec3 },

Cooldown { ready: Duration },

}

const BUNNY_COUNT: usize = 5;

const DETECTION_DISTANCE: f32 = 5.0;

const SHORT_JUMP_DISTANCE: f32 = 1.0;

const LONG_JUMP_DISTANCE: f32 = 3.0;

const LONE_JUMPS_PER_SECOND: f64 = 1.0;

const COLLECTIVE_JUMPS_PER_SECOND: f64 = 1.0;

const JUMP_HEIGHT: f32 = 1.0;

const JUMP_COOLDOWN: f32 = 0.05;

const DESIRED_SPEED: f32 = 10.0;

const SPEED: f32 = LONG_JUMP_DISTANCE / (LONG_JUMP_DISTANCE / DESIRED_SPEED - JUMP_COOLDOWN);

fn setup(

mut commands: Commands,

asset_server: Res<AssetServer>,

mut meshes: ResMut<Assets<Mesh>>,

mut rng: ResMut<Rng>,

) {

let model =

asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/cube-pets/animal-bunny.glb"));

let mesh = meshes.add(Cuboid::from_length(2.0).mesh().build());

for _ in 0..BUNNY_COUNT {

commands.spawn((

SceneRoot(model.clone()),

Transform::from_xyz(

rng.random_range(-15.0..=15.0),

0.0,

rng.random_range(-15.0..=15.0),

),

Mesh3d(mesh.clone()),

Bunny,

));

}

}

type IdleBunniesQuery<'w, 's, 't> =

Query<'w, 's, (Entity, &'t mut Transform), (With<Bunny>, Without<JumpState>)>;

fn calculate(

mut commands: Commands,

time: Res<Time>,

locator: Res<Locator>,

dog: Single<&Transform, (With<Dog>, Without<Bunny>)>,

mut bunnies: IdleBunniesQuery,

mut obstacles: Obstacles,

mut rng: ResMut<Rng>,

) {

bunnies.iter_mut().for_each(|(bunny, mut bunny_transform)| {

calculate_next_move(

&mut commands,

&time,

&locator,

&dog,

&mut bunny_transform,

bunny,

&mut obstacles,

&mut rng,

);

});

}

fn calculate_next_move(

commands: &mut Commands,

time: &Time,

locator: &Locator,

dog: &Transform,

bunny_transform: &mut Transform,

bunny: Entity,

obstacles: &mut Obstacles,

rng: &mut Rng,

) {

if let Some(direction) = is_dog_nearby(dog, bunny_transform) {

jump_away_from_dog(commands, bunny_transform, bunny, obstacles, direction);

} else if let Some(nearby_bunnies) = is_near_others(locator, bunny, bunny_transform) {

jump_with_others(

commands,

time,

obstacles,

bunny,

bunny_transform,

nearby_bunnies,

rng,

);

} else {

jump_alone(commands, time, obstacles, bunny, bunny_transform, rng);

}

}

fn is_dog_nearby(dog: &Transform, bunny_transform: &mut Transform) -> Option<Vec3> {

let direction = bunny_transform.translation - dog.translation;

if direction.length_squared() > DETECTION_DISTANCE * DETECTION_DISTANCE {

return None;

}

Some(direction)

}

fn jump_away_from_dog(

commands: &mut Commands,

bunny_transform: &mut Transform,

bunny: Entity,

obstacles: &mut Obstacles,

direction: Vec3,

) {

let dog_direction = direction.with_y(0.0).normalize();

let Some(to) = obstacles.avoid(

bunny_transform.translation,

bunny_transform.translation + dog_direction * LONG_JUMP_DISTANCE,

) else {

return;

};

start_jump(commands, bunny, bunny_transform, to);

}

fn is_near_others(

locator: &Locator,

bunny: Entity,

bunny_transform: &Transform,

) -> Option<Vec<(Entity, (Vec3, Dir3))>> {

let nearby_bunnies = locator.get_nearby(bunny, bunny_transform.translation, DETECTION_DISTANCE);

if nearby_bunnies.is_empty() {

None

} else {

Some(nearby_bunnies)

}

}

fn jump_with_others(

commands: &mut Commands,

time: &Time,

obstacles: &mut Obstacles,

bunny: Entity,

bunny_transform: &mut Transform,

nearby_bunnies: Vec<(Entity, (Vec3, Dir3))>,

rng: &mut Rng,

) {

if !rng.random_bool((COLLECTIVE_JUMPS_PER_SECOND * time.delta_secs_f64()).clamp(0.0, 1.0)) {

return;

}

let average_direction = calculate_average_direction(nearby_bunnies);

let Some(to) = obstacles.avoid(

bunny_transform.translation,

bunny_transform.translation + average_direction * SHORT_JUMP_DISTANCE,

) else {

return;

};

start_jump(commands, bunny, bunny_transform, to);

fn calculate_average_direction(nearby_bunnies: Vec<(Entity, (Vec3, Dir3))>) -> Vec3 {

let (sin, cos) = nearby_bunnies

.iter()

.skip(1)

.fold((0.0, 0.0), |a, (_, (_, d))| {

let angle = d.angle_between(Vec3::Z);

(a.0 + angle.sin(), a.1 + angle.cos())

});

let average_angle = sin.atan2(cos);

let average_direction = Dir3::Z.rotate_y(average_angle);

average_direction

}

}

fn jump_alone(

commands: &mut Commands,

time: &Time,

obstacles: &mut Obstacles,

bunny: Entity,

bunny_transform: &mut Transform,

rng: &mut Rng,

) {

if !rng.random_bool((LONE_JUMPS_PER_SECOND * time.delta_secs_f64()).clamp(0.0, 1.0)) {

return;

}

let angle = rng.random_range(-std::f32::consts::PI..=std::f32::consts::PI);

let direction = Dir3::Z.rotate_y(angle);

let Some(to) = obstacles.avoid(

bunny_transform.translation,

bunny_transform.translation + direction * LONG_JUMP_DISTANCE,

) else {

return;

};

start_jump(commands, bunny, bunny_transform, to);

}

fn start_jump(commands: &mut Commands, bunny: Entity, bunny_transform: &mut Transform, to: Vec3) {

commands.entity(bunny).insert(JumpState::Jumping {

from: bunny_transform.translation,

to,

});

bunny_transform.look_to(-(to - bunny_transform.translation), Vec3::Y);

}

fn jump(

mut commands: Commands,

time: Res<Time>,

mut bunnies: Query<(Entity, &mut Transform, &mut JumpState), With<Bunny>>,

) {

bunnies.iter_mut().for_each(

|(bunny, mut bunny_transform, ref mut jump_state)| match jump_state.deref_mut() {

JumpState::Jumping { from, to } => {

let from = *from;

let to = *to;

animate_jumping(

&time,

&mut bunny_transform,

jump_state.deref_mut(),

from,

to,

)

}

JumpState::Cooldown { ready } => {

let ready = *ready;

cooldown(&mut commands, &time, bunny, ready);

}

},

);

}

fn animate_jumping(

time: &Time,

bunny_transform: &mut Transform,

jump_state: &mut JumpState,

from: Vec3,

to: Vec3,

) {

let current = bunny_transform.translation.with_y(to.y);

let direction = to - current;

let delta = SPEED * time.delta_secs();

let (direction, length) = direction.normalize_and_length();

if length <= delta {

bunny_transform.translation = to;

*jump_state = JumpState::Cooldown {

ready: time.elapsed() + Duration::from_secs_f32(JUMP_COOLDOWN),

};

return;

}

let next = current + direction.normalize() * delta;

let total_distance = from.distance(to);

bunny_transform.translation = next

+ Vec3::Y

* JUMP_HEIGHT

* (std::f32::consts::PI * from.distance(next) / total_distance).sin();

}

fn cooldown(commands: &mut Commands, time: &Time, bunny: Entity, ready: Duration) {

if time.elapsed() >= ready {

commands.entity(bunny).remove::<JumpState>();

}

}

use std::collections::HashMap;

use bevy::{

app::{App, PreUpdate},

ecs::{

entity::Entity,

query::With,

resource::Resource,

system::{Query, ResMut},

},

math::{Dir3, Vec3},

transform::components::Transform,

};

use crate::bunnies::bunny::Bunny;

pub fn add_locator(app: &mut App) -> &mut App {

app.init_resource::<Locator>()

.add_systems(PreUpdate, update_locator)

}

fn update_locator(mut locator: ResMut<Locator>, bunnies: Query<(Entity, &Transform), With<Bunny>>) {

bunnies

.iter()

.for_each(|(bunny, transform)| locator.set(bunny, transform.translation, transform.back()));

}

#[derive(Resource, Default)]

pub(super) struct Locator {

bunnies: HashMap<Entity, (Vec3, Dir3)>,

}

impl Locator {

fn set(&mut self, bunny: Entity, position: Vec3, direction: Dir3) {

self.bunnies.insert(bunny, (position, direction));

}

pub(super) fn get_nearby(

&self,

this: Entity,

center: Vec3,

radius: f32,

) -> Vec<(Entity, (Vec3, Dir3))> {

self.bunnies

.iter()

.filter(|(e, (pos, _))| **e != this && center.distance(*pos) <= radius)

.map(|(b, (p, d))| (*b, (*p, *d)))

.collect::<Vec<_>>()

}

}

mod bunny;

mod locator;

use bevy::app::App;

use crate::bunnies::{bunny::add_bunny_systems, locator::add_locator};

pub trait BunnySystems {

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

}

impl BunnySystems for App {

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

add_bunny_systems(self);

add_locator(self)

}

}

mod bunnies;

ecs::{

resource::Resource,

system::{Commands, Res, ResMut},

},

prelude::{Deref, DerefMut},

use rand::SeedableRng;

use rand_chacha::ChaCha8Rng;

use crate::bunnies::BunnySystems;

.init_resource::<Rng>()

viewport_height: 30.0,

const SIDE: usize = 30;

#[derive(Resource, Deref, DerefMut)]

struct Rng(ChaCha8Rng);

impl Default for Rng {

fn default() -> Self {

Self(ChaCha8Rng::seed_from_u64(0))

}

}