post-merge refactoring

Author: =

client/src/sim.rs

@@ -412,7 +412,9 @@ impl Sim {
         }
     }
 
-    // helper function for handle_forces
+    /// checks to see if there are any non-Void voxels near Position.
+    // acts as a helper function for handle_forces
+    // currently uses a hyperbolic equivilent of an AABB.
     fn check_collision(&self, pos: Position) -> bool {
         let params = self.params.as_ref().unwrap();
 
@@ -441,10 +443,7 @@ impl Sim {
                     ref voxels,
                 } => {
                     for voxel_address in cbb.every_voxel() {
-                        if match voxels.get(voxel_address as usize) {
-                            Material::Void => false,
-                            _ => true,
-                        } {
+                        if !matches!(voxels.get(voxel_address as usize), Material::Void) {
                             return true;
                         }
                     }

common/src/collision.rs

@@ -152,7 +152,7 @@ impl BoundingBox {
         }
     }
 
-    pub fn every_voxel_address<'a>(&'a self) -> impl Iterator<Item = VoxelAddress> + 'a {
+    pub fn every_voxel_address(&self) -> impl Iterator<Item = VoxelAddress> + '_ {
         self.bounding_boxes.iter().flat_map(|cbb| {
             cbb.every_voxel().map(move |index| VoxelAddress {
                 node: cbb.node,
@@ -242,7 +242,7 @@ impl ChunkBoundingBox {
         }
     }
 
-    pub fn every_voxel<'b>(&'b self) -> impl Iterator<Item = u32> + 'b {
+    pub fn every_voxel(&self) -> impl Iterator<Item = u32> + '_ {
         let lwm = (self.dimension as u32) + 2;
         (self.min_xyz[2]..self.max_xyz[2]).flat_map(move |z| {
             (self.min_xyz[1]..self.max_xyz[1]).flat_map(move |y| {
@@ -260,9 +260,11 @@ lazy_static! {
     static ref PERPENDICULAR_VERTEX: [[Option<Vertex>; VERTEX_COUNT]; SIDE_COUNT] = {
         let mut result = [[None; VERTEX_COUNT]; SIDE_COUNT];
 
-        for s in 0..SIDE_COUNT {
-            let side = Side::from_index(s);
+        for side in Side::iter() {
             let incident_vertices = side.vertices();
+
+            // 'v' and 'vertex as usize' will have different values.
+            #[allow(clippy::needless_range_loop)]
             for v in 0..5 {
                 let vertex = incident_vertices[v];
                 let mut vertex_counts = [0; VERTEX_COUNT];
@@ -280,9 +282,9 @@ lazy_static! {
                 // inceident corners as not perpendicular
                 for i in side.vertices().iter() {vertex_counts[*i as usize] = -1}
 
-                for i in 0..VERTEX_COUNT {
-                    if vertex_counts[i] == 2 {
-                        result[s][vertex as usize] = Some(Vertex::from_index(i));
+                for i in Vertex::iter() {
+                    if vertex_counts[i as usize] == 2 {
+                        result[side as usize][vertex as usize] = Some(i);
                         break;
                     }
                 }
@@ -295,10 +297,7 @@ lazy_static! {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::node::{DualGraph, Node};
-    use crate::Chunks;
     use crate::{graph::Graph, proto::Position, traversal::ensure_nearby};
-    use approx::*;
 
     const CHUNK_SIZE: u8 = 12_u8; // might want to test with multiple values in the future.
     static CHUNK_SIZE_F: f64 = CHUNK_SIZE as f64;
@@ -460,7 +459,7 @@ mod tests {
                     BoundingBox::create_aabb(NodeId::ROOT, position, radius, &graph, CHUNK_SIZE);
 
                 let mut actual_voxels = 0;
-                for address in bb.every_voxel_address() {
+                for _address in bb.every_voxel_address() {
                     actual_voxels += 1;
                 }
 

common/src/force.rs

@@ -33,7 +33,7 @@ impl ForceParams {
         is_colliding: bool,
         time: f64,
     ) -> na::Vector4<f64> {
-        let mut velocity = inital_velocity.clone();
+        let mut velocity = *inital_velocity;
 
         // with current collsion detection tech, we want the player to slowly rise if they are in the ground
         if is_colliding {
@@ -48,17 +48,17 @@ impl ForceParams {
 
     /// returns the change in velocity that occurs by pulled by gravity at "height" for "time"
     fn gravity(&self, down: &na::Vector4<f64>, height: f64, time: f64) -> na::Vector4<f64> {
-        return match self.gravity_type {
+        match self.gravity_type {
             GravityMethod::PlanarConstant => down * (self.gravity_intensity * time),
             GravityMethod::PlanarDivergent => {
                 down * (self.gravity_intensity * time / height.cosh().powi(2))
             }
             GravityMethod::Zero => na::zero(),
-        };
+        }
     }
 
     /// rewrites velocity to account for time spent under drag.
     fn air_drag(&self, inital_velocity: &na::Vector4<f64>, time: f64) -> na::Vector4<f64> {
-        return inital_velocity * self.air_drag_factor.powf(time);
+        inital_velocity * self.air_drag_factor.powf(time)
     }
 }

common/src/math.rs

@@ -112,12 +112,12 @@ pub fn translate_normal<N: RealField>(
     v0: na::Vector4<N>,
 ) -> na::Vector4<N> {
     let d = distance(&p0, &p1);
-    if !(d >= na::zero()) {
+    // TODO: verfiy this is equvilent to !(d >= na::zero())
+    if na::zero::<N>() > d {
         return v0;
     }
 
-    let v1 = v0 * d.cosh() + p1 * d.sinh();
-    return v1;
+    v0 * d.cosh() + p1 * d.sinh()
 }
 
 /// normalizes vector v with repect to translation matrix t
@@ -131,12 +131,12 @@ pub fn normalize_vector<N: RealField>(t: na::Matrix4<N>, v: na::Vector4<N>) -> n
     let v_mag = m.sqrt();
     let v_norm = v / v_mag;
 
-    return (v_norm + p * mip(&p, &v_norm)) * v_mag;
+    (v_norm + p * mip(&p, &v_norm)) * v_mag
 }
 
 /// make a orthogonal to b
 pub fn orthogonalize<N: RealField>(a: &na::Vector4<N>, b: &na::Vector4<N>) -> na::Vector4<N> {
-    return a - b * (mip(a, b) / mip(b, b));
+    a - b * (mip(a, b) / mip(b, b))
 }
 
 #[rustfmt::skip]
@@ -297,20 +297,11 @@ mod tests {
 
         assert_abs_diff_eq!(mip(&vec2, &orth), 0.0, epsilon = 1e-5);
     }
-    /*
+
     #[test]
     fn translate_normal_identity() {
         let p = na::Vector4::new(-0.03635, 0.95129, 0.0, 1.38068);
         let norm = na::Vector4::new(1.0, 0.0, 0.0, 0.0);
         assert_abs_diff_eq!(translate_normal(p, p, norm), norm, epsilon = 1e-5);
-    }*/
-
-    fn translate_normal_still_normal() {
-        let p1 = na::Vector4::new(-0.03635, 0.95129, 0.0, 1.38068);
-        let p0 = origin();
-        let norm = na::Vector4::new(1.0, 0.0, 0.0, 0.0);
-        let trans = translate_normal(p0, p1, norm);
-        assert_abs_diff_eq!(mip(&trans, &trans), 1.0, epsilon = 1e-5);
-        assert_abs_diff_eq!(mip(&trans, &p1), 0.0, epsilon = 1e-5);
     }
 }

common/src/worldgen.rs

@@ -130,7 +130,7 @@ impl NodeState {
     }
 
     pub fn surface(&self) -> Plane<f64> {
-        return self.surface;
+        self.surface
     }
 
     // if the node lies above the ground-plane or not