Split (#130)

* Tons of stuff in this commit. Initial asteroid splitting implementation.

* Stopped sub-splits. Recalculated radius per-split.

* Got rid of "Gaps" in split asteroids

* Spin changes; shape refinements

* Removed some unused variables

* Removed unused function

* Clippy stuff...

* More clippy

* More clippy!!!

* Update asteroid.rs

* Update asteroid.rs

* Refactored indexing so it works for arbitrary numbers of chunks

* Avoided using a "for" index to access an array

* Rustfmt

* Removed extra Positioned features and fixed PI

* Removed comment

Author: mcdenhoed

src/game/mod.rs

@@ -154,6 +154,10 @@ impl Updateable for Game {
                 if let Some(index) = asteroids
                        .iter()
                        .position(|asteroid| asteroid.collides_with(bullet)) {
+                    if asteroids[index].can_split() {
+                        let new_asteroids = asteroids[index].split(bullet);
+                        asteroids.extend(new_asteroids);
+                    }
                     asteroids.remove(index);
                     *score += 10;
                     music::play_sound(&Sound::AsteroidExplosion, music::Repeat::Times(0));

src/game/models/asteroid.rs

@@ -1,5 +1,6 @@
 //! This module defines the asteroid component.
 use std::{cmp, f64};
+use std::f64::consts::PI;
 
 use opengl_graphics::GlGraphics;
 use piston_window::{Context, polygon, Size, Transformed, UpdateArgs};
@@ -97,6 +98,32 @@ fn generate_jagged_shape(radius: f64, num_segments: usize) -> Vec<[f64; 2]> {
     randomize_shape(new_shape, max_mut)
 }
 
+fn center_mass(mut shape: &mut Vec<[f64; 2]>) -> Vector {
+    let mut average = Vector::default();
+    for vertex in &mut shape.iter() {
+        // Here, we are adding the new vertex location into what will be our average location.
+        average += (*vertex).into();
+    }
+    // Now we divide the 'average' by the number of segments to convert it from a sum of coordinates
+    // into an average of each coordinate. This isn't a real center-of-mass calculation,
+    // but it's good enough for this purpose (because we aren't mutating *that* far from a circle)
+    average /= shape.len() as f64;
+    for mut vertex in &mut shape.iter_mut() {
+        vertex[0] -= average.x;
+        vertex[1] -= average.y;
+    }
+    average
+}
+
+fn calculate_radius(shape: &[[f64; 2]]) -> f64 {
+    let mut avg_magnitude: f64 = 0.0;
+    for vertex in &mut shape.iter() {
+        let vert_as_vect: Vector = (*vertex).into();
+        avg_magnitude += vert_as_vect.magnitude()
+    }
+    avg_magnitude / shape.len() as f64
+}
+
 impl Asteroid {
     pub fn new(window_size: Size) -> Self {
 
@@ -144,6 +171,80 @@ impl Asteroid {
             on_screen: false,
         }
     }
+
+    pub fn can_split(&self) -> bool {
+        self.shape.len() > 10
+    }
+
+    pub fn split<P: Positioned>(&mut self, other: &P) -> Vec<Asteroid> {
+        self.normalize_rotation();
+        let index_nearest = self.index_nearest_point(other);
+        let num_pieces = 3;
+        let mut chunks: Vec<Asteroid> = Vec::new();
+        let chunk_size = self.shape.len() / num_pieces;
+        let mut transformed_shape = self.shape.split_off(index_nearest);
+        transformed_shape.extend(self.shape.iter().cloned());
+        let last_element = transformed_shape[transformed_shape.len() - 1];
+        let first_element = transformed_shape[0];
+        transformed_shape.push(first_element);
+        transformed_shape.insert(0, last_element);
+        let mut first_indices: Vec<usize> = (0..num_pieces - 1)
+            .map(|idx| idx + 1)
+            .map(|idx| idx * chunk_size)
+            .map(|idx| idx as usize)
+            .collect();
+        let mut last_indices = first_indices.clone();
+        first_indices.insert(0, 0);
+        last_indices.push(transformed_shape.len() - 2);
+        let zipped_indices: Vec<(&usize, &usize)> =
+            first_indices.iter().zip(last_indices.iter()).collect();
+        for pair in zipped_indices {
+            let mut new_shape = transformed_shape[*pair.0..*pair.1 + 1].to_vec();
+            new_shape.push([0.0, 0.0]);
+            let average_pos = center_mass(&mut new_shape);
+            let new_radius = calculate_radius(&new_shape);
+            chunks.push(Asteroid {
+                            pos: self.pos + average_pos,
+                            vel: self.vel + average_pos.rotate(PI / 2.0) * self.spin +
+                                 average_pos * 0.005,
+                            rot: 0.0,
+                            spin: self.spin * 0.5,
+                            radius: new_radius,
+                            shape: new_shape,
+                            window_size: self.window_size,
+                            on_screen: true,
+                        })
+        }
+        chunks
+    }
+
+    fn normalize_rotation(&mut self) {
+        let mut norm_shape = self.shape.clone();
+        for vert in &mut norm_shape {
+            let v: Vector = (*vert).into();
+            let rotated = v.rotate(self.rot);
+            vert[0] = rotated.x;
+            vert[1] = rotated.y;
+        }
+        self.shape = norm_shape.clone();
+        self.rot = 0.0;
+    }
+
+    fn index_nearest_point<P: Positioned>(&mut self, other: &P) -> usize {
+        let other_pos = other.pos();
+        let nearest_point = self.shape
+            .iter()
+            .map(|vert| {
+                     Vector {
+                         x: vert[0],
+                         y: vert[1],
+                     }
+                 })
+            .map(|vert| other_pos.distance(vert.rotate(self.rot) + self.pos))
+            .enumerate()
+            .min_by_key(|&(_, b)| b as i64);
+        nearest_point.unwrap().0
+    }
 }
 
 impl Updateable for Asteroid {

src/game/models/vector.rs

@@ -1,5 +1,5 @@
 use std::f64::consts::PI;
-use std::ops::{Add, AddAssign, Rem, RemAssign, Sub, SubAssign, Div, DivAssign};
+use std::ops::{Add, AddAssign, Rem, RemAssign, Sub, SubAssign, Mul, MulAssign, Div, DivAssign};
 
 use piston_window::Size;
 use rand;
@@ -31,6 +31,24 @@ impl Vector {
         }
         angle_to_point
     }
+
+    pub fn magnitude(self) -> f64 {
+        (self.x.powi(2) + self.y.powi(2)).sqrt()
+    }
+
+    pub fn distance(self, other: Vector) -> f64 {
+        (self - other).magnitude()
+    }
+
+    pub fn rotate(self, angle: f64) -> Vector {
+        let old_angle = (self.angle_to_vector(Vector { x: 0.0, y: 0.0 }) + PI) % (PI * 2.0);
+        let magnitude = self.magnitude();
+        let new_angle = (angle + old_angle) % (PI * 2.0);
+        Vector {
+            x: magnitude * new_angle.cos(),
+            y: magnitude * new_angle.sin(),
+        }
+    }
 }
 
 impl Add for Vector {
@@ -107,6 +125,39 @@ impl Div<f64> for Vector {
     }
 }
 
+impl Mul<Vector> for Vector {
+    type Output = Self;
+
+    fn mul(self, other: Self) -> Self {
+        Vector {
+            x: self.x * other.x,
+            y: self.y * other.y,
+        }
+    }
+}
+
+impl Mul<f64> for Vector {
+    type Output = Self;
+
+    fn mul(self, other: f64) -> Self {
+        Vector {
+            x: self.x * other,
+            y: self.y * other,
+        }
+    }
+}
+
+impl MulAssign<Vector> for Vector {
+    fn mul_assign(&mut self, other: Self) {
+        *self = *self * other;
+    }
+}
+
+impl MulAssign<f64> for Vector {
+    fn mul_assign(&mut self, other: f64) {
+        *self = *self * other;
+    }
+}
 impl DivAssign<Vector> for Vector {
     fn div_assign(&mut self, other: Self) {
         *self = *self / other;