Merge branch 'BasicDie'

9 files changed, 394 insertions, 4 deletions

diff --git a/.gitignore b/.gitignore
index 5146acf..c0cdeaa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,4 @@ rust/Cargo.lock
 rust/debug/
 target/
 tramp
+make.bat
diff --git a/cargo b/cargo
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/cargo
diff --git a/godot/native/BasicDie.gdns b/godot/native/BasicDie.gdns
new file mode 100644
index 0000000..ab5d534
--- /dev/null
+++ b/godot/native/BasicDie.gdns
@@ -0,0 +1,8 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://native/game.gdnlib" type="GDNativeLibrary" id=1]
+
+[resource]
+resource_name = "BasicDie"
+class_name = "BasicDie"
+library = ExtResource( 1 )
diff --git a/godot/project.godot b/godot/project.godot
index a8f6586..d7b88c5 100644
--- a/godot/project.godot
+++ b/godot/project.godot
@@ -18,6 +18,14 @@ config/icon="res://assets/godot-ferris-32x32.png"
 
 singletons=[  ]
 
+[input]
+
+mouse_btn_left={
+"deadzone": 0.5,
+"events": [ Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"button_mask":0,"position":Vector2( 0, 0 ),"global_position":Vector2( 0, 0 ),"factor":1.0,"button_index":1,"pressed":false,"doubleclick":false,"script":null)
+ ]
+}
+
 [rendering]
 
 environment/default_environment="res://default_env.tres"
diff --git a/godot/scenes/Game.tscn b/godot/scenes/Game.tscn
index f8b17cb..0eb902d 100644
--- a/godot/scenes/Game.tscn
+++ b/godot/scenes/Game.tscn
@@ -1,8 +1,17 @@
-[gd_scene load_steps=3 format=2]
+[gd_scene load_steps=7 format=2]
 
 [ext_resource path="res://native/Game.gdns" type="Script" id=1]
+[ext_resource path="res://native/BasicDie.gdns" type="Script" id=2]
 [ext_resource path="res://scenes/levels/test_scene_uuuhhh/TestSceneUuuhhh.tscn" type="PackedScene" id=2]
 
+[sub_resource type="CubeMesh" id=1]
+
+[sub_resource type="BoxShape" id=2]
+
+[sub_resource type="CubeMesh" id=3]
+
+[sub_resource type="BoxShape" id=4]
+
 [node name="Game" type="Spatial"]
 script = ExtResource( 1 )
 
@@ -12,3 +21,36 @@ current = true
 fov = 64.6875
 
 [node name="TestSceneUuuhhh" parent="." instance=ExtResource( 2 )]
