Implement turbo mode

include/scratchcpp/iengine.h

@@ -99,6 +99,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Sets the framerate of the project. */
         virtual void setFps(double fps) = 0;
 
+        /*! Returns true if turbo mode is enabled. */
+        virtual bool turboModeEnabled() const = 0;
+
+        /*! Sets whether turbo mode is enabled. */
+        virtual void setTurboModeEnabled(bool turboMode) = 0;
+
         /*! Returns true if the given key is pressed. */
         virtual bool keyPressed(const std::string &name) const = 0;
 

src/engine/internal/engine.cpp

@@ -368,7 +368,7 @@ void Engine::eventLoop(bool untilProjectStops)
             elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - frameStart);
             sleepTime = m_frameDuration - elapsedTime;
             timeout = sleepTime <= std::chrono::milliseconds::zero();
-        } while (!m_redrawRequested && !timeout && !stop);
+        } while (!((m_redrawRequested && !m_turboModeEnabled) || timeout || stop));
 
         if (stop)
             break;
@@ -477,6 +477,16 @@ void Engine::setFps(double fps)
     updateFrameDuration();
 }
 
+bool Engine::turboModeEnabled() const
+{
+    return m_turboModeEnabled;
+}
+
+void Engine::setTurboModeEnabled(bool turboMode)
+{
+    m_turboModeEnabled = turboMode;
+}
+
 bool Engine::keyPressed(const std::string &name) const
 {
     if (name == "any") {

src/engine/internal/engine.h

@@ -45,6 +45,9 @@ class Engine : public IEngine
         double fps() const override;
         void setFps(double fps) override;
 
+        bool turboModeEnabled() const override;
+        void setTurboModeEnabled(bool turboMode) override;
+
         bool keyPressed(const std::string &name) const override;
         void setKeyState(const std::string &name, bool pressed) override;
         void setAnyKeyPressed(bool pressed) override;
@@ -161,8 +164,9 @@ class Engine : public IEngine
 
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;
-        double m_fps = 30;                              // default FPS
-        std::chrono::milliseconds m_frameDuration;      // will be computed in eventLoop()
+        double m_fps = 30;                         // default FPS
+        std::chrono::milliseconds m_frameDuration; // will be computed in eventLoop()
+        bool m_turboModeEnabled = false;
         std::unordered_map<std::string, bool> m_keyMap; // holds key states
         bool m_anyKeyPressed = false;
         double m_mouseX = 0;

test/engine/engine_test.cpp

@@ -114,6 +114,23 @@ TEST(EngineTest, FpsProject)
     EXPECT_CALL(clock, sleep(std::chrono::milliseconds(100)));
     EXPECT_CALL(clock, sleep(std::chrono::milliseconds(15)));
     p.run();
+
+    engine->setTurboModeEnabled(true);
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time5)).WillOnce(Return(time5)).WillOnce(Return(time6)).WillOnce(Return(time6)).WillOnce(Return(time7)).WillOnce(Return(time8));
+    EXPECT_CALL(clock, sleep).Times(0);
+    p.run();
+}
+
+TEST(EngineTest, TurboModeEnabled)
+{
+    Engine engine;
+    ASSERT_FALSE(engine.turboModeEnabled());
+
+    engine.setTurboModeEnabled(true);
+    ASSERT_TRUE(engine.turboModeEnabled());
+
+    engine.setTurboModeEnabled(false);
+    ASSERT_FALSE(engine.turboModeEnabled());
 }
 
 TEST(EngineTest, ExecutionOrder)

test/mocks/enginemock.h

@@ -31,6 +31,9 @@ class EngineMock : public IEngine
         MOCK_METHOD(double, fps, (), (const, override));
         MOCK_METHOD(void, setFps, (double fps), (override));
 
+        MOCK_METHOD(bool, turboModeEnabled, (), (const, override));
+        MOCK_METHOD(void, setTurboModeEnabled, (bool), (override));
+
         MOCK_METHOD(bool, keyPressed, (const std::string &), (const, override));
         MOCK_METHOD(void, setKeyState, (const std::string &, bool), (override));
         MOCK_METHOD(void, setAnyKeyPressed, (bool), (override));