nora

src/main.rs

@@ -70,14 +70,14 @@ async fn main() {
     let mut size: u32 = 100;
     let mut world: World = World::new(None, None, None);
 
-    let mut hlayers: Vec<usize> = vec![6, 6, 0];
+    let mut hlayers: Vec<usize> = vec![20, 6, 0];
     let mut prev_hlayers = hlayers.clone();
 
     let mut mut_rate = 0.05;
     let mut prev_mut_rate = 0.05;
 
-    let mut activ: usize = 0;
-    let mut prev_activ: usize = 0;
+    let mut activ: usize = 2;
+    let mut prev_activ: usize = 2;
     let activs = [
         ActivationFunc::ReLU,
         ActivationFunc::Sigmoid,
@@ -94,9 +94,8 @@ async fn main() {
     );
 
     let ui_thick = 34.;
-    let nums = &[
-        "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16",
-    ];
+    let nums_owning: Vec<String> = (0..=20).into_iter().map(|i| format!("{:00}", i)).collect();
+    let nums: Vec<&str> = nums_owning.iter().map(|v| v.as_str()).collect();
     let skin = skins::get_ui_skin();
     let skin2 = skins::get_white_buttons_skin();
     let skin3 = skins::get_green_buttons_skin();
@@ -390,9 +389,9 @@ async fn main() {
                     ui.label(None, "Hidden Layers");
                     ui.label(None, "Neurons Config");
 
-                    ui.combo_box(hash!(), "Layer 1", nums, &mut hlayers[0]);
-                    ui.combo_box(hash!(), "Layer 2", nums, &mut hlayers[1]);
-                    ui.combo_box(hash!(), "Layer 3", nums, &mut hlayers[2]);
+                    ui.combo_box(hash!(), "Layer 1", &nums, &mut hlayers[0]);
+                    ui.combo_box(hash!(), "Layer 2", &nums, &mut hlayers[1]);
+                    ui.combo_box(hash!(), "Layer 3", &nums, &mut hlayers[2]);
                     if prev_hlayers != hlayers {
                         pop = Population::new(
                             size as usize,

src/nn.rs

@@ -85,7 +85,8 @@ impl NN {
         // println!("inputs: {:?}", inputs);
         let mut y = DMatrix::from_vec(inputs.len(), 1, inputs.to_vec());
         for i in 0..self.config.len() - 1 {
-            y = (&self.weights[i] * y.insert_row(self.config[i] - 1, 1.)).map(|x| {
+            let row = y.insert_row(self.config[i] - 1, 1.);
+            y = (&self.weights[i] * row).map(|x| {
                 match self.activ_func {
                     ActivationFunc::ReLU => x.max(0.),
                     ActivationFunc::Sigmoid => 1. / (1. + (-x).exp()),

src/player.rs

@@ -7,6 +7,12 @@ use crate::{
     nn::{ActivationFunc, NN},
     HEIGHT, WIDTH,
 };
+const NUM_KEYS: usize = 4;
+const INPUTS_PER_ASTEROID: usize = 4;
+const NUM_ASTEROIDS: usize = 5;
+const INPUTS_FOR_SHIP: usize = 1;
+const VALUES_PER_MEMORY: usize = 1;
+const NUM_MEMORIES: usize = 3;
 #[derive(Default)]
 pub struct Player {
     pub pos: Vec2,
@@ -16,17 +22,16 @@ pub struct Player {
     rot: f32,
     drag: f32,
     bullets: Vec<Bullet>,
-    asteroid: Option<Asteroid>,
+    asteroids: Vec<Option<Asteroid>>,
     inputs: Vec<f32>,
     pub outputs: Vec<f32>,
-    // asteroid_data: Vec<(f32, f32, f32)>,
-    raycasts: Vec<f32>,
     last_shot: u32,
     shot_interval: u32,
     pub brain: Option<NN>,
     alive: bool,
     pub lifespan: u32,
     pub shots: u32,
+    memory: std::collections::VecDeque<f32>,
 }
 
 impl Player {
@@ -40,9 +45,14 @@ impl Player {
                 Some(mut c) => {
                     c.retain(|&x| x != 0);
                     // Number of inputs
-                    c.insert(0, 5);
+                    c.insert(
+                        0,
+                        (INPUTS_PER_ASTEROID * NUM_ASTEROIDS)
+                            + INPUTS_FOR_SHIP
+                            + (VALUES_PER_MEMORY * NUM_MEMORIES),
+                    );
                     // Number of outputs
-                    c.push(4);
+                    c.push(NUM_KEYS + VALUES_PER_MEMORY);
                     Some(NN::new(c, mut_rate.unwrap(), activ.unwrap()))
                 }
                 _ => None,
@@ -55,51 +65,18 @@ impl Player {
             shot_interval: 18,
             alive: true,
             shots: 4,
-            outputs: vec![0.; 4],
-            raycasts: vec![0.; 8],
+            // 4 outputs, 1 for memory
+            outputs: vec![0.; NUM_KEYS + VALUES_PER_MEMORY],
+            memory: vec![0.; VALUES_PER_MEMORY * NUM_MEMORIES].into(),
 
             ..Default::default()
         }
     }
 
     pub fn check_player_collision(&mut self, asteroid: &Asteroid) -> bool {
-        // To give more near asteroids data:
+        // Save the asteroid to our asteroids
+        self.asteroids.push(Some(asteroid.clone()));
 
-        // self.asteroid_data.push((
-        //     ((asteroid.pos - self.pos).length() - asteroid.radius) / WIDTH,
-        //     self.dir.angle_between(asteroid.pos - self.pos),
-        //     (asteroid.vel - self.vel).length(),
-        // ));
-
-        // Single asteroid data:
-        if self.asteroid.is_none()
-            || (asteroid.pos).distance_squared(self.pos)
-                < self
-                    .asteroid
-                    .as_ref()
-                    .unwrap()
-                    .pos
-                    .distance_squared(self.pos)
-        {
-            self.asteroid = Some(asteroid.clone());
-        }
-
-        // Try raycasting below:
-
-        // let v = asteroid.pos - self.pos;
-        // for i in 0..4 {
-        //     let dir = Vec2::from_angle(PI / 4. * i as f32).rotate(self.dir);
-        //     let cross = v.perp_dot(dir);
-        //     let dot = v.dot(dir);
-        //     if cross.abs() <= asteroid.radius {
-        //         self.raycasts[if dot >= 0. { i } else { i + 4 }] = *partial_max(
-        //             &self.raycasts[if dot >= 0. { i } else { i + 4 }],
-        //             &(100.
-        //                 / (dot.abs() - (asteroid.radius * asteroid.radius - cross * cross).sqrt())),
-        //         )
-        //         .unwrap();
-        //     }
-        // }
         if asteroid.check_collision(self.pos, 8.) || self.lifespan > 3600 && self.brain.is_some() {
             self.alive = false;
             return true;
@@ -107,12 +84,28 @@ impl Player {
         false
     }
 
+    pub fn consider_asteroids(pos: Vec2, asteroids: &mut Vec<Option<Asteroid>>) {
+        // Consider the closest asteroids first
+        asteroids.sort_by_key(|ast| match ast {
+            None => i32::MAX,
+            Some(ast) => (dist_wrapping(ast.pos, pos) * 100.) as i32,
+        });
+        // Cull if there are too may asteroids
+        *asteroids = asteroids.iter().cloned().take(NUM_ASTEROIDS).collect();
+        // Insert if there are not enought asteroids
+        if asteroids.len() < NUM_ASTEROIDS {
+            for _ in 0..NUM_ASTEROIDS - asteroids.len() {
+                asteroids.push(None);
+            }
+        }
+        assert_eq!(asteroids.len(), NUM_ASTEROIDS);
+    }
+
     pub fn check_bullet_collisions(&mut self, asteroid: &mut Asteroid) -> bool {
         for bullet in &mut self.bullets {
             if asteroid.check_collision(bullet.pos, 0.) {
                 asteroid.alive = false;
                 bullet.alive = false;
-                self.asteroid = None;
                 return true;
             }
         }
@@ -125,46 +118,50 @@ impl Player {
         self.acc = 0.;
         self.outputs = vec![0.; 4];
         let mut keys = vec![false; 4];
-        if let Some(ast) = self.asteroid.as_ref() {
-            self.inputs = vec![
-                (ast.pos - self.pos).length() / HEIGHT,
-                self.dir.angle_between(ast.pos - self.pos),
-                (ast.vel - self.vel).x * 0.6,
-                (ast.vel - self.vel).y * 0.6,
-                self.rot / TAU as f32,
-                // self.vel.x / 8.,
-                // self.vel.y / 8.,
-                // self.rot / TAU as f32,
-            ];
-            // self.inputs.append(self.raycasts.as_mut());
-
-            // self.asteroid_data
-            //     .sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
-            // self.asteroid_data.resize(1, (0., 0., 0.));
-            // inputs.append(
-            //     &mut self
-            //         .asteroid_data
-            //         .iter()
-            //         .map(|(d, a, h)| vec![*d, *a, *h])
-            //         .flatten()
-            //         .collect::<Vec<_>>(),
-            // );
-
-            if let Some(brain) = &self.brain {
-                self.outputs = brain.feed_forward(&self.inputs);
-                keys = self
-                    .outputs
-                    .iter()
-                    .map(|&x| {
-                        x > if brain.activ_func == ActivationFunc::Sigmoid {
-                            0.85
-                        } else {
-                            0.
-                        }
-                    })
-                    .collect();
+        self.inputs = vec![];
+        // Insert all the asteroid data
+        Self::consider_asteroids(self.pos, &mut self.asteroids);
+        for ast in &self.asteroids {
+            if let Some(ast) = ast {
+                self.inputs.extend_from_slice(&[
+                    // Distance to asteroid
+                    dist_wrapping(ast.pos, self.pos),
+                    // Angle to asteroid
+                    self.dir.angle_between(ast.pos - self.pos),
+                    // Asteroid velocity x
+                    (ast.vel - self.vel).x * 0.6,
+                    // Asteroid velocity y
+                    (ast.vel - self.vel).y * 0.6,
+                ]);
+            } else {
+                self.inputs.extend_from_slice(&[0., 0., 0., 0.]);
             }
         }
+        assert_eq!(self.inputs.len(), NUM_ASTEROIDS * INPUTS_PER_ASTEROID);
+        // Insert the ship data
+        self.inputs.push(self.rot / TAU as f32);
+        // Insert the memories
+        for memory in &self.memory {
+            self.inputs.push(memory.min(1.).max(-1.));
+        }
+        // Run the brain
+        if let Some(brain) = &self.brain {
+            assert_eq!(self.inputs.len(), brain.config[0] - 1);
+            self.outputs = brain.feed_forward(&self.inputs);
+            self.memory.push_back(self.outputs[self.outputs.len() - 1]);
+            self.memory.pop_front();
+            keys = self
+                .outputs
+                .iter()
+                .map(|&x| {
+                    x > if brain.activ_func == ActivationFunc::Sigmoid {
+                        0.85
+                    } else {
+                        0.
+                    }
+                })
+                .collect();
+        }
         if keys[0] || self.brain.is_none() && is_key_down(KeyCode::Right) {
             // RIGHT
             self.rot = (self.rot + 0.1 + TAU as f32) % TAU as f32;
@@ -187,6 +184,7 @@ impl Player {
                     pos: self.pos + self.dir * 20.,
                     vel: self.dir * 8.5 + self.vel,
                     alive: true,
+                    travelled: Vec2::new(0., 0.),
                 });
             }
         }
@@ -204,10 +202,8 @@ impl Player {
             bullet.update();
         }
         self.bullets
-            .retain(|b| b.alive && b.pos.x.abs() * 2. < WIDTH && b.pos.y.abs() * 2. < HEIGHT);
-        self.asteroid = None;
-        // self.asteroid_data.clear();
-        // self.raycasts = vec![0.; 8];
+            .retain(|b| b.alive);
+        self.asteroids = vec![];
     }
 
     pub fn draw(&self, color: Color, debug: bool) {
@@ -226,7 +222,10 @@ impl Player {
             draw_triangle_lines(p6, p7, p8, 2., color);
         }
         if debug {
-            if let Some(ast) = self.asteroid.as_ref() {
+            let mut debug_asteroids = self.asteroids.clone();
+            Self::consider_asteroids(self.pos, &mut debug_asteroids);
+            for asteroid in &debug_asteroids {
+            if let Some(ast) = asteroid {
                 draw_circle_lines(ast.pos.x, ast.pos.y, ast.radius, 1., RED);
                 // let p = self.pos
                 //     + self.dir.rotate(Vec2::from_angle(self.asteroid_data[0].1))
@@ -234,6 +233,7 @@ impl Player {
                 //         * WIDTH;
                 draw_line(self.pos.x, self.pos.y, ast.pos.x, ast.pos.y, 1., RED);
             }
+            }
 
             // Draw raycasts
 
@@ -266,13 +266,39 @@ struct Bullet {
     pos: Vec2,
     vel: Vec2,
     alive: bool,
+    travelled: Vec2,
 }
 
 impl Bullet {
     fn update(&mut self) {
         self.pos += self.vel;
+        if self.pos.x.abs() > WIDTH * 0.5 {
+            self.pos.x *= -1.;
+        }
+        if self.pos.y.abs() > HEIGHT * 0.5 {
+            self.pos.y *= -1.;
+        }
+        self.travelled += self.vel;
+        if self.travelled.length() >= (WIDTH*WIDTH + HEIGHT*HEIGHT).sqrt() / 2. {
+            self.alive = false;
+        }
     }
     fn draw(&self, c: Color) {
         draw_circle(self.pos.x, self.pos.y, 2., Color::new(c.r, c.g, c.b, 0.9));
     }
 }
+
+// Distance in a toroidal space:
+// https://blog.demofox.org/2017/10/01/calculating-the-distance-between-points-in-wrap-around-toroidal-space/
+fn dist_wrapping(a: Vec2, b: Vec2) -> f32 {
+    let mut dx = (a.x - b.x).abs();
+    let mut dy = (a.y - b.y).abs();
+
+    if dx > (WIDTH as f32 / 2.) {
+        dx = WIDTH as f32 - dx;
+    }
+    if dy > (HEIGHT as f32 / 2.) {
+        dy = HEIGHT as f32 - dy;
+    }
+    (dx*dx + dy*dy).sqrt() / (WIDTH*WIDTH + HEIGHT*HEIGHT).sqrt()
+}

src/population.rs

@@ -150,10 +150,7 @@ impl Population {
         let total = self.worlds.iter().fold(0., |acc, x| acc + x.fitness);
         self.worlds
             .sort_by(|a, b| b.fitness.partial_cmp(&a.fitness).unwrap());
-        for i in &self.worlds {
-            println!("Fitness: {}", i.fitness);
-        }
-        println!("Gen: {}, Fitness: {}", self.gen, self.worlds[0].fitness);
+        println!("{}", self.worlds[0].fitness);
         let mut new_worlds = (0..std::cmp::max(1, self.size / 20))
             .map(|i| World::simulate(self.worlds[i].see_brain().to_owned()))
             .collect::<Vec<_>>();

src/world.rs

@@ -102,8 +102,7 @@ impl World {
                 self.over = true;
             }
         }
-        self.fitness =
-            (self.score / self.player.shots as f32).powi(2) * self.player.lifespan as f32;
+        self.fitness = (self.score as f32).powi(2) + (self.player.lifespan) as f32;
         self.asteroids.append(&mut to_add);
         self.asteroids.retain(|asteroid| asteroid.alive);
         // if self.asteroids.iter().fold(0, |acc, x| {