Fix lints

Author: confusinguser

src/ai.rs

@@ -91,7 +91,7 @@ fn eval_recursive(
 
         if eval_next > eval {
             eval = eval_next;
-            best_variation = best_variation_returned.clone();
+            best_variation.clone_from(&best_variation_returned);
             if og {
                 ai_cache.last_variation = best_variation_returned;
             }

src/cell.rs

@@ -156,19 +156,15 @@ impl CellCoordinates {
     }
 
     /// Gets the diagonal that can be reached by walking in the cartesian directions consecutively,
-    /// does not return true neigbors. The second element of the second element denotes if the new
+    /// does not return true neighbors. The second element of the second element denotes if the new
     /// cell is on a different side than the first
     pub(crate) fn get_diagonal(
         &self,
         diagonal: (CartesianDirection, CartesianDirection),
         cube_side_length: u32,
     ) -> Option<(CellCoordinates, bool)> {
-        let Some(cell1) = self.get_cell_in_direction(diagonal.0, cube_side_length) else {
-            return None;
-        };
-        let Some(cell2) = cell1.0.get_cell_in_direction(diagonal.1, cube_side_length) else {
-            return None;
-        };
+        let cell1 = self.get_cell_in_direction(diagonal.0, cube_side_length)?;
+        let cell2 = cell1.0.get_cell_in_direction(diagonal.1, cube_side_length)?;
         if cell1.1 && cell2.1 {
             // The second element tells us if the transformation went over a cube edge, in this
             // case we are in a corner, which means we have a true neighbor in cell2

src/cube_rotation.rs

@@ -58,6 +58,7 @@ impl RotationState {
         }
     }
 
+    #[allow(unused)]
     /// Panics in some cases if the rotation state is not possible. That is, if the side and top are parallel
     fn get_see_direction(&self, see_direction: SeeDirection) -> CartesianDirection {
         match see_direction {
@@ -172,7 +173,11 @@ fn input_handling(input: Res<Input<KeyCode>>, rotation_data: &mut RotationData)
 }
 
 /// @param see_direction: The side (seen from the camera) that this rotation is rotating around
-fn start_rotation(rotation_data: &mut RotationData, rotation: CartesianDirection, _see_direction: SeeDirection) {
+fn start_rotation(
+    rotation_data: &mut RotationData,
+    rotation: CartesianDirection,
+    _see_direction: SeeDirection,
+) {
     // If the rotation axis is not parallel to the top axis, then this rotation will modify the side axis
     if !rotation.is_parallel_to(rotation_data.future_rotation_state.side) {
         let target = rotation_data
@@ -217,7 +222,8 @@ fn total_animation_rotation(
 fn camera_up_vector(rotation_data: &RotationData, rotation_time: Duration) -> Vec3 {
     let mut output = rotation_data.rotation_state.top.as_vec3();
     for animation in &rotation_data.animations {
-        if (animation.side_changing == SeeDirection::Top || animation.side_changing == SeeDirection::Bottom)
+        if (animation.side_changing == SeeDirection::Top
+            || animation.side_changing == SeeDirection::Bottom)
             && animation.target != animation.from
         {
             output += animation.camera_up_vector(rotation_time) - animation.from.as_vec3();
@@ -237,11 +243,18 @@ fn rotation_curve(time: f32) -> f32 {
 
     let c1 = 1.70158;
     let c3 = c1 + 1.;
-    
+
     1. + c3 * (time - 1.).powi(3) + c1 * (time - 1.).powi(2)
 }
 
+#[allow(unused_imports)]
 mod tests {
+    use std::time::Duration;
+
+    use bevy::math::Quat;
+
+    use super::*;
+
     #[test]
     fn rotation_state_after_rotation_test() {
         use super::RotationState;
@@ -252,10 +265,6 @@ mod tests {
             RotationState { top: X, side: Z }
         );
     }
-    
-    use super::*;
-    use bevy::math::Quat;
-    use std::time::Duration;
 
     #[test]
     fn total_animation_rotation_with_no_animations() {
@@ -264,4 +273,4 @@ mod tests {
         let result = total_animation_rotation(&animations, rotation_time);
         assert_eq!(result, Quat::IDENTITY);
     }
-} 
+}

src/main.rs

@@ -40,7 +40,6 @@ fn main() {
 
 #[derive(Component)]
 struct MainCamera {
-    start_coords: Vec3,
 }
 
 fn setup(
@@ -66,7 +65,7 @@ fn setup(
     commands.spawn((
         PointLightBundle {
             point_light: PointLight {
-                intensity: 9000.0,
+                intensity: 5000.0,
                 range: 100.,
                 shadows_enabled: false,
                 ..default()
@@ -75,7 +74,6 @@ fn setup(
             ..default()
         },
         MainCamera {
-            start_coords: Vec3::new(8., 8., 8.),
         },
     ));
 
@@ -86,7 +84,6 @@ fn setup(
         },
         RaycastPickCamera::default(), // Enable picking with this camera
         MainCamera {
-            start_coords: Vec3::new(2., 2., 2.),
         },
     ));
 }

src/movement.rs

@@ -12,6 +12,7 @@ pub(crate) struct GameMove {
 }
 
 impl GameMove {
+    #[allow(unused)]
     pub(crate) fn display_with_unit(&self, unit: Option<&Unit>) -> String {
         let mut output = String::new();
         if let Some(unit) = unit {

src/units.rs

@@ -180,9 +180,7 @@ impl Units {
     }
 
     pub(crate) fn remove_unit(&mut self, coords: CellCoordinates) -> Option<Unit> {
-        let Some(index) = self.units.iter().position(|unit| unit.coords==coords) else {
-            return None;
-        };
+        let index = self.units.iter().position(|unit| unit.coords==coords)?;
 
         Some(self.units.swap_remove(index))
     }

src/utils.rs

@@ -171,9 +171,7 @@ impl CartesianDirection {
             return None;
         }
 
-        let Some(axis_num) = first_nonzero_component(vec) else {
-            return None;
-        };
+        let axis_num = first_nonzero_component(vec)?;
 
         Some(Self::from_axis_num(
             axis_num,
@@ -274,6 +272,7 @@ impl CartesianDirection {
 }
 
 /// Signifies the direction seen from the camera.
+#[allow(unused)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub(crate) enum SeeDirection {
     Top,