361 lines
13 KiB
Rust
361 lines
13 KiB
Rust
/// file: main.rs
|
|
/// author: Rohmer Maxime <maxluligames@gmail.com>
|
|
/// date: 10/05/2022
|
|
/// version: 0.1.0
|
|
/// Sources:
|
|
/// https://eater.net/boids
|
|
/// https://docs.rs/sdl2/latest/sdl2/
|
|
|
|
use sdl2::pixels::Color;
|
|
use sdl2::event::Event;
|
|
use sdl2::keyboard::Keycode;
|
|
//use sdl2::keyboard::Scancode;
|
|
//use std::collections::HashSet;
|
|
use std::time::Duration;
|
|
use sdl2::rect::Point;
|
|
use sdl2::rect::Rect;
|
|
use rand::Rng;
|
|
|
|
const WINDOW_HEIGHT:i32 = 800;
|
|
const WINDOW_WIDTH:i32 = 1000;
|
|
const MAX_BIRD_SPEED:i32 = 40;
|
|
const BIRDS_COUNT:i32 = 200;
|
|
const BIRD_SIZE:i32 = 15;
|
|
|
|
const VISION_RANGE:i32 = 10;
|
|
const COHERENCE_RATE:i32 = 1;
|
|
const SEPRATION_RATE:i32 = 1;
|
|
const ALIGNEMENT_RATE:i32 = 1;
|
|
const NEIGHBOUR_TRESHOLD:i32 = 10;
|
|
|
|
pub struct Bird{
|
|
shape:Rect,
|
|
velocity:Point,
|
|
}
|
|
|
|
pub struct Simulation{
|
|
birds:Vec<Bird>,
|
|
}
|
|
impl Simulation{
|
|
pub fn render(&mut self,ctx:&mut sdl2::render::Canvas<sdl2::video::Window>){
|
|
ctx.set_draw_color(Color::RGB(0x6D, 0x6D, 0x64));
|
|
ctx.clear();
|
|
|
|
for bird in self.birds.iter(){
|
|
ctx.set_draw_color(Color::RGB(0x33, 0x33, 0x33));
|
|
ctx.fill_rect(bird.shape).expect("Rusty Boids");
|
|
ctx.set_draw_color(Color::RGB(0xe7, 0x4c, 0x3c));
|
|
let start_pos = Point::new(bird.shape.x + bird.shape.width() as i32 / 2,bird.shape.y + bird.shape.height() as i32 /2);
|
|
let end_pos = Point::new(start_pos.x + bird.velocity.x * 2,start_pos.y + bird.velocity.y * 2);
|
|
ctx.draw_line(start_pos,end_pos).expect("Could nor draw vector line");
|
|
}
|
|
}
|
|
pub fn apply_coherence(&mut self){
|
|
// first we calculate all the averages for every birds
|
|
let mut averages:Vec<Point> = Vec::with_capacity(BIRDS_COUNT as usize);
|
|
for i in 0..BIRDS_COUNT{
|
|
let mut sum = Point::new(0,0);
|
|
let target = &self.birds[i as usize];
|
|
let mut x_offset:i32;
|
|
let mut y_offset:i32;
|
|
let mut neighbours_count = 0;
|
|
for bird in &self.birds{
|
|
x_offset = (target.shape.x - bird.shape.x).abs();
|
|
y_offset = (target.shape.y - bird.shape.y).abs();
|
|
|
|
if x_offset <= VISION_RANGE && y_offset <= VISION_RANGE{
|
|
sum.x += bird.shape.x;
|
|
sum.y += bird.shape.y;
|
|
neighbours_count += 1;
|
|
}
|
|
}
|
|
let average = Point::new(sum.x / neighbours_count as i32,sum.y / neighbours_count as i32);
|
|
averages.push(average);
|
|
}
|
|
|
|
for i in 0..BIRDS_COUNT{
|
|
//now we need to steer torwards it
|
|
let bird = &mut self.birds[i as usize];
|
|
let posx = bird.shape.x;
|
|
let posy = bird.shape.y;
|
|
let average = averages[i as usize];
|
|
|
|
let mut added_velocity:Point = Point::new(0,0);
|
|
|
|
if posx > average.x{
|
|
added_velocity.x -= COHERENCE_RATE;
|
|
}else if posx < average.x{
|
|
added_velocity.x += COHERENCE_RATE;
|
|
}
|
|
|
|
if posy > average.y{
|
|
added_velocity.y -= COHERENCE_RATE;
|
|
}else if posy < average.y{
|
|
added_velocity.y += COHERENCE_RATE;
|
|
}
|
|
|
|
if added_velocity.x > COHERENCE_RATE / 3{
|
|
added_velocity.x = COHERENCE_RATE / 3;
|
|
}
|
|
if added_velocity.x < -COHERENCE_RATE / 3{
|
|
added_velocity.x = -COHERENCE_RATE / 3;
|
|
}
|
|
|
|
if added_velocity.y > COHERENCE_RATE / 3{
|
|
added_velocity.y = COHERENCE_RATE / 3;
|
|
}
|
|
if added_velocity.y < -COHERENCE_RATE / 3{
|
|
added_velocity.y = -COHERENCE_RATE / 3;
|
|
}
|
|
|
|
bird.velocity.x += added_velocity.x;
|
|
bird.velocity.y += added_velocity.y;
|
|
|
|
}
|
|
|
|
}
|
|
pub fn apply_separation(&mut self){
|
|
// first we calculate all the averages for every birds
|
|
let mut averages:Vec<Point> = Vec::with_capacity(BIRDS_COUNT as usize);
|
|
for i in 0..BIRDS_COUNT{
|
|
let mut sum = Point::new(0,0);
|
|
let target = &self.birds[i as usize];
|
|
let mut x_offset:i32;
|
|
let mut y_offset:i32;
|
|
let mut neighbours_count = 0;
|
|
for bird in &self.birds{
|
|
x_offset = (target.shape.x - bird.shape.x).abs();
|
|
y_offset = (target.shape.y - bird.shape.y).abs();
|
|
|
|
if x_offset <= NEIGHBOUR_TRESHOLD && y_offset <= NEIGHBOUR_TRESHOLD{
|
|
sum.x += bird.shape.x;
|
|
sum.y += bird.shape.y;
|
|
neighbours_count += 1;
|
|
}
|
|
}
|
|
let average = Point::new(sum.x / neighbours_count as i32,sum.y / neighbours_count as i32);
|
|
averages.push(average);
|
|
}
|
|
|
|
for i in 0..BIRDS_COUNT{
|
|
//now we need to steer torwards it
|
|
let bird = &mut self.birds[i as usize];
|
|
let posx = bird.shape.x;
|
|
let posy = bird.shape.y;
|
|
let average = averages[i as usize];
|
|
|
|
let mut added_velocity:Point = Point::new(0,0);
|
|
|
|
if posx > average.x{
|
|
added_velocity.x -= SEPRATION_RATE;
|
|
}else if posx < average.x{
|
|
added_velocity.x += SEPRATION_RATE;
|
|
}
|
|
|
|
if posy > average.y{
|
|
added_velocity.y -= SEPRATION_RATE;
|
|
}else if posy < average.y{
|
|
added_velocity.y += SEPRATION_RATE;
|
|
}
|
|
|
|
if added_velocity.x > MAX_BIRD_SPEED / 3{
|
|
added_velocity.x = MAX_BIRD_SPEED / 3;
|
|
}
|
|
if added_velocity.x < -MAX_BIRD_SPEED / 3{
|
|
added_velocity.x = -MAX_BIRD_SPEED / 3;
|
|
}
|
|
|
|
if added_velocity.y > MAX_BIRD_SPEED / 3{
|
|
added_velocity.y = MAX_BIRD_SPEED / 3;
|
|
}
|
|
if added_velocity.y < -MAX_BIRD_SPEED / 3{
|
|
added_velocity.y = -MAX_BIRD_SPEED / 3;
|
|
}
|
|
|
|
bird.velocity.x += added_velocity.x;
|
|
bird.velocity.y += added_velocity.y;
|
|
}
|
|
}
|
|
pub fn apply_alignement(&mut self){
|
|
// first we calculate all the averages for every birds
|
|
let mut averages:Vec<Point> = Vec::with_capacity(BIRDS_COUNT as usize);
|
|
for i in 0..BIRDS_COUNT{
|
|
let mut sum = Point::new(0,0);
|
|
let target = &self.birds[i as usize];
|
|
let mut x_offset:i32;
|
|
let mut y_offset:i32;
|
|
let mut neighbours_count = 0;
|
|
for bird in &self.birds{
|
|
x_offset = (target.shape.x - bird.shape.x).abs();
|
|
y_offset = (target.shape.y - bird.shape.y).abs();
|
|
if x_offset <= VISION_RANGE && y_offset <= VISION_RANGE{
|
|
sum.x += bird.velocity.x;
|
|
sum.y += bird.velocity.y;
|
|
neighbours_count += 1;
|
|
}
|
|
}
|
|
let average = Point::new(sum.x / neighbours_count as i32,sum.y / neighbours_count as i32);
|
|
averages.push(average);
|
|
}
|
|
|
|
for i in 0..BIRDS_COUNT{
|
|
//now we need to steer torwards it
|
|
let bird = &mut self.birds[i as usize];
|
|
let posx = bird.shape.x;
|
|
let posy = bird.shape.y;
|
|
let average = averages[i as usize];
|
|
|
|
let mut added_velocity:Point = Point::new(0,0);
|
|
|
|
if posx > average.x{
|
|
added_velocity.x -= ALIGNEMENT_RATE;
|
|
}else if posx < average.x{
|
|
added_velocity.x += ALIGNEMENT_RATE;
|
|
}
|
|
|
|
if posy > average.y{
|
|
added_velocity.y -= ALIGNEMENT_RATE;
|
|
}else if posy < average.y{
|
|
added_velocity.y += ALIGNEMENT_RATE;
|
|
}
|
|
|
|
if added_velocity.x > MAX_BIRD_SPEED / 3{
|
|
added_velocity.x = MAX_BIRD_SPEED / 3;
|
|
}
|
|
if added_velocity.x < -MAX_BIRD_SPEED / 3{
|
|
added_velocity.x = -MAX_BIRD_SPEED / 3;
|
|
}
|
|
|
|
if added_velocity.y > MAX_BIRD_SPEED / 3{
|
|
added_velocity.y = MAX_BIRD_SPEED / 3;
|
|
}
|
|
if added_velocity.y < -MAX_BIRD_SPEED / 3{
|
|
added_velocity.y = -MAX_BIRD_SPEED / 3;
|
|
}
|
|
|
|
bird.velocity.x += added_velocity.x;
|
|
bird.velocity.y += added_velocity.y;
|
|
|
|
}
|
|
}
|
|
pub fn update(&mut self){
|
|
self.apply_coherence();
|
|
self.apply_alignement();
|
|
self.apply_separation();
|
|
|
|
for bird in &mut self.birds{
|
|
check_velocity(bird);
|
|
let mut posx = bird.shape.x;
|
|
let mut posy = bird.shape.y;
|
|
let width:i32 = bird.shape.width() as i32;
|
|
let height:i32 = bird.shape.height() as i32;
|
|
|
|
let push_back = 1;
|
|
let soft_border_margin = 30;
|
|
let left_soft_border = 0 + soft_border_margin;
|
|
let right_soft_border = WINDOW_WIDTH - soft_border_margin;
|
|
let top_soft_border = 0 + soft_border_margin;
|
|
let bottom_soft_border = WINDOW_HEIGHT -soft_border_margin;
|
|
|
|
|
|
if posx + bird.velocity.x > WINDOW_WIDTH - width || posx + bird.velocity.x < 0{
|
|
bird.velocity.x = 0;
|
|
}
|
|
if posy + bird.velocity.y > WINDOW_HEIGHT - height || posy + bird.velocity.y < 0{
|
|
bird.velocity.y = 0;
|
|
}
|
|
|
|
if posx + bird.velocity.x > right_soft_border && bird.velocity.x <= 0{
|
|
//the bird is coming from the border so we accelerate it
|
|
bird.velocity.x -= push_back;
|
|
}else{
|
|
bird.velocity.x += push_back;
|
|
}
|
|
if posx - bird.velocity.x < left_soft_border && bird.velocity.x >= 0{
|
|
//the bird is coming from the border so we accelerate it
|
|
bird.velocity.x += push_back;
|
|
}else{
|
|
bird.velocity.x -= push_back;
|
|
}
|
|
|
|
if posy + bird.velocity.y > bottom_soft_border && bird.velocity.y <= 0{
|
|
//the bird is coming from the border so we accelerate it
|
|
bird.velocity.y -= push_back;
|
|
}else{
|
|
bird.velocity.y += push_back;
|
|
}
|
|
if posy - bird.velocity.y < top_soft_border && bird.velocity.y >= 0{
|
|
//the bird is coming from the border so we accelerate it
|
|
bird.velocity.y += push_back;
|
|
}else{
|
|
bird.velocity.y -= push_back;
|
|
}
|
|
|
|
posx += bird.velocity.x;
|
|
posy += bird.velocity.y;
|
|
|
|
bird.shape.set_x(posx);
|
|
bird.shape.set_y(posy);
|
|
|
|
bird.velocity = Point::new(0,0);
|
|
}
|
|
}
|
|
}
|
|
pub fn check_velocity(bird:&mut Bird){
|
|
if bird.velocity.y > MAX_BIRD_SPEED{
|
|
bird.velocity.y = MAX_BIRD_SPEED;
|
|
}else if bird.velocity.y < -MAX_BIRD_SPEED{
|
|
bird.velocity.y = -MAX_BIRD_SPEED;
|
|
}
|
|
if bird.velocity.x > MAX_BIRD_SPEED{
|
|
bird.velocity.x = MAX_BIRD_SPEED;
|
|
}else if bird.velocity.x < -MAX_BIRD_SPEED{
|
|
bird.velocity.x = -MAX_BIRD_SPEED;
|
|
}
|
|
}
|
|
|
|
pub fn main_loop(canvas: &mut sdl2::render::Canvas<sdl2::video::Window>,event_pump:&mut sdl2::EventPump,game:&mut Simulation){
|
|
'running: loop {
|
|
for event in event_pump.poll_iter() {
|
|
match event {
|
|
Event::Quit {..} |
|
|
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
|
|
break 'running
|
|
},
|
|
_ => {}
|
|
}
|
|
}
|
|
// MAIN LOOP
|
|
game.update();
|
|
game.render(canvas);
|
|
// MAIN LOOP
|
|
canvas.present();
|
|
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
|
|
}
|
|
}
|
|
pub fn generate_birds() -> Vec<Bird>{
|
|
let mut rng = rand::thread_rng();
|
|
let mut birds = Vec::with_capacity(BIRDS_COUNT as usize);
|
|
for _bird in 0..BIRDS_COUNT{
|
|
let rectangle = Rect::new(rng.gen_range(0..WINDOW_WIDTH - BIRD_SIZE),rng.gen_range(0..WINDOW_HEIGHT - BIRD_SIZE),BIRD_SIZE as u32, BIRD_SIZE as u32);
|
|
let velocity = Point::new(rng.gen_range(-MAX_BIRD_SPEED..MAX_BIRD_SPEED), rng.gen_range(-MAX_BIRD_SPEED..MAX_BIRD_SPEED));
|
|
birds.push(Bird{shape:rectangle,velocity:velocity});
|
|
}
|
|
return birds;
|
|
}
|
|
pub fn main() {
|
|
let sdl_context = sdl2::init().unwrap();
|
|
let video_subsystem = sdl_context.video().unwrap();
|
|
|
|
let window = video_subsystem.window("Rust Boids Simulation", WINDOW_WIDTH as u32, WINDOW_HEIGHT as u32)
|
|
.position_centered()
|
|
.build()
|
|
.unwrap();
|
|
|
|
let mut canvas = window.into_canvas().build().unwrap();
|
|
let mut event_pump = sdl_context.event_pump().unwrap();
|
|
|
|
let mut simulation = Simulation{birds:generate_birds()};
|
|
|
|
main_loop(&mut canvas,&mut event_pump,&mut simulation);
|
|
} |