Ratelimit MeshUpdateQueue::cleanupCache() runs

[minetest.git] / src / client / inputhandler.h

diff --git a/src/client/inputhandler.h b/src/client/inputhandler.h
index 7487bbdc70d719213ebd6dbb575efa001dded786..3db105c518ecf6d066d1436247b6f558e3f1f21c 100644 (file)
--- a/src/client/inputhandler.h
+++ b/src/client/inputhandler.h
@@ -152,8 +152,14 @@ class MyEventReceiver : public IEventReceiver
        // in the subsequent iteration of Game::processPlayerInteraction
        bool WasKeyReleased(const KeyPress &keycode) const { return keyWasReleased[keycode]; }
 
-       void listenForKey(const KeyPress &keyCode) { keysListenedFor.set(keyCode); }
-       void dontListenForKeys() { keysListenedFor.clear(); }
+       void listenForKey(const KeyPress &keyCode)
+       {
+               keysListenedFor.set(keyCode);
+       }
+       void dontListenForKeys()
+       {
+               keysListenedFor.clear();
+       }
 
        s32 getMouseWheel()
        {
@@ -189,8 +195,6 @@ class MyEventReceiver : public IEventReceiver
 #endif
        }
 
-       s32 mouse_wheel = 0;
-
        JoystickController *joystick = nullptr;
 
 #ifdef HAVE_TOUCHSCREENGUI
@@ -198,10 +202,12 @@ class MyEventReceiver : public IEventReceiver
 #endif
 
 private:
+       s32 mouse_wheel = 0;
+
        // The current state of keys
        KeyList keyIsDown;
 
-       // Whether a key was down
+       // Like keyIsDown but only reset when that key is read
        KeyList keyWasDown;
 
        // Whether a key has just been pressed
@@ -240,6 +246,9 @@ class InputHandler
        virtual bool wasKeyReleased(GameKeyType k) = 0;
        virtual bool cancelPressed() = 0;
 
+       virtual float getMovementSpeed() = 0;
+       virtual float getMovementDirection() = 0;
+
        virtual void clearWasKeyPressed() {}
        virtual void clearWasKeyReleased() {}
 
@@ -269,6 +278,12 @@ class RealInputHandler : public InputHandler
        {
                m_receiver->joystick = &joystick;
        }
+
+       virtual ~RealInputHandler()
+       {
+               m_receiver->joystick = nullptr;
+       }
+
        virtual bool isKeyDown(GameKeyType k)
        {
                return m_receiver->IsKeyDown(keycache.key[k]) || joystick.isKeyDown(k);
@@ -285,10 +300,52 @@ class RealInputHandler : public InputHandler
        {
                return m_receiver->WasKeyReleased(keycache.key[k]) || joystick.wasKeyReleased(k);
        }
+
+       virtual float getMovementSpeed()
+       {
+               bool f = m_receiver->IsKeyDown(keycache.key[KeyType::FORWARD]),
+                       b = m_receiver->IsKeyDown(keycache.key[KeyType::BACKWARD]),
+                       l = m_receiver->IsKeyDown(keycache.key[KeyType::LEFT]),
+                       r = m_receiver->IsKeyDown(keycache.key[KeyType::RIGHT]);
+               if (f || b || l || r)
+               {
+                       // if contradictory keys pressed, stay still
+                       if (f && b && l && r)
+                               return 0.0f;
+                       else if (f && b && !l && !r)
+                               return 0.0f;
+                       else if (!f && !b && l && r)
+                               return 0.0f;
+                       return 1.0f; // If there is a keyboard event, assume maximum speed
+               }
+               return joystick.getMovementSpeed();
+       }
+
+       virtual float getMovementDirection()
+       {
+               float x = 0, z = 0;
+
+               /* Check keyboard for input */
+               if (m_receiver->IsKeyDown(keycache.key[KeyType::FORWARD]))
+                       z += 1;
+               if (m_receiver->IsKeyDown(keycache.key[KeyType::BACKWARD]))
+                       z -= 1;
+               if (m_receiver->IsKeyDown(keycache.key[KeyType::RIGHT]))
+                       x += 1;
+               if (m_receiver->IsKeyDown(keycache.key[KeyType::LEFT]))
+                       x -= 1;
+
+               if (x != 0 || z != 0) /* If there is a keyboard event, it takes priority */
+                       return atan2(x, z);
+               else
+                       return joystick.getMovementDirection();
+       }
+
        virtual bool cancelPressed()
        {
                return wasKeyDown(KeyType::ESC) || m_receiver->WasKeyDown(CancelKey);
        }
+
        virtual void clearWasKeyPressed()
        {
                m_receiver->clearWasKeyPressed();
@@ -297,17 +354,21 @@ class RealInputHandler : public InputHandler
        {
                m_receiver->clearWasKeyReleased();
        }
+
        virtual void listenForKey(const KeyPress &keyCode)
        {
                m_receiver->listenForKey(keyCode);
        }
-       virtual void dontListenForKeys() { m_receiver->dontListenForKeys(); }
+       virtual void dontListenForKeys()
+       {
+               m_receiver->dontListenForKeys();
+       }
+
        virtual v2s32 getMousePos()
        {
-               if (RenderingEngine::get_raw_device()->getCursorControl()) {
-                       return RenderingEngine::get_raw_device()
-                                       ->getCursorControl()
-                                       ->getPosition();
+               auto control = RenderingEngine::get_raw_device()->getCursorControl();
+               if (control) {
+                       return control->getPosition();
                }
 
                return m_mousepos;
@@ -315,16 +376,18 @@ class RealInputHandler : public InputHandler
 
        virtual void setMousePos(s32 x, s32 y)
        {
-               if (RenderingEngine::get_raw_device()->getCursorControl()) {
-                       RenderingEngine::get_raw_device()
-                                       ->getCursorControl()
-                                       ->setPosition(x, y);
+               auto control = RenderingEngine::get_raw_device()->getCursorControl();
+               if (control) {
+                       control->setPosition(x, y);
                } else {
                        m_mousepos = v2s32(x, y);
                }
        }
 
-       virtual s32 getMouseWheel() { return m_receiver->getMouseWheel(); }
+       virtual s32 getMouseWheel()
+       {
+               return m_receiver->getMouseWheel();
+       }
 
        void clear()
        {
@@ -352,6 +415,8 @@ class RandomInputHandler : public InputHandler
        virtual bool wasKeyPressed(GameKeyType k) { return false; }
        virtual bool wasKeyReleased(GameKeyType k) { return false; }
        virtual bool cancelPressed() { return false; }
+       virtual float getMovementSpeed() { return movementSpeed; }
+       virtual float getMovementDirection() { return movementDirection; }
        virtual v2s32 getMousePos() { return mousepos; }
        virtual void setMousePos(s32 x, s32 y) { mousepos = v2s32(x, y); }
 
@@ -365,4 +430,6 @@ class RandomInputHandler : public InputHandler
        KeyList keydown;
        v2s32 mousepos;
        v2s32 mousespeed;
+       float movementSpeed;
+       float movementDirection;
 };