applying force after pressing leftclick and dragging the mouse

1 files changed, 62 insertions, 9 deletions

diff --git a/rust/src/BasicDie.rs b/rust/src/BasicDie.rs
index 7bc6d65..3f15de5 100644
--- a/rust/src/BasicDie.rs
+++ b/rust/src/BasicDie.rs
@@ -14,14 +14,14 @@ enum InputState {
 #[inherit(RigidBody)]
 #[register_with(Self::register_builder)]
 pub struct BasicDie {
-    #[property(path="base/camera_offset")]
-    camera_offset: f32,
-    #[property(path="base/camera_clamp")]
+    #[property(path="camera/camera_clamp")]
     camera_clamp: Vector2,
     #[property(path="shooting/max_force")]
     max_force: f32,
     #[property(path="shooting/up_angle")]
     up_angle: f32,
+    #[property(path="shooting/stopping_velocity")]
+    stopping_velocity: f32,
     #[property(path="input/mouse_sensitivity")]
     mouse_sensitivity: Vector2,
 
@@ -32,6 +32,7 @@ pub struct BasicDie {
 
     node_camera_arm_horizontal: Option<Ref<Spatial>>,
     node_camera_arm_vertical: Option<Ref<Spatial>>,
+    node_camera: Option<Ref<Spatial>>,
 }
 
 #[methods]
@@ -43,10 +44,10 @@ impl BasicDie {
 
     fn new(_owner: &RigidBody) -> Self {
         BasicDie {
-            camera_offset: 0.0,
             camera_clamp: Vector2 { x: 0.0, y: 0.0 },
             max_force: 0.0,
             up_angle: 5.0,
+            stopping_velocity: 0.0,
             mouse_sensitivity: Vector2 { x: 1.0, y: 1.0 },
 
             input_state: InputState::Default,
@@ -56,6 +57,7 @@ impl BasicDie {
 
             node_camera_arm_horizontal: None,
             node_camera_arm_vertical: None,
+            node_camera: None,
         }
     }
 
@@ -96,13 +98,41 @@ impl BasicDie {
             },
             _ => godot_warn!("No horizontal arm to look for the vertical arm")
         }
+
+        // look for the camera
+        match self.node_camera_arm_vertical {
+            Some(arm) => {
+                let save_arm = arm.assume_safe();
+                match save_arm.get_node(NodePath::from_str("Camera")) {
+                    Some(node) => {
+                        let save_node = node.assume_safe();
+                        match save_node.cast::<Spatial>() {
+                            Some(casted) => {
+                                let save_casted = casted.claim(); 
+                                self.node_camera = Some(save_casted)},
+                            _ => godot_warn!("Camera was not of type 'Spatial'"),
+                        }
+                    },
+                    _ => godot_warn!("No camera found.")
+                }
+            },
+            _ => godot_warn!("No vertical arm to look for the camera")
+        }
     }
 
     #[export]
     unsafe fn _physics_process(&mut self, owner: &RigidBody, delta: f64) {
 
         if matches!(self.input_state, InputState::Moving) {
-            // TODO check if velocity reached a certain threshold and set the mode to default again
+            // get the current velocity
+            let current_vel = owner.linear_velocity().length();
+
+            godot_print!("current velocity: {}", current_vel);
+
+            // check if the velocity is less than the threshold and change input state in that case
+            if current_vel <= self.stopping_velocity {
+                self.input_state = InputState::Default;
+            }
         };
     }
 
@@ -113,7 +143,7 @@ impl BasicDie {
 
         match self.input_state {
             InputState::Default => self.default_input(event),
-            InputState::Shooting => self.shooting_input(event),
+            InputState::Shooting => self.shooting_input(owner, event),
             InputState::Moving => self.moving_input(event),
         }
     }
@@ -158,14 +188,14 @@ impl BasicDie {
     }
 
     /// this input method will be called when player is currently taking a shot
-    unsafe fn shooting_input(&mut self, event: Ref<InputEvent>) {
+    unsafe fn shooting_input(&mut self, owner: &RigidBody, event: Ref<InputEvent>) {
         let save_event = event.assume_safe();
 
         godot_print!("shooting input");
 
         if save_event.is_action_released(GodotString::from_str(&self.action_shooting), false) {
             self.input_state = InputState::Moving;
-            // TODO add force based on input and strength
+            self.shoot(owner);
             return;
         }
 
@@ -222,7 +252,6 @@ impl BasicDie {
                 // check for the current rotation
                 let save_arm = arm.assume_safe();
                 let current_rot = save_arm.rotation();
-                godot_print!("current rotation: {} | {} | {} ", current_rot.x, current_rot.y, current_rot.z);
 
                 // clamp the rotation
                 if current_rot.x + input > self.camera_clamp.x || current_rot.x + input <= self.camera_clamp.y {
@@ -236,4 +265,28 @@ impl BasicDie {
             _ => godot_warn!("No vertical camera arm assigned")
         }
     }
+
+    unsafe fn shoot(&mut self, owner: &RigidBody) {
+        // make sure the camera actually exists
+        match self.node_camera {
+            Some(cam) => {
+                // get the base position of the node
+                let base_pos = owner.transform().origin;
+
+                // get the save reference
+                let save_cam = cam.assume_safe();
+                
+                // get the forward vector of the camera setting the up angle to the defined value in the editor
+                let mut forward_vector = save_cam.global_transform().basis.c();
+                forward_vector.y = self.up_angle;
+
+                // calculate the impulse force
+                let impulse = forward_vector.normalized() * self.current_force;
+
+                // actually add the force
+                owner.apply_impulse(base_pos, impulse); 
+            },
+            None => godot_warn!("No camera assigned!"),
+        }
+    }
 }