+
+[node name="RigidBody" type="RigidBody" parent="."]
+transform = Transform( 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 3.25589, 0 )
+script = ExtResource( 2 )
+camera/camera_clamp = Vector2( 1.608, -2.526 )
+shooting/max_force = 30.0
+shooting/up_angle = 1.0
+input/camera_mouse_sensitivity = Vector2( 0.01, 0.008 )
+input/shoot_sensitivity = 0.069
+
+[node name="MeshInstance" type="MeshInstance" parent="RigidBody"]
+mesh = SubResource( 1 )
+material/0 = null
+
+[node name="CollisionShape" type="CollisionShape" parent="RigidBody"]
+shape = SubResource( 2 )
+
+[node name="CameraArmHorizontal" type="Spatial" parent="RigidBody"]
+
+[node name="CameraArmVertical" type="Spatial" parent="RigidBody/CameraArmHorizontal"]
+
+[node name="Camera" type="Camera" parent="RigidBody/CameraArmHorizontal/CameraArmVertical"]
+transform = Transform( 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 10 )
+
+[node name="StaticBody" type="StaticBody" parent="."]
+transform = Transform( 100, 0, 0, 0, 0.1, 0, 0, 0, 100, 0, 0, 0 )
+
+[node name="MeshInstance" type="MeshInstance" parent="StaticBody"]
+mesh = SubResource( 3 )
+material/0 = null
+
+[node name="CollisionShape" type="CollisionShape" parent="StaticBody"]
+shape = SubResource( 4 )
diff --git a/lib/x86_64-pc-windows-msvc/code_with_your_friends2022.dll b/lib/x86_64-pc-windows-msvc/code_with_your_friends2022.dll
new file mode 100644
index 0000000..115f39f
--- /dev/null
+++ b/lib/x86_64-pc-windows-msvc/code_with_your_friends2022.dll
diff --git a/rust/src/basic_die.rs b/rust/src/basic_die.rs
new file mode 100644
index 0000000..9dab3ce
--- /dev/null
+++ b/rust/src/basic_die.rs
@@ -0,0 +1,331 @@
+use std::borrow::Borrow;
+use gdnative::api::*;
+use gdnative::prelude::*;
+
+/// the input state for the player
+enum InputState {
+    Default,
+    Shooting,
+    Moving
+}
+
+/// the basic die used by the player
+#[derive(NativeClass)]
+#[inherit(RigidBody)]
+#[register_with(Self::register_builder)]
+pub struct BasicDie {
+    #[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/camera_mouse_sensitivity")]
+    mouse_sensitivity: Vector2,
+    #[property(path="input/shoot_sensitivity")]
+    shoot_sensitivity: f32,
+
+    input_state: InputState,
+    current_force: f32,
+
+    action_shooting: String,
+
+    node_camera_arm_horizontal: Option<Ref<Spatial>>,
+    node_camera_arm_vertical: Option<Ref<Spatial>>,
+    node_camera: Option<Ref<Spatial>>,
+}
+
+#[methods]
+impl BasicDie {
+    // Register the builder for methods, properties and/or signals.
+    fn register_builder(_builder: &ClassBuilder<Self>) {
+        godot_print!("BasicDie builder is registered!");
+    }
+
+    fn new(_owner: &RigidBody) -> Self {
+        BasicDie {
+            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 },
+            shoot_sensitivity: 1.0,
+
+            input_state: InputState::Default,
+            current_force: 0.0,
+
+            action_shooting: String::from("mouse_btn_left"),
+
+            node_camera_arm_horizontal: None,
+            node_camera_arm_vertical: None,
+            node_camera: None,
+        }
+    }
+
+    #[export]
+    unsafe fn _ready(&mut self, owner: &RigidBody) {
+        owner.set_physics_process(true);
+
+        // look for the vertical camera arm
+        match self.node_camera_arm_horizontal {
+            Some(arm) => {
+                let save_arm = arm.assume_safe();
+                match save_arm.get_node(NodePath::from_str("CameraArmVertical")) {
+                    Some(node) => {
+                        let save_node = node.assume_safe();
+                        match save_node.cast::<Spatial>() {
+                            Some(casted) => {
+                                let save_casted = casted.claim(); 
+                                self.node_camera_arm_vertical = Some(save_casted)},
+                            _ => godot_warn!("Camera Arm was not of type 'Spatial'"),
+                        }
+                    },
+                    _ => godot_warn!("No vertical arm found.")
+                }
+            },
+            _ => 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) {
+
+        // detect if the die stops moving
+        if matches!(self.input_state, InputState::Moving) {
+            // 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;
+            }
+        };
+    }
+
+    #[export]
+    unsafe fn _input(&mut self, owner: &RigidBody, event: Ref<InputEvent>) {
+
+        self.general_input(event.borrow());
+
+        match self.input_state {
+            InputState::Default => self.default_input(event),
+            InputState::Shooting => self.shooting_input(owner, event),
+            InputState::Moving => self.moving_input(event),
+        }
+
+        // look for the horizontal camera arm
+        match owner.get_node(NodePath::from_str("CameraArmHorizontal")) {
+            Some(node) => {
+                let save_node = node.assume_safe();
+                match save_node.cast::<Spatial>() {
+                    Some(casted) => {
+                        let save_casted = casted.claim(); 
+                        self.node_camera_arm_horizontal = Some(save_casted)},
+                    _ => godot_warn!("Camera Arm was not of type 'Spatial'"),
+                }
+            },
+            _ => godot_warn!("No horizontal arm found")
+        }
+
+        // look for the vertical camera arm
+        match self.node_camera_arm_horizontal {
+            Some(arm) => {
+                let save_arm = arm.assume_safe();
+                match save_arm.get_node(NodePath::from_str("CameraArmVertical")) {
+                    Some(node) => {
+                        let save_node = node.assume_safe();
+                        match save_node.cast::<Spatial>() {
+                            Some(casted) => {
+                                let save_casted = casted.claim(); 
+                                self.node_camera_arm_vertical = Some(save_casted)},
+                            _ => godot_warn!("Camera Arm was not of type 'Spatial'"),
+                        }
+                    },
+                    _ => godot_warn!("No vertical arm found.")
+                }
+            },
+            _ => 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")
+        }
+    }
+
+    /// this input method will always be called, regardless of the input state
+    unsafe fn general_input(&mut self, event: &Ref<InputEvent>) {
+        let save_event = event.assume_safe();
+
+        // rotate camera horizontally
+        let mouse_event = save_event.cast::<InputEventMouseMotion>(); // get the input as mouse input
+        match mouse_event {
+            Some(motion_event) => {
+                let x_mov = motion_event.relative().x * self.mouse_sensitivity.x;
+                self.rotate_cam_horizontal(x_mov);
+            },
+            _ => {}
+        }
+    }
+
+    /// this input method will be called when looking around, before taking a shot
+    unsafe fn default_input(&mut self, event: Ref<InputEvent>) {
+        let save_event = event.assume_safe();
+
+        // left mouse button was pressed => switch to shooting mode
+        if save_event.is_action_pressed(GodotString::from_str(&self.action_shooting), false, false) {
+            godot_print!("mouse_button, switching to shooting mode");
+            self.input_state = InputState::Shooting;
+            return;
+        }
+
+        // rotate camera vertically
+        let mouse_event = save_event.cast::<InputEventMouseMotion>(); // get the input as mouse input
+        match mouse_event {
+            Some(motion_event) => {
+                let y_mov = -motion_event.relative().y * self.mouse_sensitivity.y;
+                self.rotate_cam_vertical(y_mov);
+            },
+            _ => {}
+        };
+    }
+
+    /// this input method will be called when player is currently taking a shot
+    unsafe fn shooting_input(&mut self, owner: &RigidBody, event: Ref<InputEvent>) {
+        let save_event = event.assume_safe();
+
+        // mouse released, shoot
+        if save_event.is_action_released(GodotString::from_str(&self.action_shooting), false) {
+            self.input_state = InputState::Moving;
+            self.shoot(owner);
+            return;
+        }
+
+        // charge shot with vertical mouse movement
+        let mouse_event = save_event.cast::<InputEventMouseMotion>(); // get the input as mouse input
+        match mouse_event {
+            Some(motion_event) => {
+                let y_mov = motion_event.relative().y * self.mouse_sensitivity.y;
+                self.current_force = match self.current_force + y_mov {
+                    x if x < 0.0 => 0.0,
+                    x if x > self.max_force => self.max_force,
+                    x => x
+                };
+
+                godot_print!("current force: {}", self.current_force);
+            },
+            _ => {}
+        };
+    }
+
+    /// this input method will be called when player is moving
+    unsafe fn moving_input(&mut self, event: Ref<InputEvent>) {
+        let save_event = event.assume_safe();
+
+        // rotate camera vertically
+        let mouse_event = save_event.cast::<InputEventMouseMotion>(); // get the input as mouse input
+        match mouse_event {
+            Some(motion_event) => {
+                let y_mov = motion_event.relative().y * self.mouse_sensitivity.y;
+                self.rotate_cam_vertical(y_mov);
+            },
+            _ => {}
+        };
+    }
+
+    unsafe fn rotate_cam_horizontal(&mut self, input: f32) {
+        // make sure the arm exists
+        match self.node_camera_arm_horizontal {
+            Some(arm) => {
+                // rotate the horizontal camera arm
+                let save_arm = arm.assume_safe();
+                save_arm.rotate_object_local(Vector3 {x: 0.0, y: 1.0, z: 0.0}, input as f64)
+            },
+            _ => godot_warn!("No horizontal camera arm assigned.")
+        }
+    }
+
+    unsafe fn rotate_cam_vertical(&mut self, input: f32) {
+        // make sure the camera arm actually exists
+        match self.node_camera_arm_vertical {
+            Some(arm) => {
+                // check for the current rotation
+                let save_arm = arm.assume_safe();
+                let current_rot = save_arm.rotation();
+
+                // clamp the rotation
+                if current_rot.x + input > self.camera_clamp.x || current_rot.x + input <= self.camera_clamp.y {
+                    return;
+                }
+
+                // actually rotate if possible
+                let save_arm = arm.assume_safe();
+                save_arm.rotate_object_local(Vector3 {x: 1.0, y: 0.0, z: 0.0}, input as f64)
+            },
+            _ => 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!"),
+        }
+    }
+}
diff --git a/rust/src/game.rs b/rust/src/game.rs
index ece5a54..61b23ed 100644
--- a/rust/src/game.rs
+++ b/rust/src/game.rs
@@ -40,7 +40,5 @@ impl Game {
 
     // This function will be called in every frame
     #[export]
-    unsafe fn _process(&self, _owner: &Spatial, delta: f64) {
-        godot_print!("Inside {} _process(), delta is {}", self.name, delta);
-    }
+    unsafe fn _process(&self, _owner: &Spatial, _delta: f64) { }
 }
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 7958395..de26e5d 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -1,6 +1,7 @@
 mod game;
 mod spinning_cube;
 mod test;
+mod basic_die;
 
 use gdnative::prelude::{godot_init, InitHandle};
 
@@ -9,6 +10,7 @@ fn init(handle: InitHandle) {
     handle.add_class::<game::Game>();
     handle.add_class::<spinning_cube::SpinningCube>();
     handle.add_class::<test::SpinningCubeReverse>();
+    handle.add_class::<basic_die::BasicDie>();
 }
 
 // macros that create the entry-points of the dynamic library.