feat 3D: jumping like rabbits :3

examples/POC_3D/include/Constants.hpp

@@ -11,4 +11,4 @@
 #define WINDOW_HEIGHT 720
 #define HUD_HEIGHT 30
 #define WINDOW_TOTAL_HEIGHT WINDOW_HEIGHT + HUD_HEIGHT
-#define MOUSE_SENSITIVITY 0.2f
+#define MOUSE_SENSITIVITY 0.6f

examples/POC_3D/include/events/Jump.hpp

@@ -0,0 +1,20 @@
+/*
+** EPITECH PROJECT, 2024
+** B-CPP-500-LYN-5-1-rtype-basile.fouquet
+** File description:
+** Jump.hpp
+*/
+
+#pragma once
+
+#include "GEngine/libdev/System.hpp"
+
+namespace rtype::event {
+struct Jump : public gengine::Event {
+    float strength;
+
+    Jump(float strength = 0.1)
+        : strength(strength) {
+    }
+};
+} // namespace rtype::event

examples/POC_3D/include/systems/InputsToGameEvents.hpp

@@ -13,6 +13,7 @@
 
 #include "events/Movement.hpp"
 #include "events/Rotation.hpp"
+#include "events/Jump.hpp"
 
 namespace rtype::system {
 class InputsToGameEvents
@@ -26,6 +27,8 @@ class InputsToGameEvents
     void moveBck(geg::event::io::KeySEvent &e);
     void moveRight(geg::event::io::KeyDEvent &e);
 
+    void jump(geg::event::io::KeySpaceEvent &e);
+
 private:
     char m_directionBitmask = 0;
     static const char FWD_MASK = 1 << 0;    // 0b0001

examples/POC_3D/include/systems/PlayerMotion.hpp

@@ -16,9 +16,11 @@
 #include "GEngine/libdev/components/driver/output/Model.hpp"
 #include "components/Player.hpp"
 
+#include "GEngine/libdev/Components.hpp"
 #include "GEngine/libdev/System.hpp"
 
 #include "GEngine/interface/events/SharedEvent.hpp"
+#include "events/Jump.hpp"
 #include "events/Movement.hpp"
 #include "events/Rotation.hpp"
 
@@ -27,12 +29,16 @@
 namespace rtype::system {
 class PlayerMotion
     : public gengine::System<PlayerMotion, gengine::interface::component::RemoteLocal, gengine::component::Velocity3D,
-                             gengine::component::driver::output::Model, gengine::component::Transform3D,
+                             gengine::component::driver::output::Model, geg::component::Transform3D, geg::component::Acceleration3D,
                              component::Player, gengine::system::driver::output::DrawModel> {
 public:
     void init(void) override;
     void onGameLoop(gengine::system::event::GameLoop &);
     void movePlayer(gengine::interface::event::SharedEvent<event::Movement> &e);
     void rotatePlayer(gengine::interface::event::SharedEvent<event::Rotation> &e);
+    void jumpPlayer(gengine::interface::event::SharedEvent<event::Jump> &e);
+
+private:
+    void moveCamera(geg::component::Transform3D &transform, gengine::Vect3 &forward);
 };
 } // namespace rtype::system

examples/POC_3D/run.sh

@@ -5,7 +5,7 @@ build_project() {
     cd build
     touch .gitkeep
 
-    cmake .. -DCMAKE_TOOLCHAIN_FILE=./cmake/define-compilers.cmake || { echo "CMake configuration failed"; exit 1; }
+    cmake .. -DCMAKE_TOOLCHAIN_FILE=./cmake/define-compilers.cmake -DCMAKE_BUILD_TYPE=Debug || { echo "CMake configuration failed"; exit 1; }
     cmake --build . --parallel 8 || { echo "CMake build failed"; exit 1; }
 }
 
@@ -17,7 +17,7 @@ build_project
 
 echo "Running server..."
 mkfifo pipe
-./r-type_server > pipe &
+./r-type_serverd > pipe &
 SERVER_PID=$!
 tee server_output.log < pipe &
 TEE_PID=$!
@@ -37,7 +37,7 @@ trap cleanup SIGINT
 sleep 1
 
 echo "Running client..."
-./r-type_client
+./r-type_clientd
 
 kill $SERVER_PID 2>/dev/null
 kill $TEE_PID 2>/dev/null

examples/POC_3D/source/components.cpp

@@ -23,6 +23,7 @@ void GEngineDeclareComponents(Registry *r) {
     r->registerComponent<geg::component::Velocity3D>();
     r->registerComponent<geg::component::Transform2D>();
     r->registerComponent<geg::component::Transform3D>();
+    r->registerComponent<geg::component::Acceleration3D>();
     r->registerComponent<geg::component::io::Drawable>();
     r->registerComponent<geg::component::io::Sprite>();
     r->registerComponent<geg::component::io::Model>();

examples/POC_3D/source/systems.cpp

@@ -46,6 +46,7 @@ void GEngineDeclareSystems(Registry *r) {
 
     r->registerSystem<gengine::system::Motion2D>();
     r->registerSystem<gengine::system::Motion3D>();
+    r->registerSystem<gengine::system::MotionAcceleration3D>();
     r->registerSystem<gengine::system::Collision2D>();
     r->registerSystem<gengine::system::AutoKiller>();
 
@@ -58,9 +59,11 @@ void GEngineDeclareSystems(Registry *r) {
     r->registerSystem<gengine::interface::system::HandleLocal>();
 
     r->registerSystem<gengine::interface::network::system::ClientEventPublisher<
-        rtype::event::Movement, rtype::event::Rotation, gengine::interface::event::GetRemoteLocalWhoIAm>>();
+        rtype::event::Movement, rtype::event::Rotation, rtype::event::Jump,
+        gengine::interface::event::GetRemoteLocalWhoIAm>>();
     r->registerSystem<gengine::interface::network::system::ServerEventReceiver<
-        rtype::event::Movement, rtype::event::Rotation, gengine::interface::event::GetRemoteLocalWhoIAm>>();
+        rtype::event::Movement, rtype::event::Rotation, rtype::event::Jump,
+        gengine::interface::event::GetRemoteLocalWhoIAm>>();
 
     // TODO auto register ↓
 }

examples/POC_3D/source/systems/InputsToGameEvents.cpp

@@ -15,6 +15,7 @@ void InputsToGameEvents::init(void) {
     subscribeToEvent<geg::event::io::KeyAEvent>(&InputsToGameEvents::moveLeft);
     subscribeToEvent<geg::event::io::KeySEvent>(&InputsToGameEvents::moveBck);
     subscribeToEvent<geg::event::io::KeyDEvent>(&InputsToGameEvents::moveRight);
+    subscribeToEvent<geg::event::io::KeySpaceEvent>(&InputsToGameEvents::jump);
 }
 
 void InputsToGameEvents::sendEvents(gengine::system::event::GameLoop &e) {
@@ -25,9 +26,10 @@ void InputsToGameEvents::sendEvents(gengine::system::event::GameLoop &e) {
     // DisableCursor(); //TODO Debug this (trying to hide the cursor)
     // SetMousePosition(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2);
     gengine::Vect3 rotation = {0, 0, 0};
-    if (mouseDelta.x != 0.0f)
-        rotation.y += MOUSE_SENSITIVITY * mouseDelta.x;
-    publishEvent<event::Rotation>(rotation);
+    if (mouseDelta.x != 0.0f) {
+        rotation.y -= MOUSE_SENSITIVITY * mouseDelta.x;
+        publishEvent<event::Rotation>(rotation);
+    }
 }
 
 void InputsToGameEvents::moveFwd(geg::event::io::KeyWEvent &e) {
@@ -127,4 +129,9 @@ event::Movement::State InputsToGameEvents::getMovementState(void) {
         return event::Movement::STANDING;
     }
 }
+
+void InputsToGameEvents::jump(geg::event::io::KeySpaceEvent &e) {
+    if (e.state == geg::event::io::InputState::PRESSED)
+        publishEvent(event::Jump(0.12));
+}
 } // namespace rtype::system

examples/POC_3D/source/systems/PlayerMotion.cpp

@@ -19,14 +19,27 @@ void PlayerMotion::init(void) {
     subscribeToEvent<gengine::system::event::GameLoop>(&PlayerMotion::onGameLoop);
     subscribeToEvent<gengine::interface::event::SharedEvent<event::Movement>>(&PlayerMotion::movePlayer);
     subscribeToEvent<gengine::interface::event::SharedEvent<event::Rotation>>(&PlayerMotion::rotatePlayer);
+    subscribeToEvent<gengine::interface::event::SharedEvent<event::Jump>>(&PlayerMotion::jumpPlayer);
 }
 
 void PlayerMotion::onGameLoop(gengine::system::event::GameLoop &e) {
+    auto &transforms = getComponents<geg::component::Transform3D>();
+    auto &velocities = getComponents<gengine::component::Velocity3D>();
+    auto &players = getComponents<component::Player>();
+
+    for (auto [entity, transform, player] : gengine::Zip(transforms, players)) {
+        if (transform.pos.y <= 0) {
+            transform.pos.y = 0;
+            if (velocities.contains(entity))
+                velocities.get(entity).y = 0;
+            unsetComponent<geg::component::Acceleration3D>(entity);
+        }
+    }
 }
 
 void PlayerMotion::movePlayer(gengine::interface::event::SharedEvent<event::Movement> &e) {
     auto &velocities = getComponents<gengine::component::Velocity3D>();
-    auto &transforms = getComponents<gengine::component::Transform3D>();
+    auto &transforms = getComponents<geg::component::Transform3D>();
     auto &players = getComponents<component::Player>();
     auto &remotes = getComponents<gengine::interface::component::RemoteLocal>();
     auto &models = getComponents<gengine::component::driver::output::Model>();
@@ -40,51 +53,60 @@ void PlayerMotion::movePlayer(gengine::interface::event::SharedEvent<event::Move
 
         // Handle movement input
         switch (e->state) {
-        case event::Movement::LEFT:
-            velocity = {-player.speed * right.x, 0.f, -player.speed * right.z};
+        case event::Movement::LEFT: {
+            velocity.x = -player.speed * right.x;
+            velocity.z = -player.speed * right.z;
             break;
-        case event::Movement::RIGHT:
-            velocity = {player.speed * right.x, 0, player.speed * right.z};
+        }
+        case event::Movement::RIGHT: {
+            velocity.x = player.speed * right.x;
+            velocity.z = player.speed * right.z;
             break;
-        case event::Movement::FWD:
-            velocity = {player.speed * forward.x, 0.f, player.speed * forward.z};
+        }
+        case event::Movement::FWD: {
+            velocity.x = player.speed * forward.x;
+            velocity.z = player.speed * forward.z;
             break;
-        case event::Movement::BCK:
-            velocity = {-player.speed * forward.x, 0, -player.speed * forward.z};
+        }
+        case event::Movement::BCK: {
+            velocity.x = -player.speed * forward.x;
+            velocity.z = -player.speed * forward.z;
             break;
-        case event::Movement::FWD_RIGHT:
-            velocity = {player.speed * (forward.x + right.x) / sqrt(2.f), 0,
-                        player.speed * (forward.z + right.z) / sqrt(2.f)};
+        }
+        case event::Movement::FWD_RIGHT: {
+            velocity.x = player.speed * (forward.x + right.x) / sqrt(2.f);
+            velocity.z = player.speed * (forward.z + right.z) / sqrt(2.f);
             break;
-        case event::Movement::FWD_LEFT:
-            velocity = {player.speed * (forward.x - right.x) / sqrt(2.f), 0,
-                        player.speed * (forward.z - right.z) / sqrt(2.f)};
+        }
+        case event::Movement::FWD_LEFT: {
+            velocity.x = player.speed * (forward.x - right.x) / sqrt(2.f);
+            velocity.z = player.speed * (forward.z - right.z) / sqrt(2.f);
             break;
-        case event::Movement::BCK_RIGHT:
-            velocity = {-player.speed * (forward.x - right.x) / sqrt(2.f), 0,
-                        -player.speed * (forward.z - right.z) / sqrt(2.f)};
+        }
+        case event::Movement::BCK_RIGHT: {
+            velocity.x = -player.speed * (forward.x - right.x) / sqrt(2.f);
+            velocity.z = -player.speed * (forward.z - right.z) / sqrt(2.f);
             break;
-        case event::Movement::BCK_LEFT:
-            velocity = {-player.speed * (forward.x + right.x) / sqrt(2.f), 0,
-                        -player.speed * (forward.z + right.z) / sqrt(2.f)};
+        }
+        case event::Movement::BCK_LEFT: {
+            velocity.x = -player.speed * (forward.x + right.x) / sqrt(2.f);
+            velocity.z = -player.speed * (forward.z + right.z) / sqrt(2.f);
             break;
-        case event::Movement::STANDING:
-            velocity = {0, 0, 0};
+        }
+        case event::Movement::STANDING: {
+            velocity.x = 0;
+            velocity.z = 0;
             break;
         }
-        if (hasSystem<gengine::system::driver::output::DrawModel>()) {
-            auto &draw = getSystem<gengine::system::driver::output::DrawModel>();
-            draw.camera.position.x = transform.pos.x - forward.x * 2;
-            draw.camera.position.z = transform.pos.z - forward.z * 2;
-            draw.camera.target.x = transform.pos.x + forward.x * 3;
-            draw.camera.target.z = transform.pos.z + forward.z * 3;
         }
+
+        moveCamera(transform, forward);
     }
 }
 
 void PlayerMotion::rotatePlayer(gengine::interface::event::SharedEvent<event::Rotation> &e) {
     auto &players = getComponents<component::Player>();
-    auto &transforms = getComponents<gengine::component::Transform3D>();
+    auto &transforms = getComponents<geg::component::Transform3D>();
     auto &remotes = getComponents<gengine::interface::component::RemoteLocal>();
 
     for (auto [entity, remote, player, transform] : gengine::Zip(remotes, players, transforms)) {
@@ -95,4 +117,30 @@ void PlayerMotion::rotatePlayer(gengine::interface::event::SharedEvent<event::Ro
         transform.rotation.z += e->move.z;
     }
 }
+
+void PlayerMotion::jumpPlayer(gengine::interface::event::SharedEvent<event::Jump> &e) {
+    auto &transforms = getComponents<geg::component::Transform3D>();
+    auto &velocities = getComponents<gengine::component::Velocity3D>();
+    auto &accelerations = getComponents<geg::component::Acceleration3D>();
+    auto &players = getComponents<component::Player>();
+    auto &remotes = getComponents<gengine::interface::component::RemoteLocal>();
+
+    for (auto [entity, remote, player, velocity, transform] : gengine::Zip(remotes, players, velocities, transforms)) {
+        if (remote.getUUIDBytes() != e.remoteUUID ||
+            accelerations.contains(entity)) // check if its the same remote (zip)
+            continue;
+        velocity.y = e->strength;
+        setComponent(entity, geg::component::Acceleration3D(0, -0.009, 0));
+    }
+}
+
+void PlayerMotion::moveCamera(geg::component::Transform3D &transform, gengine::Vect3 &forward) {
+    if (hasSystem<gengine::system::driver::output::DrawModel>()) {
+        auto &draw = getSystem<gengine::system::driver::output::DrawModel>();
+        draw.camera.position.x = transform.pos.x - forward.x * 2;
+        draw.camera.position.z = transform.pos.z - forward.z * 2;
+        draw.camera.target.x = transform.pos.x + forward.x * 3;
+        draw.camera.target.z = transform.pos.z + forward.z * 3;
+    }
+}
 } // namespace rtype::system

include/GEngine/libdev/Components.hpp

@@ -27,6 +27,7 @@ using Transform3D = gengine::component::Transform3D;
 using Velocity2D = gengine::component::Velocity2D;
 using Velocity3D = gengine::component::Velocity3D;
 using Acceleration2D = gengine::component::Acceleration2D;
+using Acceleration3D = gengine::component::Acceleration3D;
 } // namespace geg::component
 
 #include "GEngine/libdev/components/driver/output/Animation.hpp"

include/GEngine/libdev/Systems.hpp

@@ -26,6 +26,7 @@ using AutoMainLoop = gengine::system::AutoMainLoop;
 using Motion2D = gengine::system::Motion2D;
 using Motion3D = gengine::system::Motion3D;
 using MotionAcceleration2D = gengine::system::MotionAcceleration2D;
+using MotionAcceleration3D = gengine::system::MotionAcceleration3D;
 } // namespace geg::system
 
 #include "GEngine/libdev/systems/driver/input/KeyboardCatcher.hpp"

include/GEngine/libdev/components/Accelerations.hpp

@@ -19,4 +19,15 @@ struct Acceleration2D : public Component<Acceleration2D> {
 
     bool operator==(const Acceleration2D &) const = default;
 };
+
+struct Acceleration3D : public Component<Acceleration3D> {
+    float x, y, z;
+    Acceleration3D(float x, float y, float z)
+        : x(x)
+        , y(y)
+        , z(z) {
+    }
+
+    bool operator==(const Acceleration3D &) const = default;
+};
 } // namespace gengine::component

include/GEngine/libdev/systems/Motions.hpp

@@ -38,4 +38,10 @@ class MotionAcceleration2D : public System<MotionAcceleration2D, component::Velo
     void init(void);
     void onGameLoop(event::GameLoop &);
 };
+
+class MotionAcceleration3D : public System<MotionAcceleration3D, component::Velocity3D, component::Acceleration3D> {
+public:
+    void init(void);
+    void onGameLoop(event::GameLoop &);
+};
 } // namespace gengine::system

source/GEngine/libdev/systems/Motions.cpp

@@ -49,4 +49,19 @@ void MotionAcceleration2D::onGameLoop(event::GameLoop &e) {
         velocity.y += acceleration.y;
     }
 }
+
+void MotionAcceleration3D::init(void) {
+    subscribeToEvent<event::GameLoop>(&MotionAcceleration3D::onGameLoop);
+}
+
+void MotionAcceleration3D::onGameLoop(event::GameLoop &e) {
+    auto &velocities = getComponents<component::Velocity3D>();
+    auto &accelerations = getComponents<component::Acceleration3D>();
+
+    for (auto [entity, velocity, acceleration] : Zip(velocities, accelerations)) {
+        velocity.x += acceleration.x;
+        velocity.y += acceleration.y;
+        velocity.z += acceleration.z;
+    }
+}
 } // namespace gengine::system