Refactor broadcasts

They now behave (almost) the same as in Scratch, but there are some details which will be fixed later.

Author: adazem009

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".

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;
 }

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);
 };

src/engine/engine.cpp

@@ -126,8 +126,19 @@ void Engine::frame()
         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 +191,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() });
         }
     }
 }
@@ -251,9 +286,16 @@ void Engine::run()
     }
 }
 
-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()
@@ -377,8 +419,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

src/engine/engine.h

@@ -30,12 +30,12 @@ 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;
@@ -83,6 +83,7 @@ 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;

test/mocks/enginemock.h

@@ -18,12 +18,12 @@ 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));