Compiler Explorer

Source code

use std::cell::RefCell;

#[derive(Clone, Copy, PartialEq)]
pub struct Vec2 {
    pub x: f32,
    pub y: f32,
}

impl Vec2 {
    pub const ZERO: Self = Self{x: 0f32, y: 0f32};

pub fn distance(self, rhs: Self) -> f32 {
        let x = self.x - rhs.x;
        let y = self.y - rhs.y;
        (x*x + y*y).sqrt()
    }

pub fn clamp_length_max(self, max: f32) -> Self {
        let length = self.distance(Self::ZERO);
        if length > max {
            let mut copy = self;
            copy /= length;
            copy * max
        } else {
            self
        }
    }

pub fn normalize(mut self) -> Self {
        let length = self.distance(Self::ZERO);
        self /= length;
        self
    }
}

impl std::ops::Mul<f32> for Vec2 {
    type Output = Self;
    fn mul(self, rhs: f32) -> Self {
        Vec2 {x: self.x * rhs, y: self.y * rhs}
    }
}

impl std::ops::AddAssign for Vec2 {
    fn add_assign(&mut self, rhs: Self) {
        self.x += rhs.x;
        self.y += rhs.y;
    }
}

impl std::ops::SubAssign for Vec2 {
    fn sub_assign(&mut self, rhs: Self) {
        self.x -= rhs.x;
        self.y -= rhs.y;
    }
}

impl std::ops::DivAssign<f32> for Vec2 {
    fn div_assign(&mut self, rhs: f32) {
        self.x /= rhs;
        self.y /= rhs;
    }
}

#[repr(C)]
pub struct Boid {
    position: Vec2,
    velocity: Vec2,
    acceleration: Vec2,
    life_history: [i32; 512],
}

pub type BoidCell = RefCell<Boid>;
pub type BoidRef = Box<BoidCell>;
const PERCEPTION: f32 = 100.0;
const MAX_SPEED: f32 = 100.0;
const MAX_FORCE: f32 = 80.0;

impl Boid {
    pub fn new(position: Vec2, velocity: Vec2) -> Self {
        Boid {
            position,
            velocity,
            acceleration: Vec2{x: 0f32, y: 0f32},
            life_history: [0; 512],
        }
    }

#[inline(always)]
    fn is_close_enough(&self, other: &Boid, max_dist: f32) -> bool {
        let distance = self.position.distance(other.position);
        distance < max_dist && distance > 0.0
    }

#[inline(never)]
    pub fn alignment(&self, boids: &[BoidRef], self_idx: usize) -> Vec2 {
        let mut alignment = Vec2::ZERO;
        let mut total = 0;

for other_idx in 0..boids.len() {
            if other_idx == self_idx {
                continue;
            }

let other = boids[other_idx].borrow();
            if self.is_close_enough(&other, PERCEPTION) {
                alignment += other.velocity;
                total += 1;
            }
        }

if total > 0 {
            alignment /= total as f32;
            alignment = alignment.normalize() * MAX_SPEED;
            alignment -= self.velocity;
            alignment = alignment.clamp_length_max(MAX_FORCE);
        }
        alignment
    }
}

pub fn main() {

}