Merge pull request #201 from scratchcpp/timer

Implement timer

Author: adazem009

CMakeLists.txt

@@ -46,6 +46,7 @@ target_sources(scratchcpp
     include/scratchcpp/target.h
     include/scratchcpp/stage.h
     include/scratchcpp/sprite.h
+    include/scratchcpp/itimer.h
 )
 
 add_library(zip SHARED

include/scratchcpp/iengine.h

@@ -19,6 +19,7 @@ class Sprite;
 class Variable;
 class List;
 class Script;
+class ITimer;
 
 /*!
  * \brief The IEngine interface provides an API for running Scratch projects.
@@ -106,6 +107,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Call this from a block implementation to ignore calls to skipFrame() until the current frame ends. */
         virtual void lockFrame() = 0;
 
+        /*! Returns the timer of the project. */
+        virtual ITimer *timer() const = 0;
+
         /*!
          * Registers the given block section.
          * \see <a href="blockSections.html">Block sections</a>

include/scratchcpp/itimer.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace libscratchcpp
+{
+
+/*!
+ * \brief The ITimer interface represents a timer of a Scratch project.
+ *
+ * You can get a project timer using Engine#timer().
+ */
+class ITimer
+{
+    public:
+        virtual ~ITimer() { }
+
+        /*! Returns the time since last reset in seconds. */
+        virtual double value() const = 0;
+
+        /*! Resets the timer. */
+        virtual void reset() = 0;
+};
+
+} // namespace libscratchcpp

src/engine/CMakeLists.txt

@@ -11,6 +11,11 @@ target_sources(scratchcpp
     script_p.h
     internal/engine.cpp
     internal/engine.h
+    internal/clock.cpp
+    internal/clock.h
+    internal/iclock.h
+    internal/timer.cpp
+    internal/timer.h
     internal/blocksectioncontainer.cpp
     internal/blocksectioncontainer.h
     internal/global.h

src/engine/internal/clock.cpp

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "clock.h"
+
+using namespace libscratchcpp;
+
+std::shared_ptr<Clock> Clock::m_instance = std::make_shared<Clock>();
+
+Clock::Clock()
+{
+}
+
+std::shared_ptr<Clock> Clock::instance()
+{
+    return m_instance;
+}
+
+std::chrono::steady_clock::time_point Clock::currentTime() const
+{
+    return std::chrono::steady_clock::now();
+}

src/engine/internal/clock.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+#include "iclock.h"
+
+namespace libscratchcpp
+{
+
+class Clock : public IClock
+{
+    public:
+        Clock();
+        Clock(const Clock &) = delete;
+
+        static std::shared_ptr<Clock> instance();
+
+        std::chrono::steady_clock::time_point currentTime() const override;
+
+    private:
+        static std::shared_ptr<Clock> m_instance;
+};
+
+} // namespace libscratchcpp

src/engine/internal/engine.cpp

@@ -18,11 +18,14 @@
 
 #include "engine.h"
 #include "blocksectioncontainer.h"
+#include "timer.h"
 #include "../../blocks/standardblocks.h"
 
 using namespace libscratchcpp;
 
-Engine::Engine()
+Engine::Engine() :
+    m_defaultTimer(std::make_unique<Timer>()),
+    m_timer(m_defaultTimer.get())
 {
     srand(time(NULL));
 }
@@ -165,6 +168,8 @@ void Engine::frame()
 
 void Engine::start()
 {
+    m_timer->reset();
+
     for (auto target : m_targets) {
         auto gfBlocks = target->greenFlagBlocks();
         for (auto block : gfBlocks)
@@ -377,6 +382,16 @@ void Engine::lockFrame()
     m_lockFrame = true;
 }
 
+ITimer *Engine::timer() const
+{
+    return m_timer;
+}
+
+void Engine::setTimer(ITimer *timer)
+{
+    m_timer = timer;
+}
+
 void Engine::registerSection(std::shared_ptr<IBlockSection> section)
 {
     if (section) {

src/engine/internal/engine.h

@@ -4,6 +4,7 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/target.h>
+#include <scratchcpp/itimer.h>
 #include <unordered_map>
 #include <memory>
 #include <chrono>
@@ -43,6 +44,9 @@ class Engine : public IEngine
         void skipFrame() override;
         void lockFrame() override;
 
+        ITimer *timer() const override;
+        void setTimer(ITimer *timer);
+
         void registerSection(std::shared_ptr<IBlockSection> section) override;
         std::vector<std::shared_ptr<IBlockSection>> registeredSections() const;
         unsigned int functionIndex(BlockFunc f) override;
@@ -101,6 +105,9 @@ class Engine : public IEngine
         std::unordered_map<Variable *, Target *> m_variableOwners;
         std::unordered_map<List *, Target *> m_listOwners;
 
+        std::unique_ptr<ITimer> m_defaultTimer;
+        ITimer *m_timer = nullptr;
+
         bool m_breakFrame = false;
         bool m_skipFrame = false;
         bool m_lockFrame = false;

src/engine/internal/iclock.h

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <chrono>
+
+namespace libscratchcpp
+{
+
+class IClock
+{
+    public:
+        virtual ~IClock() { }
+
+        virtual std::chrono::steady_clock::time_point currentTime() const = 0;
+};
+
+} // namespace libscratchcpp

src/engine/internal/timer.cpp

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <cassert>
+
+#include "timer.h"
+#include "clock.h"
+
+using namespace libscratchcpp;
+
+Timer::Timer()
+{
+    m_clock = Clock::instance().get();
+    resetTimer();
+}
+
+Timer::Timer(IClock *clock) :
+    m_clock(clock)
+{
+    assert(clock);
+    resetTimer();
+}
+
+double Timer::value() const
+{
+    return std::chrono::duration_cast<std::chrono::milliseconds>(m_clock->currentTime() - m_startTime).count() / 1000.0;
+}
+
+void Timer::reset()
+{
+    resetTimer();
+}
+
+// Required to avoid calling the virtual method from the constructors
+void Timer::resetTimer()
+{
+    m_startTime = m_clock->currentTime();
+}