Merge pull request #148 from scratchcpp/refactor_broadcasts

adazem009 · web-flow · commit 3cf001faf2c9 · 2023-08-10T02:44:59.000-07:00
Refactor broadcasts
diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
@@ -58,7 +58,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<Target> target) = 0;
 
         /*! Starts the script of the broadcast with the given index. */
-        virtual void broadcast(unsigned int index, VirtualMachine *sourceScript) = 0;
+        virtual void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) = 0;
 
         /*! Stops the given script. */
         virtual void stopScript(VirtualMachine *vm) = 0;
@@ -79,7 +79,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void run() = 0;
 
         /*! Returns true if there are any running script of the broadcast with the given index. */
-        virtual bool broadcastRunning(unsigned int index) = 0;
+        virtual bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) = 0;
 
         /*!
          * Call this from a block implementation to force a "screen refresh".
@@ -90,6 +90,16 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns true if breakFrame() was called. */
         virtual bool breakingCurrentFrame() = 0;
 
+        /*!
+         * Call this from a block implementation to skip a frame and run the next frame immediately.\n
+         * The screen will be refreshed according to the frame rate.
+         * \note This also works in "run without screen refresh" custom blocks.
+         */
+        virtual void skipFrame() = 0;
+
+        /*! Call this from a block implementation to ignore calls to skipFrame() until the current frame ends. */
+        virtual void lockFrame() = 0;
+
         /*!
          * Registers the given block section.
          * \see <a href="blockSections.html">Block sections</a>
diff --git a/src/blocks/controlblocks.cpp b/src/blocks/controlblocks.cpp
@@ -171,7 +171,6 @@ unsigned int ControlBlocks::stopOtherScriptsInSprite(VirtualMachine *vm)
 unsigned int ControlBlocks::startWait(VirtualMachine *vm)
 {
     auto currentTime = std::chrono::steady_clock::now();
-    assert(m_timeMap.count(vm) == 0);
     m_timeMap[vm] = { currentTime, vm->getInput(0, 1)->toDouble() * 1000 };
     return 1;
 }
@@ -185,6 +184,8 @@ unsigned int ControlBlocks::wait(VirtualMachine *vm)
         vm->stop(true, true, false);
     } else
         vm->stop(true, true, true);
+
+    vm->engine()->lockFrame();
     return 0;
 }
 
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
@@ -48,11 +48,11 @@ void EventBlocks::compileBroadcastAndWait(Compiler *compiler)
     compiler->addInput(input);
     if (input->type() != Input::Type::ObscuredShadow) {
         input->primaryValue()->setValue(compiler->engine()->findBroadcast(input->primaryValue()->value().toString()));
-        compiler->addFunctionCall(&broadcastByIndex);
+        compiler->addFunctionCall(&broadcastByIndexAndWait);
         compiler->addInput(input);
         compiler->addFunctionCall(&checkBroadcastByIndex);
     } else {
-        compiler->addFunctionCall(&broadcast);
+        compiler->addFunctionCall(&broadcastAndWait);
         compiler->addInput(input);
         compiler->addFunctionCall(&checkBroadcast);
     }
@@ -77,16 +77,28 @@ unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
+{
+    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm, true);
+    return 1;
+}
+
+unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
+{
+    vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm, true);
+    return 1;
+}
+
 unsigned int EventBlocks::checkBroadcast(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString())))
+    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm))
         vm->stop(true, true, true);
     return 1;
 }
 
 unsigned int EventBlocks::checkBroadcastByIndex(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong()))
+    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong(), vm))
         vm->stop(true, true, true);
     return 1;
 }
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
@@ -35,6 +35,8 @@ class EventBlocks : public IBlockSection
     private:
         static unsigned int broadcast(VirtualMachine *vm);
         static unsigned int broadcastByIndex(VirtualMachine *vm);
+        static unsigned int broadcastAndWait(VirtualMachine *vm);
+        static unsigned int broadcastByIndexAndWait(VirtualMachine *vm);
         static unsigned int checkBroadcast(VirtualMachine *vm);
         static unsigned int checkBroadcastByIndex(VirtualMachine *vm);
 };
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
@@ -119,15 +119,28 @@ void Engine::compile()
 
 void Engine::frame()
 {
+    m_lockFrame = false;
+
     for (int i = 0; i < m_runningScripts.size(); i++) {
         auto script = m_runningScripts[i];
         m_breakFrame = false;
 
         do {
             script->run();
             if (script->atEnd()) {
-                for (auto &[key, value] : m_broadcastMap)
-                    value.erase(std::remove(value.begin(), value.end(), script->script()), value.end());
+                for (auto &[key, value] : m_runningBroadcastMap) {
+                    size_t index = 0;
+
+                    for (const auto &pair : value) {
+                        if (pair.second == script.get()) {
+                            value.erase(value.begin() + index);
+                            break;
+                        }
+
+                        index++;
+                    }
+                }
+
                 m_scriptsToRemove.push_back(script.get());
             }
         } while (!script->atEnd() && !m_breakFrame);
@@ -180,24 +193,48 @@ void Engine::startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<T
     }
 }
 
-void libscratchcpp::Engine::broadcast(unsigned int index, VirtualMachine *sourceScript)
+void libscratchcpp::Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait)
 {
+    bool previousSkipFrame = m_skipFrame;
+    skipFrame();
     const std::vector<Script *> &scripts = m_broadcastMap[index];
+
     for (auto script : scripts) {
-        size_t index = -1;
-        for (size_t i = 0; i < m_runningScripts.size(); i++) {
+        long scriptIndex = -1;
+        for (long i = 0; i < m_runningScripts.size(); i++) {
             if (m_runningScripts[i]->script() == script) {
-                index = i;
+                scriptIndex = i;
                 break;
             }
         }
-        if (index != -1) {
+
+        if (scriptIndex != -1) {
             // Reset the script if it's already running
-            m_runningScripts[index]->reset();
-            if (script == sourceScript->script())
+            auto vm = m_runningScripts[scriptIndex];
+            vm->reset();
+
+            // Remove the script from scripts to remove because it's going to run again
+            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm.get()), m_scriptsToRemove.end());
+            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), m_runningScripts[scriptIndex].get()) == m_scriptsToRemove.end());
+
+            auto &scripts = m_runningBroadcastMap[index];
+
+            for (auto &pair : scripts) {
+                if (pair.second->script() == script)
+                    pair.first = sourceScript;
+            }
+
+            if (script == sourceScript->script()) {
                 sourceScript->stop(false, true);
+
+                if (!previousSkipFrame && !wait)
+                    m_skipFrame = false;
+            } else
+                sourceScript->stop(true, true);
         } else {
-            m_runningScripts.push_back(script->start());
+            auto vm = script->start();
+            m_runningScripts.push_back(vm);
+            m_runningBroadcastMap[index].push_back({ sourceScript, vm.get() });
         }
     }
 }
@@ -227,6 +264,8 @@ void Engine::run()
 
     while (true) {
         auto lastFrameTime = std::chrono::steady_clock::now();
+        m_skipFrame = false;
+
         // Execute the frame
         frame();
         if (m_runningScripts.size() <= 0)
@@ -236,17 +275,29 @@ void Engine::run()
         auto currentTime = std::chrono::steady_clock::now();
         auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - lastFrameTime);
         auto sleepTime = frameDuration - elapsedTime;
+        bool timeOut = sleepTime <= std::chrono::milliseconds::zero();
 
-        if (sleepTime > std::chrono::milliseconds::zero())
+        if (!timeOut && !m_skipFrame)
             std::this_thread::sleep_for(sleepTime);
 
+        if ((m_skipFrame && timeOut) || !m_skipFrame) {
+            // TODO: Repaint here
+        }
+
         lastFrameTime = currentTime;
     }
 }
 
-bool Engine::broadcastRunning(unsigned int index)
+bool Engine::broadcastRunning(unsigned int index, VirtualMachine *sourceScript)
 {
-    return !m_broadcastMap[index].empty();
+    const auto &scripts = m_runningBroadcastMap[index];
+
+    for (const auto &pair : scripts) {
+        if (pair.first == sourceScript)
+            return true;
+    }
+
+    return false;
 }
 
 void Engine::breakFrame()
@@ -259,6 +310,20 @@ bool libscratchcpp::Engine::breakingCurrentFrame()
     return m_breakFrame;
 }
 
+void Engine::skipFrame()
+{
+    if (!m_lockFrame) {
+        breakFrame();
+        m_skipFrame = true;
+    }
+}
+
+void Engine::lockFrame()
+{
+    m_skipFrame = false;
+    m_lockFrame = true;
+}
+
 void Engine::registerSection(std::shared_ptr<IBlockSection> section)
 {
     if (section) {
@@ -364,8 +429,13 @@ void libscratchcpp::Engine::addBroadcastScript(std::shared_ptr<Block> whenReceiv
     if (m_broadcastMap.count(id) == 1) {
         std::vector<Script *> &scripts = m_broadcastMap[id];
         scripts.push_back(m_scripts[whenReceivedBlock].get());
-    } else
+    } else {
         m_broadcastMap[id] = { m_scripts[whenReceivedBlock].get() };
+
+        // Create a vector of running scripts for this broadcast
+        // so we don't need to check if it's there
+        m_runningBroadcastMap[id] = {};
+    }
 }
 
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
diff --git a/src/engine/engine.h b/src/engine/engine.h
@@ -30,16 +30,19 @@ class Engine : public IEngine
         void start() override;
         void stop() override;
         void startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<Target> target) override;
-        void broadcast(unsigned int index, VirtualMachine *sourceScript) override;
+        void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) override;
         void stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
         void run() override;
 
-        bool broadcastRunning(unsigned int index) override;
+        bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) override;
 
         void breakFrame() override;
         bool breakingCurrentFrame() override;
 
+        void skipFrame() override;
+        void lockFrame() override;
+
         void registerSection(std::shared_ptr<IBlockSection> section) override;
         unsigned int functionIndex(BlockFunc f) override;
 
@@ -81,13 +84,16 @@ class Engine : public IEngine
         std::vector<std::shared_ptr<Target>> m_targets;
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<unsigned int, std::vector<Script *>> m_broadcastMap;
+        std::unordered_map<unsigned int, std::vector<std::pair<VirtualMachine *, VirtualMachine *>>> m_runningBroadcastMap; // source script, "when received" script
         std::vector<std::string> m_extensions;
         std::vector<std::shared_ptr<VirtualMachine>> m_runningScripts;
         std::vector<VirtualMachine *> m_scriptsToRemove;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
 
         bool m_breakFrame = false;
+        bool m_skipFrame = false;
+        bool m_lockFrame = false;
 };
 
 } // namespace libscratchcpp
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
@@ -18,16 +18,19 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, start, (), (override));
         MOCK_METHOD(void, stop, (), (override));
         MOCK_METHOD(void, startScript, (std::shared_ptr<Block>, std::shared_ptr<Target>), (override));
-        MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *), (override));
+        MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
         MOCK_METHOD(void, run, (), (override));
 
-        MOCK_METHOD(bool, broadcastRunning, (unsigned int), (override));
+        MOCK_METHOD(bool, broadcastRunning, (unsigned int, VirtualMachine *), (override));
 
         MOCK_METHOD(void, breakFrame, (), (override));
         MOCK_METHOD(bool, breakingCurrentFrame, (), (override));
 
+        MOCK_METHOD(void, skipFrame, (), (override));
+        MOCK_METHOD(void, lockFrame, (), (override));
+
         MOCK_METHOD(void, registerSection, (std::shared_ptr<IBlockSection>), (override));
         MOCK_METHOD(unsigned int, functionIndex, (BlockFunc), (override));
 

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,6 @@ unsigned int ControlBlocks::stopOtherScriptsInSprite(VirtualMachine *vm)`
`171`	`171`	`unsigned int ControlBlocks::startWait(VirtualMachine *vm)`
`172`	`172`	`{`
`173`	`173`	`auto currentTime = std::chrono::steady_clock::now();`
`174`		`- assert(m_timeMap.count(vm) == 0);`
`175`	`174`	`m_timeMap[vm] = { currentTime, vm->getInput(0, 1)->toDouble() * 1000 };`
`176`	`175`	`return 1;`
`177`	`176`	`}`
`@@ -185,6 +184,8 @@ unsigned int ControlBlocks::wait(VirtualMachine *vm)`
`185`	`184`	`vm->stop(true, true, false);`
`186`	`185`	`} else`
`187`	`186`	`vm->stop(true, true, true);`
	`187`	`+`
	`188`	`+ vm->engine()->lockFrame();`
`188`	`189`	`return 0;`
`189`	`190`	`}`
`190`	`191`