refactor: consolidate imports and remove redundant comments

Consolidate multiple import statements into single lines for better readability and remove redundant comments to clean up the codebase. This improves maintainability and reduces clutter without altering the functionality.

Author: FrankCasanova

squash-the-creeps/rust/src/mob.rs

@@ -1,6 +1,4 @@
-use godot::classes::AnimationPlayer;
-use godot::classes::CharacterBody3D;
-use godot::classes::ICharacterBody3D;
+use godot::classes::{AnimationPlayer, CharacterBody3D, ICharacterBody3D};
 use godot::prelude::*;
 use rand::Rng;
 use std::f32::consts::PI;

squash-the-creeps/rust/src/player.rs

@@ -1,9 +1,5 @@
 use crate::mob::Mob;
-use godot::classes::AnimationPlayer;
-use godot::classes::CharacterBody3D;
-use godot::classes::CollisionShape3D;
-use godot::classes::ICharacterBody3D;
-use godot::classes::Input;
+use godot::classes::{AnimationPlayer, CharacterBody3D, CollisionShape3D, ICharacterBody3D, Input};
 use godot::prelude::*;
 use std::f32::consts::FRAC_PI_6;
 
@@ -34,109 +30,74 @@ pub struct Player {
 #[godot_api]
 impl ICharacterBody3D for Player {
     fn physics_process(&mut self, _delta: f64) {
-        /*Here, instead of _process(), we're going to make all
-        calculations using the _physics_process() virtual function.
-        It's designed specifically for physics-related code like
-        moving a kinematic or rigid body.
-        It updates the node using fixed time intervals.*/
-
-        // var direction = Vector3.ZERO
         let mut direction = Vector3::ZERO;
 
         let input = Input::singleton();
 
-        // if Input.is_action_pressed("move_right"):
         if input.is_action_pressed("move_right") {
-            //direction.x += 1
             direction += Vector3::RIGHT;
         }
-        // if Input.is_action_pressed("move_left"):
         if input.is_action_pressed("move_left") {
-            //direction.x -= 1
             direction += Vector3::LEFT;
         }
-        // if Input.is_action_pressed("move_back"):
         if input.is_action_pressed("move_back") {
-            // direction.z += 1
             direction += Vector3::BACK;
         }
-        // if Input.is_action_pressed("move_forward"):
         if input.is_action_pressed("move_forward") {
-            // direction.z -= 1
             direction += Vector3::FORWARD;
         }
 
-        // if direction != Vector3.ZERO:
         if direction != Vector3::ZERO {
             // In the lines below, we turn the character when moving and make the animation play faster.
-            //direction = direction.normalized()
             direction = direction.normalized();
 
             // take the pivot node and rotate it to face the direction we're moving in
             let mut pivot = self.base_mut().get_node_as::<Node3D>("Pivot");
-            // $Pivot.basis = Basis.looking_at(direction) (GDScript)
+
+            // Setting the basis property will affect the rotation of the node
             pivot.set_basis(Basis::looking_at(-direction, Vector3::UP, true));
-            // $AnimationPlayer.speed_scale = 4
             self.base()
                 .get_node_as::<AnimationPlayer>("AnimationPlayer")
                 .set_speed_scale(4.0);
         } else {
-            // $AnimationPlayer.speed_scale = 1
             self.base()
                 .get_node_as::<AnimationPlayer>("AnimationPlayer")
                 .set_speed_scale(1.0);
         }
         // Ground Velocity
-        // velocity.x = direction.x * speed
         self.target_velocity.x = direction.x * self.speed;
-
-        //velocity.z = direction.z * speed
         self.target_velocity.z = direction.z * self.speed;
 
         // jumping
-        // if is_on_floor() and Input.is_action_just_pressed("jump"):
         if self.base().is_on_floor() && input.is_action_just_pressed("jump") {
-            //velocity.y += jump_impulse
             self.target_velocity.y = self.jump_impulse;
         }
         // We apply gravity every frame so the character always collides with the ground when moving.
         // This is necessary for the is_on_floor() function to work as a body can always detect
         // the floor, walls, etc. when a collision happens the same frame.
         if !self.base().is_on_floor() {
-            // velocity.y -= fall_acceleration * delta
             self.target_velocity.y -= self.fall_acceleration * _delta as f32;
         }
         // moving the Character
         let velocity = self.target_velocity;
         self.base_mut().set_velocity(velocity);
-        // move_and_slide()
         self.base_mut().move_and_slide();
 
         // Here, we check if we landed on top of a mob and if so, we kill it and bounce.
         // With move_and_slide(), Godot makes the body move sometimes multiple times in a row to
         // smooth out the character's motion. So we have to loop over all collisions that may have
         // happened.
         // If there are no "slides" this frame, the loop below won't run.
-        // for index in range(get_slide_collision_count()):
         for index in 0..self.base().get_slide_collision_count() {
-            // var collision = get_slide_collision(index)
             let collision = self.base_mut().get_slide_collision(index).unwrap();
-
-            // if collision.get_collider().is_in_group("mob"):
             if let Some(collider) = collision.get_collider() {
                 if let Ok(node) = collider.try_cast::<Node3D>() {
                     if node.is_in_group("mob") {
-                        // var mob = collision.get_collider()
                         let mut mob = collision.get_collider().unwrap().cast::<Mob>();
-
-                        // if Vector3.UP.dot(collision.get_normal()) > 0.1:
                         if Vector3::UP.dot(collision.get_normal()) > 0.1 {
-                            // mob.squash()
                             mob.bind_mut().squash();
 
-                            // velocity.y = bounce_impulse
                             self.target_velocity.y = self.bounce_impulse;
-
                             // Prevent this block from running more than once,
                             // which would award the player more than 1 point for squashing a single mob.
                             break;
@@ -146,7 +107,6 @@ impl ICharacterBody3D for Player {
             }
         }
         // This makes the character follow a nice arc when jumping
-        // $Pivot.rotation.x = PI / 6 * velocity.y / jump_impulse
         let mut pivot = self.base().get_node_as::<Node3D>("Pivot");
         let mut pivot_rotation = pivot.get_rotation();
         pivot_rotation.x = FRAC_PI_6 * self.base().get_velocity().y / self.jump_impulse;
@@ -156,16 +116,12 @@ impl ICharacterBody3D for Player {
 
 #[godot_api]
 impl Player {
-    // signal hit
     #[signal]
     pub fn hit();
 
     #[func]
     pub fn die(&mut self) {
-        // hit.emit()
         self.signals().hit().emit();
-
-        // queue_free()
         self.base_mut().queue_free();
     }
 
@@ -176,7 +132,6 @@ impl Player {
             .get_node_as::<CollisionShape3D>("CollisionShape3D");
         collision_shape.set_deferred("disabled", &true.to_variant());
 
-        // die()
         self.die();
     }
 }

squash-the-creeps/rust/src/scorelabel.rs

@@ -1,5 +1,4 @@
-use godot::classes::Control;
-use godot::classes::Label;
+use godot::classes::{Control, Label};
 use godot::prelude::*;
 
 #[derive(GodotClass)]
@@ -13,10 +12,8 @@ pub struct UserInterface {
 impl UserInterface {
     #[func]
     pub fn on_mob_squashed(&mut self) {
-        // score += 1
         self.score += 1.0;
 
-        // text = "Score: %s" % score
         let mut label = self.base().get_node_as::<Label>("ScoreLabel");
         label.set_text(format!("Score: {}", self.score).as_str());
     }