Jump animation

src/Animator.cpp

@@ -107,12 +107,12 @@ namespace MagnumGame {
             auto targetBone = asset._bonesById.find(animatedObjectId);
 
             if (targetBone != asset._bonesById.end()) {
-                Debug{} << "Track" << animationName << "track" << trackIndex
-                        << "target" << animationData.trackTarget(trackIndex)
-                        << targetBone->second.name
-                        << "type" << animationData.trackType(trackIndex)
-                        << "(name" << animationData.trackTargetName(trackIndex) << ")"
-                        << "result" << animationData.trackResultType(trackIndex);
+                // Debug{} << "Track" << animationName << "track" << trackIndex
+                //         << "target" << animationData.trackTarget(trackIndex)
+                //         << targetBone->second.name
+                //         << "type" << animationData.trackType(trackIndex)
+                //         << "(name" << animationData.trackTargetName(trackIndex) << ")"
+                //         << "result" << animationData.trackResultType(trackIndex);
                 addAnimationTrack(animationData, trackIndex, targetBone->second, boneMap);
             }
             else {

src/GameState.cpp

@@ -196,10 +196,13 @@ namespace MagnumGame {
                                                                    &_animatorDrawables, &_opaqueDrawables);
         animationOffset.setTransformation(Matrix4::translation({0, -0.4f, 0}));
 
+        auto& rb = rigidBody->rigidBody();
         //Prevent rotation in X & Z
-        rigidBody->rigidBody().setAngularFactor(btVector3(0.0f, 0.5f, 0.0f));
-        Debug{} << "Friction: " << rigidBody->rigidBody().getFriction() << "rolling friction" << rigidBody->rigidBody().getRollingFriction();
-        rigidBody->rigidBody().setRollingFriction(0.5f);
+        rb.setAngularFactor(btVector3(0.0f, 0.0f, 0.0f));
+        rb.setFriction(0.5f);
+        rb.setRollingFriction(0.5f);
+
+        Debug{} << "Friction: " << rb.getFriction() << "rolling friction" << rb.getRollingFriction();
 
         _player.emplace("Someone", rigidBody, animator);
         _player->resetToStart(Matrix4::translation({0,2,0}));

src/MagnumGameApp.cpp

@@ -101,6 +101,26 @@ namespace MagnumGame {
         _gameState->loadLevel(*gltfImporter);
         _gameState->setupPlayer();
 
+        _tweakables->addDebugMode("Friction", 0, {
+                                      {
+                                          "Friction", [&]() {
+                                              return _gameState->getPlayer()->getBody()->rigidBody().getFriction();
+                                          },
+                                          [&](float value) {
+                                              _gameState->getPlayer()->getBody()->rigidBody().setFriction(value);
+                                          }
+                                      },
+                                      {
+                                          "Rolling Friction", [&]() {
+                                              return _gameState->getPlayer()->getBody()->rigidBody().
+                                                      getRollingFriction();
+                                          },
+                                          [&](float value) {
+                                              _gameState->getPlayer()->getBody()->rigidBody().setRollingFriction(value);
+                                          }
+                                      }
+                                  });
+
 #ifndef CORRADE_TARGET_EMSCRIPTEN
         setSwapInterval(0);
         setMinimalLoopPeriod(8.0_msec);

src/MagnumGameApp_text.cpp

@@ -3,21 +3,17 @@
 #include <sstream>
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/Utility/Path.h>
-#include <Magnum/Timeline.h>
 #include <Magnum/Math/Matrix3.h>
 #include <Magnum/Text/AbstractFont.h>
 #include <Magnum/Text/Alignment.h>
 #include <Magnum/Text/Renderer.h>
 #include <Magnum/TextureTools/Atlas.h>
 #include <Magnum/Math/Color.h>
-#include <Magnum/SceneGraph/Camera.h>
-
 
 #include "GameState.h"
 #include "MagnumGameApp.h"
 #include "Player.h"
 #include "Tweakables.h"
-#include "OnGroundQuery.h"
 
 namespace MagnumGame {
 
@@ -106,7 +102,15 @@ namespace MagnumGame {
                 oss << std::setprecision(5);
                 oss << std::fixed;
 
+                auto onGround = _gameState->getPlayer()->isOnGround();
+
                 oss << "Pos " << rigidBody->transformationMatrix().translation();
+                if (onGround) {
+                    oss << " OnGround";
+                }
+                else {
+                    oss << " OffGround";
+                }
             }
             else {
                 oss << "No player";

src/Player.cpp

@@ -30,17 +30,40 @@ namespace MagnumGame {
     bool Player::isAlive() const { return _pBody->rigidBody().isInWorld(); }
 
     void Player::update(Float deltaTime) {
+        auto& rigidBody = _pBody->rigidBody();
+        auto velocity = btVector3(_control * WalkSpeed);
+        // auto motion = velocity * deltaTime;
+
+        auto currentVelocity = rigidBody.getLinearVelocity();
+        velocity.setY(currentVelocity.y());
+        rigidBody.setLinearVelocity(btVector3(velocity));
 
         if (!_control.isZero()) {
-            auto motion = _control * WalkSpeed * deltaTime;
             auto position = _pBody->transformation().translation();
-
             auto matrix = Matrix4::lookAt({0,0,0}, -_control, {0,1,0});
-            matrix.translation() = position + motion;
-
+            matrix.translation() = position;
             _pBody->setTransformation(matrix);
             _pBody->syncPose();
         }
+
+        _isOnGround = OnGroundQueryResult{rigidBody}.run(_pBody->getWorld());
+        if (_markJumpFrame && _isOnGround) {
+            rigidBody.applyImpulse({0,4.0f,0},{});
+        }
+        _markJumpFrame = false;
+
+        if (_animator != nullptr) {
+            if (!_isOnGround) {
+                _animator->play("jump", false);
+            }
+            else if (_control.isZero()) {
+                _animator->play("idle", false);
+            }
+            else {
+                _animator->play("walk", false);
+            }
+        }
+
     }
 
     Vector3 Player::getPosition() const { return _pBody->transformation().translation(); }
@@ -62,15 +85,6 @@ namespace MagnumGame {
     void Player::setControl(const Vector3 &control) {
         if (_control != control) {
             _control = control;
-
-            if (_animator != nullptr) {
-                if (_control.isZero()) {
-                    _animator->play("idle", false);
-                }
-                else {
-                    _animator->play("walk", false);
-                }
-            }
         }
     }
 
@@ -95,8 +109,6 @@ namespace MagnumGame {
 
     void Player::tryJump() {
 
-        if (OnGroundQueryResult{_pBody->rigidBody()}.run(_pBody->getWorld())) {
-            _pBody->rigidBody().applyImpulse({0,4.0f,0},{});
-        }
+        _markJumpFrame = true;
     }
 }

src/Player.h

@@ -47,12 +47,16 @@ namespace MagnumGame {
 
         RigidBody* getBody() { return _pBody; }
 
+        bool isOnGround() const { return _isOnGround; }
+
     private:
         std::string _name;
         RigidBody *_pBody;
         Animator *_animator;
         IEnableDrawable *_pBodyDrawable{};
         Vector3 _control{};
+        bool _markJumpFrame;
+        bool _isOnGround;
     };
 
 }

src/Tweakables.h

@@ -9,7 +9,7 @@
 namespace MagnumGame {
     class Tweakables {
     public:
-        Tweakables();
+        explicit Tweakables();
 
         /**
          * @brief Named pointer for tweaking a configurable float value at runtime
@@ -38,8 +38,9 @@ namespace MagnumGame {
             void tweakBy(int sign, int powerAdjust) {
                 float value = get();
 
+                float absValue = std::max(abs(value), 0.00001f);
                 //Compute the nearest sensible power of 10 to for adjusting a value
-                set(value + sign * pow(10, round(log10(abs(value))) + powerAdjust));
+                set(value + sign * pow(10, round(log10(absValue)) + powerAdjust));
             }
 
         private: