From b3feac63452bb227212659b1194d9a13d8e4929b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 28 Dec 2023 10:30:41 +0100
Subject: [PATCH 01/17] Engine: Remove running broadcasts map

---
 src/engine/internal/engine.cpp | 58 ++++++++++------------------------
 src/engine/internal/engine.h   |  5 ++-
 2 files changed, 19 insertions(+), 44 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index b85d4876..ca148fd9 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -205,22 +205,17 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
 void Engine::broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait)
 {
     const std::vector<Script *> &scripts = m_broadcastMap[broadcast];
-    auto &runningBroadcasts = m_runningBroadcastMap[broadcast];
 
-    for (auto script : scripts) {
-        for (auto &pair : runningBroadcasts) {
-            if (pair.second->script() == script)
-                pair.first = sourceScript;
-        }
+    for (const auto &[target, targetScripts] : m_runningScripts) {
+        for (auto vm : targetScripts) {
+            auto it = std::find_if(scripts.begin(), scripts.end(), [vm](Script *script) { return vm->script() == script; });
 
-        if (script == sourceScript->script())
-            sourceScript->stop(false, !wait); // source script is the broadcast script
+            if (it != scripts.end() && *it == sourceScript->script())
+                sourceScript->stop(false, !wait); // source script is the broadcast script
+        }
     }
 
-    std::vector<VirtualMachine *> startedScripts = startHats(scripts);
-
-    for (VirtualMachine *vm : startedScripts)
-        runningBroadcasts.push_back({ sourceScript, vm });
+    startHats(scripts);
 }
 
 void Engine::stopScript(VirtualMachine *vm)
@@ -448,20 +443,6 @@ void Engine::runScripts(const TargetScriptMap &scriptMap, TargetScriptMap &globa
                 break;
             }
         }
-
-        // Remove from m_runningBroadcastMap
-        for (auto &[broadcast, pairs] : m_runningBroadcastMap) {
-            size_t index = 0;
-
-            for (const auto &pair : pairs) {
-                if (pair.second == script) {
-                    pairs.erase(pairs.begin() + index);
-                    break;
-                }
-
-                index++;
-            }
-        }
     }
     m_scriptsToRemove.clear();
 }
@@ -642,16 +623,16 @@ bool Engine::broadcastRunning(unsigned int index, VirtualMachine *sourceScript)
 
 bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript)
 {
-    auto it = m_runningBroadcastMap.find(broadcast);
+    assert(m_broadcastMap.find(broadcast) != m_broadcastMap.cend());
+    const auto &scripts = m_broadcastMap[broadcast];
 
-    if (it == m_runningBroadcastMap.cend())
-        return false;
+    for (const auto &[target, targetScripts] : m_runningScripts) {
+        for (auto vm : targetScripts) {
+            auto it = std::find_if(scripts.begin(), scripts.end(), [vm](Script *script) { return vm->script() == script; });
 
-    const auto &scripts = it->second;
-
-    for (const auto &pair : scripts) {
-        if (pair.first == sourceScript)
-            return true;
+            if (it != scripts.end())
+                return true;
+        }
     }
 
     return false;
@@ -790,13 +771,8 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadc
         std::vector<Script *> &scripts = m_broadcastMap[broadcast];
         // TODO: Do not allow adding existing scripts
         scripts.push_back(m_scripts[whenReceivedBlock].get());
-    } else {
+    } else
         m_broadcastMap[broadcast] = { 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[broadcast] = {};
-    }
 }
 
 void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
@@ -1238,7 +1214,7 @@ std::vector<VirtualMachine *> Engine::startHats(const std::vector<Script *> &scr
         for (VirtualMachine *vm : runningScripts) {
             vm->reset();
 
-            // Remove the script from scripts to remove because it's going to run again
+            // Remove the script from scripts to remove and running broadcast map because it's going to run again
             m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm), m_scriptsToRemove.end());
             assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end());
         }
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index a04c158b..32eb1d64 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -161,9 +161,8 @@ class Engine : public IEngine
         std::vector<std::shared_ptr<Target>> m_targets;
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<Broadcast *, std::vector<Script *>> m_broadcastMap;
-        std::unordered_map<Broadcast *, std::vector<std::pair<VirtualMachine *, VirtualMachine *>>> m_runningBroadcastMap; // source script, "when received" script
-        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;                                         // target (no clones), "when I start as a clone" scripts
-        std::unordered_map<std::string, std::vector<Script *>> m_whenKeyPressedScripts;                                    // key name, "when key pressed" scripts
+        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;      // target (no clones), "when I start as a clone" scripts
+        std::unordered_map<std::string, std::vector<Script *>> m_whenKeyPressedScripts; // key name, "when key pressed" scripts
         std::vector<std::string> m_extensions;
         std::vector<Target *> m_executableTargets; // sorted by layer (reverse order of execution)
         TargetScriptMap m_runningScripts;

From fb311bf93547371a0133ea0bcd29844c9445d155 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 01:44:47 +0100
Subject: [PATCH 02/17] Add kill method to VirtualMachine

---
 include/scratchcpp/virtualmachine.h           |  1 +
 src/engine/virtualmachine.cpp                 |  7 +++++++
 test/virtual_machine/virtual_machine_test.cpp | 10 +++++++++-
 3 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/virtualmachine.h b/include/scratchcpp/virtualmachine.h
index 3789e8f5..c00a0996 100644
--- a/include/scratchcpp/virtualmachine.h
+++ b/include/scratchcpp/virtualmachine.h
@@ -128,6 +128,7 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         void replaceReturnValue(const Value &v, unsigned int offset);
 
         void run();
+        void kill();
         void reset();
         void moveToLastCheckpoint();
 
diff --git a/src/engine/virtualmachine.cpp b/src/engine/virtualmachine.cpp
index 24a01de1..46f6fa5f 100644
--- a/src/engine/virtualmachine.cpp
+++ b/src/engine/virtualmachine.cpp
@@ -175,6 +175,13 @@ void VirtualMachine::run()
     impl->running = false;
 }
 
+/*! Stops the execution and sets atEnd to true. */
+void VirtualMachine::kill()
+{
+    reset();
+    impl->atEnd = true;
+}
+
 /*! Jumps back to the initial position. */
 void VirtualMachine::reset()
 {
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index e4f4aeb8..307dc5a4 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -1590,7 +1590,7 @@ TEST(VirtualMachineTest, OP_WARP)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
-TEST(VirtualMachineTest, Reset)
+TEST(VirtualMachineTest, ResetAndKill)
 {
     static unsigned int bytecode1[] = { OP_START, OP_NULL, OP_EXEC, 0, OP_HALT };
     static unsigned int bytecode2[] = { OP_START, OP_NULL, OP_EXEC, 1, OP_HALT };
@@ -1629,6 +1629,14 @@ TEST(VirtualMachineTest, Reset)
 
     vm.reset();
     ASSERT_FALSE(vm.atEnd());
+
+    // kill()
+    vm.run();
+    ASSERT_FALSE(vm.atEnd());
+    ASSERT_EQ(vm.registerCount(), 1);
+    vm.kill();
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_TRUE(vm.atEnd());
 }
 
 TEST(VirtualMachineTest, NoCrashWhenRepeatingZeroTimes)

From 81c62109c5a1fc3283d47510f139074a7cb347ef Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 13:40:44 +0100
Subject: [PATCH 03/17] Set the name of backdrop broadcasts

---
 src/scratch/costume.cpp      | 1 +
 test/assets/costume_test.cpp | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/scratch/costume.cpp b/src/scratch/costume.cpp
index b24da79f..df32fb35 100644
--- a/src/scratch/costume.cpp
+++ b/src/scratch/costume.cpp
@@ -12,6 +12,7 @@ Costume::Costume(const std::string &name, const std::string &id, const std::stri
     Asset(name, id, format),
     impl(spimpl::make_unique_impl<CostumePrivate>())
 {
+    impl->broadcast.setName(name);
 }
 
 /*! Returns the reciprocal of the costume scaling factor for bitmap costumes. */
diff --git a/test/assets/costume_test.cpp b/test/assets/costume_test.cpp
index 94a8a734..7f53e602 100644
--- a/test/assets/costume_test.cpp
+++ b/test/assets/costume_test.cpp
@@ -55,5 +55,5 @@ TEST_F(CostumeTest, Broadcast)
     Broadcast *broadcast = costume.broadcast();
     ASSERT_TRUE(broadcast);
     ASSERT_TRUE(broadcast->id().empty());
-    ASSERT_TRUE(broadcast->name().empty());
+    ASSERT_EQ(broadcast->name(), "costume1");
 }

From 2bc7038c362367f8ad1550c34fe1d7a8988acaa2 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 15:29:43 +0100
Subject: [PATCH 04/17] Rewrite the event loop

---
 include/scratchcpp/iengine.h      |   3 +
 src/blocks/looksblocks.cpp        |  10 +-
 src/engine/internal/engine.cpp    | 637 +++++++++++++++++-------------
 src/engine/internal/engine.h      |  43 +-
 test/2_frames.sb3                 | Bin 932 -> 924 bytes
 test/blocks/looks_blocks_test.cpp | 262 +++++++-----
 test/clone_limit.sb3              | Bin 2364 -> 2331 bytes
 test/engine/engine_test.cpp       |  90 +++--
 test/mocks/enginemock.h           |   1 +
 9 files changed, 607 insertions(+), 439 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 7306a2c5..b9468a00 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -62,6 +62,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Starts the script of the given broadcast. */
         virtual void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) = 0;
 
+        /*! Starts the "when backdrop switches to" scripts for the given backdrop broadcast. */
+        virtual void startBackdropScripts(Broadcast *broadcast) = 0;
+
         /*! Stops the given script. */
         virtual void stopScript(VirtualMachine *vm) = 0;
 
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index eee69eef..18cca774 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -388,6 +388,7 @@ void LooksBlocks::compileSwitchBackdropToAndWait(Compiler *compiler)
         compiler->addFunctionCall(&switchBackdropToAndWait);
     }
 
+    compiler->addFunctionCall(&backdropNumber);
     compiler->addFunctionCall(&checkBackdropScripts);
 }
 
@@ -750,7 +751,7 @@ void LooksBlocks::startBackdropScripts(VirtualMachine *vm, bool wait)
 {
     if (Stage *stage = vm->engine()->stage()) {
         if (stage->costumes().size() > 0)
-            vm->engine()->broadcastByPtr(stage->currentCostume()->broadcast(), vm, wait);
+            vm->engine()->startBackdropScripts(stage->currentCostume()->broadcast());
     }
 }
 
@@ -894,11 +895,14 @@ unsigned int LooksBlocks::randomBackdropAndWait(VirtualMachine *vm)
 unsigned int LooksBlocks::checkBackdropScripts(VirtualMachine *vm)
 {
     if (Stage *stage = vm->engine()->stage()) {
-        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->currentCostume()->broadcast(), vm))
+        long index = vm->getInput(0, 1)->toLong() - 1;
+        assert(stage->costumes().size() == 0 || index >= 0);
+
+        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->costumeAt(index)->broadcast(), vm))
             vm->stop(true, true, true);
     }
 
-    return 0;
+    return 1;
 }
 
 unsigned int LooksBlocks::goToFront(VirtualMachine *vm)
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index ca148fd9..f896d970 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -23,10 +23,19 @@
 #include "blocksectioncontainer.h"
 #include "timer.h"
 #include "clock.h"
-#include "../../blocks/standardblocks.h"
+#include "blocks/standardblocks.h"
+#include "blocks/eventblocks.h"
 
 using namespace libscratchcpp;
 
+const std::unordered_map<Engine::HatType, bool> Engine::m_hatRestartExistingThreads = {
+    { HatType::GreenFlag, true },
+    { HatType::BroadcastReceived, true },
+    { HatType::BackdropChanged, true },
+    { HatType::CloneInit, false },
+    { HatType::KeyPressed, false }
+};
+
 Engine::Engine() :
     m_defaultTimer(std::make_unique<Timer>()),
     m_timer(m_defaultTimer.get()),
@@ -156,42 +165,34 @@ void Engine::start()
     m_timer->reset();
     m_running = true;
 
-    for (auto target : m_targets) {
-        auto gfBlocks = target->greenFlagBlocks();
-        for (auto block : gfBlocks)
-            startScript(block, target.get());
-    }
+    // Start "when green flag clicked" scripts
+    startHats(HatType::GreenFlag, {}, nullptr);
 
     m_eventLoopMutex.unlock();
 }
 
 void Engine::stop()
 {
-    finalize();
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L2057-L2081
     deleteClones();
+
+    if (m_activeThread) {
+        stopThread(m_activeThread.get());
+        // NOTE: The project should continue running even after "stop all" is called and the remaining threads should be stepped once.
+        // The remaining threads can even start new threads which will ignore the "stop all" call and will "restart" the project.
+        // This is probably a bug in the Scratch VM, but let's keep it here to keep it compatible.
+        m_threadsToStop = m_threads;
+    } else {
+        // If there isn't any active thread, it means the project was stopped from the outside
+        // In this case all threads should be removed and the project should be considered stopped
+        m_threads.clear();
+        m_running = false;
+    }
 }
 
 VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
 {
-    if (!topLevelBlock) {
-        std::cout << "warning: starting a script with a null top level block (nothing will happen)" << std::endl;
-        return nullptr;
-    }
-
-    if (!target) {
-        std::cout << "error: scripts must be started by a target";
-        assert(false);
-        return nullptr;
-    }
-
-    if (topLevelBlock->next()) {
-        auto script = m_scripts[topLevelBlock];
-        std::shared_ptr<VirtualMachine> vm = script->start(target);
-        addRunningScript(vm);
-        return vm.get();
-    }
-
-    return nullptr;
+    return pushThread(topLevelBlock, target).get();
 }
 
 void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait)
@@ -204,39 +205,30 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
 
 void Engine::broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait)
 {
-    const std::vector<Script *> &scripts = m_broadcastMap[broadcast];
-
-    for (const auto &[target, targetScripts] : m_runningScripts) {
-        for (auto vm : targetScripts) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), [vm](Script *script) { return vm->script() == script; });
-
-            if (it != scripts.end() && *it == sourceScript->script())
-                sourceScript->stop(false, !wait); // source script is the broadcast script
-        }
-    }
+    startHats(HatType::BroadcastReceived, { { EventBlocks::Fields::BROADCAST_OPTION, broadcast->name() } }, nullptr);
+}
 
-    startHats(scripts);
+void Engine::startBackdropScripts(Broadcast *broadcast)
+{
+    startHats(HatType::BackdropChanged, { { EventBlocks::Fields::BACKDROP, broadcast->name() } }, nullptr);
 }
 
 void Engine::stopScript(VirtualMachine *vm)
 {
-    assert(vm);
-    if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end())
-        m_scriptsToRemove.push_back(vm);
+    stopThread(vm);
 }
 
 void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
 {
-    const auto &targetScripts = m_runningScripts[target];
-    std::vector<VirtualMachine *> scripts;
+    std::vector<VirtualMachine *> threads;
 
-    for (auto script : targetScripts) {
-        if ((script->target() == target) && (script.get() != exceptScript))
-            scripts.push_back(script.get());
+    for (auto thread : m_threads) {
+        if ((thread->target() == target) && (thread.get() != exceptScript))
+            threads.push_back(thread.get());
     }
 
-    for (auto script : scripts)
-        stopScript(script);
+    for (auto thread : threads)
+        stopThread(thread);
 }
 
 void Engine::initClone(std::shared_ptr<Sprite> clone)
@@ -250,24 +242,13 @@ void Engine::initClone(std::shared_ptr<Sprite> clone)
     if (!root)
         return;
 
-    auto it = m_cloneInitScriptsMap.find(root);
-
-    if (it != m_cloneInitScriptsMap.cend()) {
-        const auto &scripts = it->second;
-
 #ifndef NDEBUG
-        // Since we're initializing the clone, it shouldn't have any running scripts
-        for (const auto &[target, targetScripts] : m_runningScripts) {
-            for (const auto script : targetScripts)
-                assert((target != clone.get()) || (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) != m_scriptsToRemove.end()));
-        }
+    // Since we're initializing the clone, it shouldn't have any running scripts
+    for (auto thread : m_threads)
+        assert(thread->target() != clone.get() || thread->atEnd());
 #endif
 
-        for (auto script : scripts) {
-            auto vm = script->start(clone.get());
-            addRunningScript(vm);
-        }
-    }
+    startHats(HatType::CloneInit, {}, clone.get());
 
     assert(std::find(m_clones.begin(), m_clones.end(), clone) == m_clones.end());
     assert(std::find(m_executableTargets.begin(), m_executableTargets.end(), clone.get()) == m_executableTargets.end());
@@ -305,146 +286,129 @@ void Engine::setRedrawHandler(const std::function<void()> &handler)
     m_redrawHandler = handler;
 }
 
-void Engine::eventLoop(bool untilProjectStops)
+void Engine::step()
 {
-    updateFrameDuration();
-    m_newScripts.clear();
-    m_stopEventLoop = false;
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L2087C6-L2155
 
-    while (true) {
-        auto frameStart = m_clock->currentSteadyTime();
-        std::chrono::steady_clock::time_point currentTime;
-        std::chrono::milliseconds elapsedTime, sleepTime;
-        m_redrawRequested = false;
-        bool timeout = false;
-        bool stop = false;
-        // TODO: Avoid copying by passing current size to runScripts()
-        TargetScriptMap scripts = m_runningScripts; // this must be copied (for now)
-
-        do {
-            m_eventLoopMutex.lock();
-            m_scriptsToRemove.clear();
-
-            // Execute new scripts from last frame
-            runScripts(m_newScripts, scripts);
-
-            // Execute all running scripts
-            m_newScripts.clear();
-            runScripts(scripts, scripts);
-
-            // Stop the event loop if the project has finished running (and untilProjectStops is set to true)
-            if (untilProjectStops) {
-                bool empty = true;
-
-                for (const auto &pair : m_runningScripts) {
-                    if (!pair.second.empty()) {
-                        empty = false;
-                        m_eventLoopMutex.unlock();
-                        break;
-                    }
-                }
+    // Clean up threads that were told to stop during or since the last step
+    m_threads.erase(std::remove_if(m_threads.begin(), m_threads.end(), [](std::shared_ptr<VirtualMachine> thread) { return thread->atEnd(); }), m_threads.end());
 
-                if (empty) {
-                    stop = true;
-                    m_eventLoopMutex.unlock();
-                    break;
-                }
-            }
+    m_redrawRequested = false;
 
-            // Stop the event loop if stopEventLoop() was called
-            m_stopEventLoopMutex.lock();
+    // Step threads
+    stepThreads();
 
-            if (m_stopEventLoop) {
-                stop = true;
-                m_eventLoopMutex.unlock();
-                break;
-            }
+    // Render
+    if (m_redrawHandler)
+        m_redrawHandler();
+}
 
-            m_stopEventLoopMutex.unlock();
+std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L70-L173
+    const double WORK_TIME = 0.75 * m_frameDuration.count(); // 75% of frame duration
+    assert(WORK_TIME > 0);
+    auto stepStart = m_clock->currentSteadyTime();
 
-            currentTime = m_clock->currentSteadyTime();
-            elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - frameStart);
-            sleepTime = m_frameDuration - elapsedTime;
-            timeout = sleepTime <= std::chrono::milliseconds::zero();
-            m_eventLoopMutex.unlock();
-        } while (!((m_redrawRequested && !m_turboModeEnabled) || timeout || stop));
+    size_t numActiveThreads = 1; // greater than zero
+    std::vector<std::shared_ptr<VirtualMachine>> doneThreads;
 
-        if (stop)
-            break;
+    auto elapsedTime = [this, &stepStart]() {
+        std::chrono::steady_clock::time_point currentTime = m_clock->currentSteadyTime();
+        std::chrono::milliseconds elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - stepStart);
+        return elapsedTime.count();
+    };
 
-        // Redraw
-        if (m_redrawHandler)
-            m_redrawHandler();
+    while (!m_threads.empty() && numActiveThreads > 0 && elapsedTime() < WORK_TIME && (m_turboModeEnabled || !m_redrawRequested)) {
+        numActiveThreads = 0;
 
-        // If the timeout hasn't been reached yet (redraw was requested), sleep
-        if (!timeout)
-            m_clock->sleep(sleepTime);
-    }
+        // Attempt to run each thread one time
+        for (int i = 0; i < m_threads.size(); i++) {
+            assert(i >= 0 && i < m_threads.size());
+            m_activeThread = m_threads[i];
 
-    finalize();
-}
+            // Check if the thread is done so it is not executed
+            if (m_activeThread->atEnd()) {
+                // Finished with this thread
+                continue;
+            }
 
-void Engine::runScripts(const TargetScriptMap &scriptMap, TargetScriptMap &globalScriptMap)
-{
-    // globalScriptMap is used to remove "scripts to remove" from it so that they're removed from the correct list
-    for (int i = m_executableTargets.size() - 1; i >= 0; i--) {
-        auto it = scriptMap.find(m_executableTargets[i]);
+            stepThread(m_activeThread);
 
-        if ((it == scriptMap.cend()) || it->second.empty())
-            continue; // skip the target if it doesn't have any running script
+            if (!m_activeThread->atEnd())
+                numActiveThreads++;
+        }
 
-        const auto &scripts = it->second;
+        // Remove threads in m_threadsToStop
+        for (auto thread : m_threadsToStop)
+            m_threads.erase(std::remove(m_threads.begin(), m_threads.end(), thread), m_threads.end());
+
+        // Remove inactive threads (and add them to doneThreads)
+        m_threads.erase(
+            std::remove_if(
+                m_threads.begin(),
+                m_threads.end(),
+                [&doneThreads](std::shared_ptr<VirtualMachine> thread) {
+                    if (thread->atEnd()) {
+                        doneThreads.push_back(thread);
+                        return true;
+                    } else
+                        return false;
+                }),
+            m_threads.end());
+    }
 
-        for (int i = 0; i < scripts.size(); i++) {
-            auto script = scripts[i];
-            assert(script);
+    if (m_threads.empty())
+        m_running = false;
 
-            if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) != m_scriptsToRemove.end())
-                continue; // skip the script if it is scheduled to be removed
+    m_activeThread = nullptr;
+    return doneThreads;
+}
 
-            script->run();
+void Engine::stepThread(std::shared_ptr<VirtualMachine> thread)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L179-L276
+    thread->run();
+}
 
-            if (script->atEnd() && m_running) {
-                if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) == m_scriptsToRemove.end())
-                    m_scriptsToRemove.push_back(script.get());
-            }
-        }
-    }
+void Engine::eventLoop(bool untilProjectStops)
+{
+    updateFrameDuration();
+    m_stopEventLoop = false;
 
-    assert(m_running || m_scriptsToRemove.empty());
+    while (true) {
+        auto tickStart = m_clock->currentSteadyTime();
+        m_eventLoopMutex.lock();
+        step();
 
-    for (auto script : m_scriptsToRemove) {
-        auto pred = [script](std::shared_ptr<VirtualMachine> vm) { return vm.get() == script; };
-#ifndef NDEBUG
-        bool found = false;
-#endif
+        // Stop the event loop if the project has finished running (and untilProjectStops is set to true)
+        if (untilProjectStops && m_threads.empty()) {
+            m_eventLoopMutex.unlock();
+            break;
+        }
 
-        // Remove from m_runningScripts
-        for (auto &[target, scripts] : m_runningScripts) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), pred);
+        // Stop the event loop if stopEventLoop() was called
+        m_stopEventLoopMutex.lock();
 
-            if (it != scripts.end()) {
-                scripts.erase(it);
-#ifndef NDEBUG
-                found = true;
-#endif
-                break;
-            }
+        if (m_stopEventLoop) {
+            m_stopEventLoopMutex.unlock();
+            m_eventLoopMutex.unlock();
+            break;
         }
 
-        assert(found);
+        m_stopEventLoopMutex.unlock();
 
-        // Remove from globalScriptMap
-        for (auto &[target, scripts] : globalScriptMap) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), pred);
+        std::chrono::steady_clock::time_point currentTime = m_clock->currentSteadyTime();
+        std::chrono::milliseconds elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - tickStart);
+        std::chrono::milliseconds sleepTime = m_frameDuration - elapsedTime;
+        m_eventLoopMutex.unlock();
 
-            if (it != scripts.end()) {
-                scripts.erase(it);
-                break;
-            }
-        }
+        // If there's any time left, sleep
+        if (sleepTime > std::chrono::milliseconds::zero())
+            m_clock->sleep(sleepTime);
     }
-    m_scriptsToRemove.clear();
+
+    finalize();
 }
 
 bool Engine::isRunning() const
@@ -508,15 +472,8 @@ void Engine::setKeyState(const KeyEvent &event, bool pressed)
 
     // Start "when key pressed" scripts
     if (pressed) {
-        auto it = m_whenKeyPressedScripts.find(event.name());
-
-        if (it != m_whenKeyPressedScripts.cend())
-            startHats(it->second);
-
-        it = m_whenKeyPressedScripts.find("any");
-
-        if (it != m_whenKeyPressedScripts.cend())
-            startHats(it->second);
+        startHats(HatType::KeyPressed, { { EventBlocks::Fields::KEY_OPTION, event.name() } }, nullptr);
+        startHats(HatType::KeyPressed, { { EventBlocks::Fields::KEY_OPTION, "any" } }, nullptr);
     }
 }
 
@@ -525,12 +482,8 @@ void Engine::setAnyKeyPressed(bool pressed)
     m_anyKeyPressed = pressed;
 
     // Start "when key pressed" scripts
-    if (pressed) {
-        auto it = m_whenKeyPressedScripts.find("any");
-
-        if (it != m_whenKeyPressedScripts.cend())
-            startHats(it->second);
-    }
+    if (pressed)
+        startHats(HatType::KeyPressed, { { EventBlocks::Fields::KEY_OPTION, "any" } }, nullptr);
 }
 
 double Engine::mouseX() const
@@ -626,15 +579,31 @@ bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceS
     assert(m_broadcastMap.find(broadcast) != m_broadcastMap.cend());
     const auto &scripts = m_broadcastMap[broadcast];
 
-    for (const auto &[target, targetScripts] : m_runningScripts) {
-        for (auto vm : targetScripts) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), [vm](Script *script) { return vm->script() == script; });
+    for (auto thread : m_threads) {
+        if (!thread->atEnd()) {
+            auto it = std::find_if(scripts.begin(), scripts.end(), [thread](Script *script) { return thread->script() == script; });
 
             if (it != scripts.end())
                 return true;
         }
     }
 
+    // TODO: Check whether the broadcast belongs to a backdrop
+    // maybe using something like broadcast->isBackdropBroadcast()
+    // after adding it to Broadcast
+    for (auto thread : m_threads) {
+        if (!thread->atEnd()) {
+            // TODO: Store the top block in Script
+            Script *script = thread->script();
+            auto it = std::find_if(m_scripts.begin(), m_scripts.end(), [script](const std::pair<std::shared_ptr<Block>, std::shared_ptr<Script>> pair) { return pair.second.get() == script; });
+            assert(it != m_scripts.end());
+            auto topBlock = it->first;
+
+            // TODO: Add a map for "when backdrop switches to" hats
+            if ((topBlock->opcode() == "event_whenbackdropswitchesto") && (topBlock->findFieldById(EventBlocks::BACKDROP)->value().toString() == broadcast->name()))
+                return true;
+        }
+    }
     return false;
 }
 
@@ -767,44 +736,30 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
 
 void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast)
 {
-    if (m_broadcastMap.count(broadcast) == 1) {
-        std::vector<Script *> &scripts = m_broadcastMap[broadcast];
-        // TODO: Do not allow adding existing scripts
-        scripts.push_back(m_scripts[whenReceivedBlock].get());
+    Script *script = m_scripts[whenReceivedBlock].get();
+    auto it = m_broadcastMap.find(broadcast);
+
+    if (it != m_broadcastMap.cend()) {
+        auto &scripts = it->second;
+        auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+
+        if (scriptIt == scripts.end())
+            scripts.push_back(script);
     } else
-        m_broadcastMap[broadcast] = { m_scripts[whenReceivedBlock].get() };
+        m_broadcastMap[broadcast] = { script };
+
+    addHatToMap(m_broadcastHats, script);
 }
 
 void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
 {
-    Target *target = hatBlock->target();
-    Script *script = m_scripts[hatBlock].get();
-    auto it = m_cloneInitScriptsMap.find(target);
-
-    if (it == m_cloneInitScriptsMap.cend())
-        m_cloneInitScriptsMap[target] = { script };
-    else {
-        auto &scripts = it->second;
-
-        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
-            scripts.push_back(script);
-    }
+    addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
 }
 
 void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName)
 {
     std::transform(keyName.begin(), keyName.end(), keyName.begin(), ::tolower);
-    Script *script = m_scripts[hatBlock].get();
-    auto it = m_whenKeyPressedScripts.find(keyName);
-
-    if (it == m_whenKeyPressedScripts.cend())
-        m_whenKeyPressedScripts[keyName] = { script };
-    else {
-        auto &scripts = it->second;
-
-        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
-            scripts.push_back(script);
-    }
+    addHatToMap(m_whenKeyPressedHats, m_scripts[hatBlock].get());
 }
 
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
@@ -1097,6 +1052,83 @@ std::shared_ptr<IBlockSection> Engine::blockSection(const std::string &opcode) c
     return nullptr;
 }
 
+void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script)
+{
+    assert(script);
+    assert(script->target());
+    Target *target = script->target();
+    auto it = map.find(target);
+
+    if (it != map.cend()) {
+        auto &scripts = it->second;
+        auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+
+        if (scriptIt == scripts.end())
+            scripts.push_back(script);
+    } else
+        map[target] = { script };
+}
+
+std::vector<Script *> Engine::getHats(Target *target, HatType type)
+{
+    assert(target);
+
+    // Get root if this is a clone
+    if (!target->isStage()) {
+        Sprite *sprite = dynamic_cast<Sprite *>(target);
+        assert(sprite);
+
+        if (sprite->isClone())
+            target = sprite->cloneSprite();
+    }
+
+    switch (type) {
+        case HatType::GreenFlag: {
+            // TODO: Add a map for green flag hats and return reference
+            std::vector<Script *> out;
+            const auto &blocks = target->blocks();
+
+            for (auto block : blocks) {
+                if (block->opcode() == "event_whenflagclicked") {
+                    assert(block->topLevel());
+                    assert(m_scripts.find(block) != m_scripts.cend());
+                    out.push_back(m_scripts[block].get());
+                }
+            }
+
+            return out;
+        }
+
+        case HatType::BroadcastReceived:
+            return m_broadcastHats[target];
+
+        case HatType::BackdropChanged: {
+            // TODO: Add a map for "when backdrop switches to" hats and return reference
+            std::vector<Script *> out;
+            const auto &blocks = target->blocks();
+
+            for (auto block : blocks) {
+                if (block->opcode() == "event_whenbackdropswitchesto") {
+                    assert(block->topLevel());
+                    assert(m_scripts.find(block) != m_scripts.cend());
+                    out.push_back(m_scripts[block].get());
+                }
+            }
+
+            return out;
+        }
+
+        case HatType::CloneInit:
+            return m_cloneInitHats[target];
+
+        case HatType::KeyPressed:
+            return m_whenKeyPressedHats[target];
+
+        default:
+            return {};
+    }
+}
+
 void Engine::updateSpriteLayerOrder()
 {
     assert(m_executableTargets.empty() || m_executableTargets[0]->isStage());
@@ -1132,8 +1164,7 @@ BlockSectionContainer *Engine::blockSectionContainer(IBlockSection *section) con
 void Engine::finalize()
 {
     m_eventLoopMutex.lock();
-    m_runningScripts.clear();
-    m_scriptsToRemove.clear();
+    m_threads.clear();
     m_running = false;
     m_redrawRequested = false;
     m_eventLoopMutex.unlock();
@@ -1175,86 +1206,128 @@ void Engine::updateFrameDuration()
 
 void Engine::addRunningScript(std::shared_ptr<VirtualMachine> vm)
 {
-    Target *target = vm->target();
-    assert(vm->target());
-    auto it1 = m_runningScripts.find(target);
-    auto it2 = m_newScripts.find(target);
+    m_threads.push_back(vm);
+}
 
-    if (it1 == m_runningScripts.cend())
-        m_runningScripts[target] = { vm };
-    else {
-        assert(std::find(it1->second.begin(), it1->second.end(), vm) == it1->second.end());
-        it1->second.push_back(vm);
+std::shared_ptr<VirtualMachine> Engine::pushThread(std::shared_ptr<Block> block, Target *target)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1649-L1661
+    if (!block) {
+        std::cerr << "error: tried to start a script with a null block" << std::endl;
+        assert(false);
+        return nullptr;
     }
 
-    if (it2 == m_newScripts.cend())
-        m_newScripts[target] = { vm };
-    else {
-        assert(std::find(it2->second.begin(), it2->second.end(), vm) == it2->second.end());
-        it2->second.push_back(vm);
+    if (!target) {
+        std::cerr << "error: scripts must be started by a target" << std::endl;
+        assert(false);
+        return nullptr;
     }
+
+    auto script = m_scripts[block];
+    std::shared_ptr<VirtualMachine> vm = script->start(target);
+    addRunningScript(vm);
+    return vm;
 }
 
-std::vector<VirtualMachine *> Engine::startHats(const std::vector<Script *> &scripts)
+void Engine::stopThread(VirtualMachine *thread)
 {
-    std::vector<VirtualMachine *> startedScripts;
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1667-L1672
+    assert(thread);
+    thread->kill();
+}
 
-    for (auto script : scripts) {
-        std::vector<VirtualMachine *> runningScripts;
+std::shared_ptr<VirtualMachine> Engine::restartThread(std::shared_ptr<VirtualMachine> thread)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1681C30-L1694
+    std::shared_ptr<VirtualMachine> newThread = thread->script()->start(thread->target());
+    auto it = std::find(m_threads.begin(), m_threads.end(), thread);
 
-        for (const auto &[target, targetScripts] : m_runningScripts) {
-            for (auto vm : targetScripts) {
-                if (vm->script() == script) {
-                    runningScripts.push_back(vm.get());
-                }
-            }
-        }
+    if (it != m_threads.end()) {
+        auto i = it - m_threads.begin();
+        m_threads[i] = newThread;
+        return newThread;
+    }
 
-        // Reset running scripts
-        for (VirtualMachine *vm : runningScripts) {
-            vm->reset();
+    addRunningScript(thread);
+    return thread;
+}
 
-            // Remove the script from scripts to remove and running broadcast map because it's going to run again
-            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm), m_scriptsToRemove.end());
-            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end());
-        }
+template<typename F>
+void Engine::allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1797-L1809
+    std::vector<Target *> *targetsPtr = &m_executableTargets;
 
-        // Start scripts which are not running
-        Target *root = script->target();
-        std::vector<Target *> targets = { root };
+    if (optTarget)
+        targetsPtr = new std::vector<Target *>({ optTarget });
 
-        if (!root->isStage()) {
-            Sprite *sprite = dynamic_cast<Sprite *>(root);
-            assert(sprite);
-            assert(!sprite->isClone());
-            const auto &children = sprite->clones();
+    const std::vector<Target *> targets = *targetsPtr;
 
-            for (auto child : children)
-                targets.push_back(child.get());
-        }
+    for (int t = targets.size() - 1; t >= 0; t--) {
+        Target *target = targets[t];
+        const auto &scripts = getHats(target, hatType);
+
+        for (size_t j = 0; j < scripts.size(); j++)
+            f(scripts[j], target);
+    }
+
+    if (optTarget)
+        delete targetsPtr;
+}
+
+std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType, const std::unordered_map<int, std::string> &optMatchFields, Target *optTarget)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1818-L1889
+    std::vector<std::shared_ptr<VirtualMachine>> newThreads;
 
-        for (Target *target : targets) {
-            std::shared_ptr<Block> block = nullptr;
+    allScriptsByOpcodeDo(
+        hatType,
+        [this, hatType, &optMatchFields, &newThreads](Script *script, Target *target) {
+            // TODO: Store the top block in Script
+            auto it = std::find_if(m_scripts.begin(), m_scripts.end(), [script](const std::pair<std::shared_ptr<Block>, std::shared_ptr<Script>> pair) { return pair.second.get() == script; });
+            assert(it != m_scripts.end());
+            auto topBlock = it->first;
 
-            if (!runningScripts.empty()) {
-                auto it = std::find_if(runningScripts.begin(), runningScripts.end(), [target, script](VirtualMachine *vm) { return (vm->target() == target) && (vm->script() == script); });
+            // Match any requested fields
+            for (const auto &[fieldId, fieldValue] : optMatchFields) {
+                assert(fieldId > -1);
+                assert(topBlock->findFieldById(fieldId));
 
-                if (it != runningScripts.end())
-                    continue; // skip the script because it was already running and was reset
+                if (topBlock->findFieldById(fieldId)->value().toString() != fieldValue) {
+                    // Field mismatch
+                    return;
+                }
             }
 
-            for (const auto &[b, s] : m_scripts) {
-                if (s.get() == script) {
-                    block = b;
-                    break;
+            if (m_hatRestartExistingThreads.at(hatType)) {
+                // Restart existing threads
+                for (auto thread : m_threads) {
+                    if (thread->target() == target && thread->script() == script) {
+                        newThreads.push_back(restartThread(thread));
+                        return;
+                    }
+                }
+            } else {
+                // Give up if any threads with the top block are running
+                for (auto thread : m_threads) {
+                    if (thread->target() == target && thread->script() == script && !thread->atEnd()) {
+                        // Some thread is already running
+                        return;
+                    }
                 }
             }
 
-            assert(block);
-            assert(std::find_if(m_targets.begin(), m_targets.end(), [script](std::shared_ptr<Target> target) { return script->target() == target.get(); }) != m_targets.end());
-            startedScripts.push_back(startScript(block, target));
-        }
-    }
+            // Start the thread with this top block
+            newThreads.push_back(pushThread(topBlock, target));
+        },
+        optTarget);
+
+    // Run edge-triggered hats (for compatibility with Scratch 2)
+    // TODO: Find out what "edge-triggered" hats are and execute them
+    // Uncommenting this would cause infinite recursion in some cases, so let's keep it commented
+    /*for (auto thread : newThreads)
+        thread->run();*/
 
-    return startedScripts;
+    return newThreads;
 }
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 32eb1d64..ac2a7ffd 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -35,6 +35,7 @@ class Engine : public IEngine
         VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *target) override;
         void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) override;
         void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) override;
+        void startBackdropScripts(Broadcast *broadcast) override;
         void stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
         void initClone(std::shared_ptr<Sprite> clone) override;
@@ -136,10 +137,19 @@ class Engine : public IEngine
         IClock *m_clock = nullptr;
 
     private:
-        using TargetScriptMap = std::unordered_map<Target *, std::vector<std::shared_ptr<VirtualMachine>>>;
-
+        enum class HatType
+        {
+            GreenFlag,
+            BroadcastReceived,
+            BackdropChanged,
+            CloneInit,
+            KeyPressed
+        };
+
+        void step();
+        std::vector<std::shared_ptr<VirtualMachine>> stepThreads();
+        void stepThread(std::shared_ptr<VirtualMachine> thread);
         void eventLoop(bool untilProjectStops = false);
-        void runScripts(const TargetScriptMap &scriptMap, TargetScriptMap &globalScriptMap);
         void finalize();
         void deleteClones();
         void removeExecutableClones();
@@ -151,27 +161,42 @@ class Engine : public IEngine
         std::shared_ptr<Entity> getEntity(const std::string &id);
         std::shared_ptr<IBlockSection> blockSection(const std::string &opcode) const;
 
+        void addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script);
+        std::vector<Script *> getHats(Target *target, HatType type);
+
         void updateSpriteLayerOrder();
 
         void updateFrameDuration();
         void addRunningScript(std::shared_ptr<VirtualMachine> vm);
-        std::vector<VirtualMachine *> startHats(const std::vector<Script *> &scripts);
+
+        std::shared_ptr<VirtualMachine> pushThread(std::shared_ptr<Block> block, Target *target);
+        void stopThread(VirtualMachine *thread);
+        std::shared_ptr<VirtualMachine> restartThread(std::shared_ptr<VirtualMachine> thread);
+
+        template<typename F>
+        void allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget);
+
+        std::vector<std::shared_ptr<VirtualMachine>> startHats(HatType hatType, const std::unordered_map<int, std::string> &optMatchFields, Target *optTarget);
+
+        static const std::unordered_map<HatType, bool> m_hatRestartExistingThreads; // used to check whether a hat should restart existing threads
 
         std::unordered_map<std::shared_ptr<IBlockSection>, std::unique_ptr<BlockSectionContainer>> m_sections;
         std::vector<std::shared_ptr<Target>> m_targets;
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<Broadcast *, std::vector<Script *>> m_broadcastMap;
-        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;      // target (no clones), "when I start as a clone" scripts
-        std::unordered_map<std::string, std::vector<Script *>> m_whenKeyPressedScripts; // key name, "when key pressed" scripts
         std::vector<std::string> m_extensions;
         std::vector<Target *> m_executableTargets; // sorted by layer (reverse order of execution)
-        TargetScriptMap m_runningScripts;
-        TargetScriptMap m_newScripts;
-        std::vector<VirtualMachine *> m_scriptsToRemove;
+        std::vector<std::shared_ptr<VirtualMachine>> m_threads;
+        std::vector<std::shared_ptr<VirtualMachine>> m_threadsToStop;
+        std::shared_ptr<VirtualMachine> m_activeThread;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
         std::recursive_mutex m_eventLoopMutex;
 
+        std::unordered_map<Target *, std::vector<Script *>> m_broadcastHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_whenKeyPressedHats;
+
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;
         double m_fps = 30;                         // default FPS
diff --git a/test/2_frames.sb3 b/test/2_frames.sb3
index 510a2d08f0bfe9c38769199db54452c766c1f2fd..d89bb837ca9f0261087b431e4e5645193a4a8a79 100644
GIT binary patch
delta 619
zcmV-x0+juv2b>3gP)h>@3IG5A2mmc%o>vjc$o%^O007Pd000aC003}uZ)#;@bS`Rh
zZ*HAa!H&}~5d9T2TtEtylWkX3F0fR)(uzeKS`etJiW^Vb5XTeQPPSFI|IRo`p&%g;
zmuP14{N9`K_y}IwEqVv(@(6{Sd$~nOy=^c8BP))fuSL**N?XW{M#diD>$ltT&G@NU
zKEEqpznJb{-h3Lpst(W2Am)S1G!m;*1iElR>d4{7l2n=enQO|*j(QV5RA;1uI<{#1
z`f-OQ*K(WbA}dj`8-sh#za@vYw2Xn&G+IYcn7TQW<^^gs#BL`QJwlpG?YKEl^#gP3
zbF+I$ug4L893Y(tM$2DJWMsT0y|!4R^gq;l!LvLYzfgz8{rlTFk0Fkh*AXPJT17Db
z_;$XynZ4t35<v#5fA!cEPT|O<ElpIqb?~y0S*a}5f3hawKL*o_234vm<{9u=V*~4q
zoNvN{hydu~ev5{+Ia`WZT1hYO$W}6VaqX5%(mC{h_bLomCGjL4D>1o>bCu_tBuT^=
z1!fae({Zp~sY!p`f5VP?a!X$Ng3OG4qWuhMG8VsAzd#yK#ffjlQDed|mK?XFyQX5n
z2edq({a_W^u1k+qO}r)?wuM4kSZQ20;;dVnq0H~ahXIg*aAxlpG_Mh}-GemSrh8xE
zc7k#?MW*m%2W^I;acpqNEA-tOI;`4Y0j@@3B*IIqI1!_yOPH{`VmO_?15ir?1PTBE
z00;mrVV;vZ0@MvHVV+kJ$;kZs0RRBblN$pq11({mlS=~|0wn^INdhL5jsp+|`T_s|
F000L48e#wd

delta 649
zcmbQkzJ$F#z?+$ci-CcGgCTfYQn*6K%d5;x3=H>}85nqgq6J0yS*gh-dRfK!c~gTE
z^Di3+{MCN(gDGgm9G#h~Y8r#gRwfyAmT`oH9`4l7U6Jg*ZSpp)zwhTvE-_$X+UN3K
z@BH_BbI-dM+*xxm(qp>2#@jm|O`Tr(G&5?%3AWjZJDjffJ!#x|#P-ni_2IX}KW;Dj
z`K9Xjr<)c3Yd#fzS!88nIeCTL9~risQZ9#S*Suvp)7*+DewN>O<>xl-xj*~Y73=P?
z+P31(-@N8k6Kdw3HoCt^!JO-RUtMvNsriw{5Yr&GfK|IJ#dW==BpoO_+<MP3svvWv
z<?`3kt8~wweW$p$hq>OuVU|JC^M0QvQI?CJ{_UIo&T;p2>+W(txh)UR-fcgbRQ7w`
zGXb{KDhzC^ukN>cCFJs8ziHwIw}0-^H<hKkZ|+`Q`Tn6%Lx&BE!TxI7c%NnYnzBFL
z{$HLZ-?vUHNcu-*@}6%Y(bs>pCeFL?ux@pm>8Xl+qHfm}B}MLh%+A$%S1)_J%vUo{
zch}4hwOtxMhaxsSQPOb<ObHa(C?WZbv#apU^O(*h`~U4PbgwO3EL*-bEcjFBGvOtH
zXX?(@wVB9l7Un(i%I#;O4(Il$GT+u7K94$w;%t^#>%7}T*JkE&Y+LHE*C6KRJEc!~
zy=^9Y<)5=J5dC3Xz5T*xDZ~4B3bxwi?fU-g{RQptsHuLl9cQmtp(82th%0uxpxEkb
z(GA^#(uV(yw7G6*ykgS2q02PK?>-|+f|+c@bcGis;Y=20)>QzBbet1loD57tr+`=m
Yh!H@SX|f}e+T=E70X8OJI%8k}06qd79smFU

diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index a94e2b04..3e7a301b 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -1580,7 +1580,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // "backdrop2"
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.setBytecode(bytecode1);
     vm.run();
 
@@ -1589,7 +1589,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 0
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.setBytecode(bytecode2);
     vm.run();
 
@@ -1599,7 +1599,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1608,7 +1608,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 1
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode3);
     vm.run();
 
@@ -1617,7 +1617,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 2
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.setBytecode(bytecode4);
     vm.run();
 
@@ -1626,7 +1626,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 3
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode5);
     vm.run();
 
@@ -1641,7 +1641,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.setBytecode(bytecode6);
     vm.run();
 
@@ -1650,7 +1650,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // "next backdrop"
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
     vm.setBytecode(bytecode7);
     vm.run();
 
@@ -1658,7 +1658,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.costumeIndex(), 3);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1666,7 +1666,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.costumeIndex(), 0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1676,7 +1676,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1685,7 +1685,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // "previous backdrop"
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
     vm.setBytecode(bytecode8);
     vm.run();
 
@@ -1693,7 +1693,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.costumeIndex(), 3);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1703,7 +1703,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1713,7 +1713,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1724,7 +1724,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(1);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     vm.setBytecode(bytecode9);
     vm.run();
 
@@ -1733,7 +1733,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 0 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode10);
     vm.run();
 
@@ -1742,7 +1742,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 5 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     vm.setBytecode(bytecode11);
     vm.run();
 
@@ -1751,7 +1751,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 6 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode12);
     vm.run();
 
@@ -1821,6 +1821,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     // Test without any backdrops first
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block1);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1830,6 +1831,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block1);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1838,24 +1840,28 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block2);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block3);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block4);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block5);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1864,12 +1870,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block6);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::nextBackdropAndWait)).WillOnce(Return(1));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block7);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1878,12 +1886,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block8);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::previousBackdropAndWait)).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block9);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1892,12 +1902,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block10);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::randomBackdropAndWait)).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block11);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1906,12 +1918,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block12);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block13);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1922,6 +1936,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
         compiler.bytecode(),
         std::vector<unsigned int>(
             { vm::OP_START,
+              vm::OP_EXEC,
+              6,
               vm::OP_EXEC,
               5,
               vm::OP_CONST,
@@ -1929,71 +1945,97 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               1,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               2,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               3,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               4,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               5,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_EXEC,
               1,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               6,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_EXEC,
               2,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               7,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_EXEC,
               3,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               8,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_NULL,
               vm::OP_EXEC,
               4,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 1, -1, 0, 1, 3, 3, 4, 5, 6 }));
@@ -2001,19 +2043,19 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
 TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 {
-    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::switchBackdropToAndWait, &LooksBlocks::switchBackdropToByIndexAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::switchBackdropToAndWait, &LooksBlocks::switchBackdropToByIndexAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
     static Value constValues[] = { "backdrop2", 0, 1, 2, 3, "next backdrop", "previous backdrop", -1, 0, 5, 6 };
 
     Target target;
@@ -2028,13 +2070,13 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     vm.setConstValues(constValues);
 
     // "backdrop2"
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
     vm.setBytecode(bytecode1);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2046,13 +2088,13 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 0
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
     vm.setBytecode(bytecode2);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2065,8 +2107,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2076,8 +2118,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 1
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode3);
     vm.run();
@@ -2087,8 +2129,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 2
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode4);
     vm.run();
@@ -2097,8 +2139,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     // 3
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode5);
     vm.run();
@@ -2113,8 +2155,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode6);
     vm.run();
@@ -2123,13 +2165,13 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     // "next backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(true));
     vm.setBytecode(bytecode7);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 3);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2140,8 +2182,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2149,8 +2191,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2160,8 +2202,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2170,25 +2212,27 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 4);
 
     // "previous backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(true));
     vm.setBytecode(bytecode8);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 3);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(false));
+    stage.setCostumeIndex(2); // checkBackdropScripts() should still check index 3 even after changing the backdrop
     vm.run();
+    stage.setCostumeIndex(3);
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2198,8 +2242,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2209,8 +2253,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2221,13 +2265,13 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // -1 (index)
     stage.setCostumeIndex(1);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(true));
     vm.setBytecode(bytecode9);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 5);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2239,8 +2283,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 0 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode10);
     vm.run();
@@ -2250,8 +2294,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 5 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode11);
     vm.run();
@@ -2260,8 +2304,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 5);
 
     // 6 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.setBytecode(bytecode12);
     vm.run();
@@ -2305,14 +2349,14 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
     vm.setFunctions(functions);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2320,7 +2364,7 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2330,8 +2374,8 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
 
 TEST_F(LooksBlocksTest, NextBackdropAndWait)
 {
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::nextBackdropAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::nextBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
 
     Target target;
 
@@ -2345,12 +2389,12 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
     vm.setBytecode(bytecode);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2361,8 +2405,8 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2371,8 +2415,8 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
     ASSERT_EQ(stage.costumeIndex(), 2);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2399,14 +2443,14 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
     vm.setFunctions(functions);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2414,7 +2458,7 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
     ASSERT_EQ(stage.costumeIndex(), 0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2424,8 +2468,8 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
 
 TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
 {
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::previousBackdropAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::previousBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
 
     Target target;
 
@@ -2439,12 +2483,12 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
     vm.setBytecode(bytecode);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2455,8 +2499,8 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2465,8 +2509,8 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
     ASSERT_EQ(stage.costumeIndex(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
@@ -2503,7 +2547,7 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
 
     EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2514,7 +2558,7 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
 
     EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2526,8 +2570,8 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
 
 TEST_F(LooksBlocksTest, RandomBackdropAndWait)
 {
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::randomBackdropAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::randomBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
 
     Target target;
 
@@ -2541,7 +2585,7 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     LooksBlocks::rng = &rng;
 
     EXPECT_CALL(rng, randint).Times(0);
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning).Times(0);
     vm.run();
 
@@ -2552,13 +2596,13 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
 
     EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
     vm.reset();
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
@@ -2572,8 +2616,8 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     stage.addCostume(std::make_shared<Costume>("backdrop4", "b4", "svg"));
 
     EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
diff --git a/test/clone_limit.sb3 b/test/clone_limit.sb3
index 75338c6e3776b4cf79f0b86ca095a73a4b596252..30e2dfd848fe083f3bb9246089d0a7a8d376bc2a 100644
GIT binary patch
delta 2060
zcmV+n2=n*65}Oi#P)h>@3IG5A2mm#;omUT_*G_r|008YR000aC003}uZ)#;@bS`Rh
zZ*J{c`*)g16#iG*N%x#SY>Kaq&7PjdsA)`%rasbaa$GyYs6=20j7F2q{_T4QP(gu!
znl^jR{^EggfbYJ)d*L22Z1f2;(f-vvlFbIgeS-FxF(L_nq+u0~k-e5cV{FK{s}R_G
zkA7U2h6kCy<*S{e;pf-6$(#K7?t69mVzvqHheSHk7)l831QLhsom?wlxue6YzYe=^
zhX*IW@hw!53X5Gg7pd3hAFGp-5BHaaYYi87#52B2#S?o&(`bLF;9>n;X1a6PdD#@t
zjn908L=?h*NJqz}NhE-Z+7Ah&$R?NT9uB((#gd5ab98m_syW^L_@!KYcaT5mwC@__
zJCM`930(cA*MCzjUN!ZL%G=A_Kc%ym;z#&jRH#M}znenEp>?Mz|Dn1_C9WtkCK~J9
z4v5xMa9>npacH5@$b`Y)*Knv~1NNYOZKNm(By0MAXa=z-6Gd{4%>kC^E!yv4#RNMr
zs#oCN%FHekw4cc(_``qC!0u}g2njRXF$tR)g3$$np$h?A?gD_$^OaT!RGCa%C4~eM
zP`m901^?H}`NK-dW!J}jpdBWQwE!E2k>O)E{Od6I?~`Hp7f$EzmyuxO$gmYR?4d90
zbOPOfAsc!aa4Qb{qa+gMI}c{669Y49bPTLXRGkC1eRGZ&dk`PhYp1rJGYOOxxSv2+
z*5*rl*=5&>0!;OZqj}5%x?3!>g+jY-g=!vnhxJ;%Sjab;opSZ8)pR@}nOFq3Z}7)Q
zEP4=&RAUBJItI}RW*zV?Sqai--UGN$s}{?D&2p^@P*VUCfjS$l!$vb-_-Zdv6dRo6
zZ)a)*VG=!<YG<W-zFJJ$&p+gloTZe#REQ7h&>s@H8Nr4iSW*zIG#C|dL{CKX*z$<t
z+~(1I;2W7yq%QbN-Dkg8;;=-rwy-pEMkFZE_ZAs(U3s52?GxX)7Yzt|(y<sqhxQhK
zlIm_rsW<W~wQ8wTJ9B~`a#S&XSQVqd>8L~-1$i7n0X$?GAZqA_%t#U?_#NEJvRTP0
zI6aoG!f^R0s}x^ZrHz%P$5d7-y0W^Fqvy!&Q)&>OxQW0gmT9vuy^a(XT4eO98@=+M
ziv62)YFPKlGdeQ-O&vuf!(Sv7vjNqAgG9RVh*WKz+AzK#ivcd1!NS_C)veBf$cn7>
zSEC{j;Fkb^BZbMjG7W-gEJIAjD)$*j&v0RCPHlzV+!`9r2egQDdTS8S%Gli~iqRTH
z7uj9p9lJ>l=wU-OzS3I?0&G8u!^}fnKaiS-LyoO*B~~w?p}<z>=K$ut1XZDb=*;XZ
zjtmZ`KutE{^A~|{u#W8^jWd<$VsR)LREK(O<=Z1_K-9t?<{07&@s!TW689!4mCPnH
zl8{X&ds460O{G#oh6qH=5-FGAGOJS7@w`X&?%FpuD8o#qS^;np;{xrcGQ#repJ+ds
z6CNOlOb9lvj4L=EQ^gW0DZmAP3Z4?9W=O=aq+~?ZDfc_rCQF1ip)WNp+lb(f+1YXf
zo?_(!ZaN0Io3x=5A`U88>yNDQ75Br3glnGV=zccPnh_cANUM2plG*#-(a$d*ny>yi
zR?P8_^La>>i+lnVGF9@-g^qoh2DqQWI@s*Y9LVuObNhoKFbLniT9w6r0ceTL<nAsK
zC@Q-n;W%iz0(mfWwzA#X&`DHUv6Okfu0PwF8Qb3-BBA~oXDWE|L{q^^{JPWIpzb^}
zUx@=hW8v@lhL9ZCFI2+DD*e^53X9)AjMm|Q{b2rwPLV&S3vkpZ7*7NE5|x4gjzXx?
zW6==6l(K68ulm~C=}_2zKwi$8OH#0)&MeBaS)4psb?3=mNS+KILT@)w_WjKcbSFq*
zJwLy6=6fU8$j_Mq*5ZdtE$;9uBvc}L<CcS|yk_|^x7pS{ak*NTe>!WNMRjGSV!cjG
zAa|Sq0=;_%oYaqzM(3kR&NfZidXqUXP=ZyT;MbJzW*12^6jED%>W}=?!2Q1c0@P9X
z3`B!X`6|MS@&X$i1A3IBrj|Ksu66k-aWHLunxx6$&BgIVzuQ}rqn^d$sN<*NsN*=f
z_nSNSo;?qaT93o_8c)Rb8f#{%`WA??uTMr&T{AvM9XuzFI*7?pn_(PPUgfB_@r&+l
zoN#Kn!)fqLs7z~rGa`7q2@#ZI(<rajyqxKL_08!dzD3XD(kMAHjq;D&t<$K<I(<`!
z6zKc*`=;-)`=&{xz9~q>TkD&?t(p19zks8zTPgnMsJ<LE<;PL?(pG^==eEaE0fS04
z8REhDOpvSRQP<!X**-~nc%*Q5^17*OCwL`RmmJ4&Lhc=Z78kBsHnqKYjFpjX_FGwE
z1M6r&<o<wJhoFY6rG@N@hD=2U-JQys&ExGeJaN<{n?>0a4bBp*{T4yDoWbu!(Z&+a
z-$ZRBWZLZqjycy9)Ax&zjm6|&n>-f@ecR;CUDZi(OHz8?H2ic?eY5Qoi<*idYIb`@
z_4{sNV@bV0Uq@`uf!9hzkb|Mr5Y2=f?bHR8FzX{!lc-}}4p4em*cG?|R5%fKQ`QOY
z+w~qjJp2n#O9KQ70000805!FplhOy&4mGu%R}Y}qPI?Cb0PQW4v<NI9HMN~rh|UlJ
qlK=n!$^ZZWBme*a0000000000005*1li>#@lO_oe26+eo0000a@#m)i

delta 2093
zcmV+|2-5eP61)<BP)h>@3IG5A2moVOURSG;t8tqL004z9000aC003}uZ)#;@bS`Rh
zZ*J{c{d1Z~82(q<O>d?jHbtWso10E!)HJ3>Q$NyNGM-&wRU)tiR-?(~{`PwpP{9BJ
zG;MC?esN%3;Ca8F_k}yeurVOaM0=NaNH&`c4+z?0#+amkkcL$_M)q0?O|T*3o<d;n
z9r|%q9_?rUmM^ysN1tEkr*8^p+waxci}@zF9}?+UV<;tbQb-(iw({*l^_Gq<|2pWs
z9qk|g#<x&KDlT_jpJ!g5eXLE7KipjuuQXiR5>NRq6;JIAEu-_Hibsui+1b`b_hm~w
zGd}YT5>W_$BV8SvCXoOt>fEQ0BAZ;UJ2>na6iXtu&(Y=itJZA$<CjY5-F{)e+qrF4
zZb44_CUEte{@_imblK9+t8Xvz|CCQ(iXY*BQK1?^{B8;rN7kKY{D<lymAInFglMdL
zGbCDH!2?l|#gT<ZBU1){kKj<p2JAt5+E`IiNY?a!@f>1bCW_=7n?o$o8?@KQiV1dL
zRIkFlmAPG}XfK;j@rVDOh20|$2njRXH3^#=g3%=c#f1PacL6|Wg=)JDs!XRY(?SXf
zsMB$Sg8v(p!a=p{vg_kM&<T^pTHt1i3?IAUkHX-;Plw@OI-S2?MuLqa!&cp}6<^pp
zDRhf}Z0KRYtvK+Hl1P|uJ(#IZ49uv}HLxa8bphD+%>`oYL44S#pV)fNrch4cega`x
zUo7qBR$V6wFwG~97BLIxZm`Uj3hlWSN<Hun8udb{SZKDomD*{$<#<FowG3|G;E#`3
z^dJ_g#tf=-4Wbjwy5L)~5~R<92XL`oD^*&5m3j@JW&kDvbvD}v%~qlK)n3w3Y;cml
zov9IoN%UZ<pOzbiS}AQm|A0esmNNEIF+QXNe@Ntd3>$)ANkOo7z^H&DdLmlHmPZul
zHjm~5-^h$2b<tny0sF-ghb5B4!s?MTB0+(^x6Fu1<$c<;PkiHEG$8Cr*J21=+Fwe4
z+ILH;dn3PEua&#?Qz!T#N0s7-RVfObu1d6VkjD`ez(ZC6qNZ-hjHFSD-@&aco0U8S
z*N>;GG75s_qpQRCx;k82SN)i}%0$;y*%zFr?uCItrFNsR(9UJ<A%lyep<d(&{^GWk
z7Q|_;BXF8k>h4SNBZVf7j9zo2SN~Ig`R6)G9qm1NRY8WosiTNw_=}`sHl%uxNY@^b
zYV8vn#u2hu=&BhktgU*(>RyPf$lBmxXa)j23II4(n5-+aAc)2)#B?mmk#+P87iJdp
zTG-Af&~PE3O<hoIgMd~h?q*et)~vb+_cHm}jdDOA9jfsM{jDItb~RRaKv7_S^Agw{
zgd>iv?=NuxhsNs9LCpIZszT+P+gBVL98Qs%Y|Ljs0^eXA+k+x!GStK3NHVAnoWRPr
zhtz<mg+I&*#24ZzomC|6O;RSEOJ^k^x0CKm{eCZ#$p~2@5HUxje3n~Dm2!^fJ+gP(
zzPUjeW-`@^fRh;KXfKl$R#*RjM0@GHa1TLbLa=dVT*C2$Dwa@b0WMJRj2Lx8B8DX;
zBdSih-@!InBD4j)v1!>x1b58Mmz(euD;Mxe!T@)RHg!V8VHInGu{A>DX1!0jW@?V^
z=R>tQnevX+TKmV@-S1uf?Bc%l>W?GEocuUjgjA)(r(hwIEzfMK;>#$1!2b-^#b$Tz
zKu*+{n;%YrLHPEERaqQ@mdIT0-ZFurV|VOUf+jqW2SevOo1IU6jY=z40=b%ezBV_u
zzdJ-iU5zuD{Q5+b$&>hXXRt=yd1S^D2Y%MVKkyA9xgTWmld#dw@Zo5O#cyK9N%-F|
znE#;~^5=8`jv57HEr2h7Q7H)EID{%a77YPRDVG3v-Phhuhr)*PYSvtlf(5mQQJ&4>
z<jJ}_PYy!zWcVO_vx#!(Z+752K?)oA`K2>s9J|Jj&Lr|Qez=^*9l(WzN<?qma4;Pw
zEI;NZ+uA2CS4sJ&v&LCePi89C8^i>1#|a?NyJx^j{TOL<KAPr#Y}1sjx2cN)C0O+d
zeogsyevu?YA+@Fc$WIMC7}zgi9fi+9G}(-=BCIGcu)#5)M>%R{m80g{7oSr5v(~5S
z4mr3!Kbq>dy9qh!w^$r?@>Cpk5-0aI+`0GL^Wdn>IBc)=L~O5>FjF-*K$LxbGLq`r
z@j0seoH(i+lcTnO134;?!7FDf<{_%EezTmG#VTGmaRTei9a!=+AvI^~QNo*bDB)FX
zLgm$(m*{_A*w#C_ohG#H_qf#RDl)b5kLHb2t7(#6Dntr&zWHA2Ja#WNjnqp8sd!_(
zR3l+EnEV3XnzVZS&s%+YYsQba?(SGcYbU=s<_Z{8s>u+456<U{Ts@Dv2EWMmNz%t-
zg}am2O<g;|E3vxbIF1u?@38oB&9bTO#S^TIZL{CV5*u1aLn04`%sK=$<SZ@Z9%#r^
zWYFD-tl8Y&KEqQ-O|n^%P0`@Y!P;+;cFP(3ULLJ2;o|MoT0-u){lGD2LNR^6R9Rb0
z{uRt~k<hncbza|9ofNksrRVL#PZ!lU+di?VnHZwxHfL17ZyDB>)ceK6<{UUtB7z(Y
zrG{uG<Y=cZsDxP`$C^Z)@N$55wuNnh8$g8<VLM};;DKH5(f$3uP)h>@3IG5A2moVO
zUX!s0)DB};URSG;t8tqL004z9lamN6AY)fvSBTCK0h0g#0LlOW03-ka0000000000
X0002R2a~`DCX)pT5C)nE00000Wxw+6

diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 6aaea6fd..f982a374 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -99,47 +99,65 @@ TEST(EngineTest, FpsProject)
     engine->m_clock = &clock;
 
     std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(50));
-    std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(75));
-    std::chrono::steady_clock::time_point time3(std::chrono::milliseconds(83));
-    std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(116));
+    std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(70));
+    std::chrono::steady_clock::time_point time3(std::chrono::milliseconds(75));
+    std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(83));
+    std::chrono::steady_clock::time_point time5(std::chrono::milliseconds(116));
+    std::chrono::steady_clock::time_point time6(std::chrono::milliseconds(156));
     EXPECT_CALL(clock, currentSteadyTime())
-        .WillOnce(Return(time1))
-        .WillOnce(Return(time1))
-        .WillOnce(Return(time2))
-        .WillOnce(Return(time2))
-        .WillOnce(Return(time3))
-        .WillOnce(Return(time3))
-        .WillOnce(Return(time4))
-        .WillOnce(Return(time4));
-    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(33)));
-    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(25)));
+        .WillOnce(Return(time1)) // tick start (frame 1 of 2)
+        .WillOnce(Return(time1)) // step start
+        .WillOnce(Return(time2)) // step loop check
+        .WillOnce(Return(time3)) // step loop check (break)
+        .WillOnce(Return(time3)) // tick end (then sleep 8 ms)
+        .WillOnce(Return(time4)) // tick start (frame 2 of 2)
+        .WillOnce(Return(time4)) // step start
+        .WillOnce(Return(time4)) // step loop check
+        .WillOnce(Return(time5)) // step loop check (break)
+        .WillOnce(Return(time5)) // tick end (without sleeping)
+        .WillOnce(Return(time5)) // tick start
+        .WillOnce(Return(time5)) // step start
+        .WillOnce(Return(time5)) // step loop check
+        ;
+    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(8)));
     p.run();
 
     engine->setFps(10);
     RedrawMock redrawMock;
     auto handler = std::bind(&RedrawMock::redraw, &redrawMock);
     engine->setRedrawHandler(std::function<void()>(handler));
-    std::chrono::steady_clock::time_point time5(std::chrono::milliseconds(100));
-    std::chrono::steady_clock::time_point time6(std::chrono::milliseconds(115));
-    std::chrono::steady_clock::time_point time7(std::chrono::milliseconds(200));
-    std::chrono::steady_clock::time_point time8(std::chrono::milliseconds(300));
+    std::chrono::steady_clock::time_point time7(std::chrono::milliseconds(100));
+    std::chrono::steady_clock::time_point time8(std::chrono::milliseconds(200));
+    std::chrono::steady_clock::time_point time9(std::chrono::milliseconds(300));
     EXPECT_CALL(clock, currentSteadyTime())
-        .WillOnce(Return(time5))
-        .WillOnce(Return(time5))
-        .WillOnce(Return(time6))
-        .WillOnce(Return(time6))
-        .WillOnce(Return(time7))
-        .WillOnce(Return(time7))
-        .WillOnce(Return(time8))
-        .WillOnce(Return(time8));
+        .WillOnce(Return(time7)) // tick start (frame 1 of 2)
+        .WillOnce(Return(time7)) // step start
+        .WillOnce(Return(time7)) // step loop check
+        .WillOnce(Return(time7)) // step loop check (break because of redraw request)
+        .WillOnce(Return(time7)) // tick end (then sleep 100 ms)
+        .WillOnce(Return(time8)) // tick start (frame 2 of 2)
+        .WillOnce(Return(time8)) // step start
+        .WillOnce(Return(time8)) // step loop check
+        .WillOnce(Return(time9)) // step loop check (break)
+        .WillOnce(Return(time9)) // tick end (without sleeping)
+        .WillOnce(Return(time9)) // tick start
+        .WillOnce(Return(time9)) // step start
+        .WillOnce(Return(time9)) // step loop check
+        ;
     EXPECT_CALL(clock, sleep(std::chrono::milliseconds(100)));
-    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(15)));
-    EXPECT_CALL(redrawMock, redraw()).Times(4);
+    EXPECT_CALL(redrawMock, redraw()).Times(3);
     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, currentSteadyTime())
+        .WillOnce(Return(time7)) // tick start
+        .WillOnce(Return(time7)) // step start
+        .WillOnce(Return(time7)) // step loop check
+        .WillOnce(Return(time7)) // step loop check
+        .WillOnce(Return(time7)) // step loop check
+        ;
     EXPECT_CALL(clock, sleep).Times(0);
+    EXPECT_CALL(redrawMock, redraw());
     p.run();
 }
 
@@ -1092,8 +1110,7 @@ TEST(EngineTest, CloneLimit)
     ASSERT_EQ(engine->cloneLimit(), 300);
     ASSERT_EQ(engine->cloneCount(), 0);
 
-    // TODO: Set "infinite" FPS and remove this (#254)
-    engine->setFps(100000);
+    engine->setTurboModeEnabled(true);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
@@ -1147,18 +1164,18 @@ TEST(EngineTest, CloneLimit)
 
 TEST(EngineTest, BackdropBroadcasts)
 {
-    // TODO: Set "infinite" FPS (#254)
     Project p("backdrop_broadcasts.sb3");
     ASSERT_TRUE(p.load());
     p.run();
 
     auto engine = p.engine();
+    engine->setFps(1000);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
     ASSERT_VAR(stage, "test1");
-    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 5); // TODO: Find out why this isn't 4
+    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 4);
     ASSERT_VAR(stage, "test2");
     ASSERT_EQ(GET_VAR(stage, "test2")->value().toInt(), 14);
     ASSERT_VAR(stage, "test3");
@@ -1171,18 +1188,18 @@ TEST(EngineTest, BackdropBroadcasts)
 
 TEST(EngineTest, BroadcastsProject)
 {
-    // TODO: Set "infinite" FPS (#254)
     Project p("broadcasts.sb3");
     ASSERT_TRUE(p.load());
     p.run();
 
     auto engine = p.engine();
+    engine->setFps(1000);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
     ASSERT_VAR(stage, "test1");
-    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 6); // TODO: Find out why this isn't 4 (the only difference between this and backdrops is that backdrop changes request redraw)
+    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 4);
     ASSERT_VAR(stage, "test2");
     ASSERT_EQ(GET_VAR(stage, "test2")->value().toInt(), 14);
     ASSERT_VAR(stage, "test3");
@@ -1190,7 +1207,7 @@ TEST(EngineTest, BroadcastsProject)
     ASSERT_VAR(stage, "test4");
     ASSERT_EQ(GET_VAR(stage, "test4")->value().toInt(), 10);
     ASSERT_VAR(stage, "test5");
-    ASSERT_EQ(GET_VAR(stage, "test5")->value().toString(), "2 1 0 0"); // TODO: Find out why this isn't "2 2 0 0"
+    ASSERT_EQ(GET_VAR(stage, "test5")->value().toString(), "2 2 0 0");
 }
 
 TEST(EngineTest, StopAll)
@@ -1206,6 +1223,7 @@ TEST(EngineTest, StopAll)
 
     ASSERT_VAR(stage, "i");
     ASSERT_EQ(GET_VAR(stage, "i")->value().toInt(), 11);
+    ASSERT_FALSE(engine->isRunning());
 }
 
 TEST(EngineTest, StopOtherScriptsInSprite)
@@ -1251,12 +1269,12 @@ TEST(EngineTest, NoCrashOnBroadcastSelfCall)
 TEST(EngineTest, NoRefreshWhenCallingRunningBroadcast)
 {
     // Regtest for #257
-    // TODO: Set "infinite" FPS (#254)
     Project p("regtest_projects/257_double_broadcast_stop.sb3");
     ASSERT_TRUE(p.load());
     p.run();
 
     auto engine = p.engine();
+    engine->setFps(1000);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index c950e772..5b735f9c 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -19,6 +19,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(VirtualMachine *, startScript, (std::shared_ptr<Block>, Target *), (override));
         MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
         MOCK_METHOD(void, broadcastByPtr, (Broadcast *, VirtualMachine *, bool), (override));
+        MOCK_METHOD(void, startBackdropScripts, (Broadcast *), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
         MOCK_METHOD(void, initClone, (std::shared_ptr<Sprite>), (override));

From e61b78ffd00d224f88b854b4fc46bb0726b66d17 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 16:14:46 +0100
Subject: [PATCH 05/17] Add isBackdropBroadcast property to Broadcast

---
 include/scratchcpp/broadcast.h          |  4 +++-
 src/scratch/broadcast.cpp               | 10 ++++++++--
 src/scratch/broadcast_p.cpp             |  5 +++--
 src/scratch/broadcast_p.h               |  3 ++-
 test/load_project/load_project_test.cpp |  5 +++++
 test/scratch_classes/broadcast_test.cpp | 23 ++++++++++++++++++++---
 6 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/include/scratchcpp/broadcast.h b/include/scratchcpp/broadcast.h
index 0aacdd56..f6e021c7 100644
--- a/include/scratchcpp/broadcast.h
+++ b/include/scratchcpp/broadcast.h
@@ -13,12 +13,14 @@ class BroadcastPrivate;
 class LIBSCRATCHCPP_EXPORT Broadcast : public Entity
 {
     public:
-        Broadcast(const std::string &id, const std::string &name);
+        Broadcast(const std::string &id, const std::string &name, bool isBackdropBroadcast = false);
         Broadcast(const Broadcast &) = delete;
 
         const std::string &name() const;
         void setName(const std::string &newName);
 
+        bool isBackdropBroadcast() const;
+
     private:
         spimpl::unique_impl_ptr<BroadcastPrivate> impl;
 };
diff --git a/src/scratch/broadcast.cpp b/src/scratch/broadcast.cpp
index 4c2c6328..582a3f8f 100644
--- a/src/scratch/broadcast.cpp
+++ b/src/scratch/broadcast.cpp
@@ -7,9 +7,9 @@
 using namespace libscratchcpp;
 
 /*! Constructs Broadcast. */
-Broadcast::Broadcast(const std::string &id, const std::string &name) :
+Broadcast::Broadcast(const std::string &id, const std::string &name, bool isBackdropBroadcast) :
     Entity(id),
-    impl(spimpl::make_unique_impl<BroadcastPrivate>(name))
+    impl(spimpl::make_unique_impl<BroadcastPrivate>(name, isBackdropBroadcast))
 {
 }
 
@@ -24,3 +24,9 @@ void Broadcast::setName(const std::string &newName)
 {
     impl->name = newName;
 }
+
+/*! Returns true if this broadcast belongs to a backdrop. */
+bool Broadcast::isBackdropBroadcast() const
+{
+    return impl->isBackdropBroadcast;
+}
diff --git a/src/scratch/broadcast_p.cpp b/src/scratch/broadcast_p.cpp
index b6cb4f19..b6c055bc 100644
--- a/src/scratch/broadcast_p.cpp
+++ b/src/scratch/broadcast_p.cpp
@@ -5,8 +5,9 @@
 namespace libscratchcpp
 {
 
-BroadcastPrivate::BroadcastPrivate(const std::string &name) :
-    name(name)
+BroadcastPrivate::BroadcastPrivate(const std::string &name, bool isBackdropBroadcast) :
+    name(name),
+    isBackdropBroadcast(isBackdropBroadcast)
 {
 }
 
diff --git a/src/scratch/broadcast_p.h b/src/scratch/broadcast_p.h
index 830a5d57..6422d99f 100644
--- a/src/scratch/broadcast_p.h
+++ b/src/scratch/broadcast_p.h
@@ -9,10 +9,11 @@ namespace libscratchcpp
 
 struct BroadcastPrivate
 {
-        BroadcastPrivate(const std::string &name);
+        BroadcastPrivate(const std::string &name, bool isBackdropBroadcast);
         BroadcastPrivate(const BroadcastPrivate &) = delete;
 
         std::string name;
+        bool isBackdropBroadcast = false;
 };
 
 } // namespace libscratchcpp
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index 4e385ac7..2c6898e9 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -12,6 +12,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/comment.h>
+#include <scratchcpp/broadcast.h>
 #include <projectdownloaderfactorymock.h>
 #include <projectdownloadermock.h>
 
@@ -498,6 +499,10 @@ TEST(LoadProjectTest, ProjectTest)
         ASSERT_EQ(engine->extensions().size(), 0);
         ASSERT_EQ(engine->broadcasts().size(), 1);
 
+        auto broadcast = engine->broadcastAt(0);
+        ASSERT_EQ(broadcast->name(), "message1");
+        ASSERT_FALSE(broadcast->isBackdropBroadcast());
+
         i++;
     }
 }
diff --git a/test/scratch_classes/broadcast_test.cpp b/test/scratch_classes/broadcast_test.cpp
index 36e45fea..e52ffac3 100644
--- a/test/scratch_classes/broadcast_test.cpp
+++ b/test/scratch_classes/broadcast_test.cpp
@@ -6,9 +6,26 @@ using namespace libscratchcpp;
 
 TEST(BroadcastTest, Constructors)
 {
-    Broadcast broadcast("a", "message1");
-    ASSERT_EQ(broadcast.id(), "a");
-    ASSERT_EQ(broadcast.name(), "message1");
+    {
+        Broadcast broadcast("a", "message1");
+        ASSERT_EQ(broadcast.id(), "a");
+        ASSERT_EQ(broadcast.name(), "message1");
+        ASSERT_FALSE(broadcast.isBackdropBroadcast());
+    }
+
+    {
+        Broadcast broadcast("a", "message1", false);
+        ASSERT_EQ(broadcast.id(), "a");
+        ASSERT_EQ(broadcast.name(), "message1");
+        ASSERT_FALSE(broadcast.isBackdropBroadcast());
+    }
+
+    {
+        Broadcast broadcast("a", "message1", true);
+        ASSERT_EQ(broadcast.id(), "a");
+        ASSERT_EQ(broadcast.name(), "message1");
+        ASSERT_TRUE(broadcast.isBackdropBroadcast());
+    }
 }
 
 TEST(BroadcastTest, Name)

From 4f72f3438bfc87c6936ce40f8d29a65d712b31aa Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 16:21:29 +0100
Subject: [PATCH 06/17] Set isBackdropBroadcast property of backdrop broadcasts

---
 src/scratch/costume_p.cpp    | 2 +-
 test/assets/costume_test.cpp | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/scratch/costume_p.cpp b/src/scratch/costume_p.cpp
index 0b70f216..88dd0dac 100644
--- a/src/scratch/costume_p.cpp
+++ b/src/scratch/costume_p.cpp
@@ -5,6 +5,6 @@
 using namespace libscratchcpp;
 
 CostumePrivate::CostumePrivate() :
-    broadcast("", "")
+    broadcast("", "", true)
 {
 }
diff --git a/test/assets/costume_test.cpp b/test/assets/costume_test.cpp
index 7f53e602..3ccceff4 100644
--- a/test/assets/costume_test.cpp
+++ b/test/assets/costume_test.cpp
@@ -56,4 +56,5 @@ TEST_F(CostumeTest, Broadcast)
     ASSERT_TRUE(broadcast);
     ASSERT_TRUE(broadcast->id().empty());
     ASSERT_EQ(broadcast->name(), "costume1");
+    ASSERT_TRUE(broadcast->isBackdropBroadcast());
 }

From ce0ecbb6265ff3877b2c8fcc7c7dc09b3b16b42a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 16:31:50 +0100
Subject: [PATCH 07/17] Use Broadcast::isBackdropBroadcast() in Engine

---
 src/blocks/eventblocks.cpp        |  8 +----
 src/engine/internal/engine.cpp    | 50 +++++++++++++++++--------------
 test/blocks/event_blocks_test.cpp |  3 --
 3 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 7cffe7ce..28ce502f 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -77,13 +77,7 @@ void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 
 void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
 {
-    if (Stage *stage = compiler->engine()->stage()) {
-        std::string backdropName = compiler->field(BACKDROP)->value().toString();
-        int index = stage->findCostume(backdropName);
-
-        if (index != -1)
-            compiler->engine()->addBroadcastScript(compiler->block(), stage->costumeAt(index)->broadcast());
-    }
+    // TODO: Register this hat in engine
 }
 
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index f896d970..fc2360d7 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -576,32 +576,35 @@ bool Engine::broadcastRunning(unsigned int index, VirtualMachine *sourceScript)
 
 bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript)
 {
-    assert(m_broadcastMap.find(broadcast) != m_broadcastMap.cend());
-    const auto &scripts = m_broadcastMap[broadcast];
-
-    for (auto thread : m_threads) {
-        if (!thread->atEnd()) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), [thread](Script *script) { return thread->script() == script; });
-
-            if (it != scripts.end())
-                return true;
+    if (broadcast->isBackdropBroadcast()) {
+        // This broadcast belongs to a backdrop
+        assert(m_broadcastMap.find(broadcast) == m_broadcastMap.cend());
+
+        for (auto thread : m_threads) {
+            if (!thread->atEnd()) {
+                // TODO: Store the top block in Script
+                Script *script = thread->script();
+                auto it = std::find_if(m_scripts.begin(), m_scripts.end(), [script](const std::pair<std::shared_ptr<Block>, std::shared_ptr<Script>> pair) { return pair.second.get() == script; });
+                assert(it != m_scripts.end());
+                auto topBlock = it->first;
+
+                // TODO: Add a map for "when backdrop switches to" hats
+                if ((topBlock->opcode() == "event_whenbackdropswitchesto") && (topBlock->findFieldById(EventBlocks::BACKDROP)->value().toString() == broadcast->name()))
+                    return true;
+            }
         }
-    }
+    } else {
+        // This is a regular broadcast
+        assert(m_broadcastMap.find(broadcast) != m_broadcastMap.cend());
+        const auto &scripts = m_broadcastMap[broadcast];
 
-    // TODO: Check whether the broadcast belongs to a backdrop
-    // maybe using something like broadcast->isBackdropBroadcast()
-    // after adding it to Broadcast
-    for (auto thread : m_threads) {
-        if (!thread->atEnd()) {
-            // TODO: Store the top block in Script
-            Script *script = thread->script();
-            auto it = std::find_if(m_scripts.begin(), m_scripts.end(), [script](const std::pair<std::shared_ptr<Block>, std::shared_ptr<Script>> pair) { return pair.second.get() == script; });
-            assert(it != m_scripts.end());
-            auto topBlock = it->first;
+        for (auto thread : m_threads) {
+            if (!thread->atEnd()) {
+                auto it = std::find_if(scripts.begin(), scripts.end(), [thread](Script *script) { return thread->script() == script; });
 
-            // TODO: Add a map for "when backdrop switches to" hats
-            if ((topBlock->opcode() == "event_whenbackdropswitchesto") && (topBlock->findFieldById(EventBlocks::BACKDROP)->value().toString() == broadcast->name()))
-                return true;
+                if (it != scripts.end())
+                    return true;
+            }
         }
     }
     return false;
@@ -736,6 +739,7 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
 
 void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast)
 {
+    assert(!broadcast->isBackdropBroadcast());
     Script *script = m_scripts[whenReceivedBlock].get();
     auto it = m_broadcastMap.find(broadcast);
 
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 127f3294..f58512b4 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -290,9 +290,6 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     auto backdrop = std::make_shared<Costume>("backdrop2", "a", "svg");
     stage.addCostume(backdrop);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, backdrop->broadcast()));
-
     compiler.init();
     compiler.setBlock(block1);
     EventBlocks::compileWhenBackdropSwitchesTo(&compiler);

From 87b1b347ff8b80d3b70c07c51a31828efd8a6be4 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 17:00:42 +0100
Subject: [PATCH 08/17] Add green flag script map to Engine

---
 include/scratchcpp/iengine.h      |  3 +++
 src/blocks/eventblocks.cpp        |  7 ++++++-
 src/blocks/eventblocks.h          |  1 +
 src/engine/internal/engine.cpp    | 22 +++++++---------------
 src/engine/internal/engine.h      |  2 ++
 test/blocks/event_blocks_test.cpp | 22 +++++++++++++++++++++-
 test/mocks/enginemock.h           |  1 +
 7 files changed, 41 insertions(+), 17 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index b9468a00..9c9fa7bb 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -245,6 +245,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the index of the broadcast with the given ID. */
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
+        /*! Registers the "green flag" script. */
+        virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Registers the broadcast script. */
         virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) = 0;
 
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 28ce502f..faa8df92 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -21,7 +21,7 @@ std::string EventBlocks::name() const
 void EventBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
-    engine->addHatBlock(this, "event_whenflagclicked");
+    engine->addCompileFunction(this, "event_whenflagclicked", &compileWhenFlagClicked);
     engine->addCompileFunction(this, "event_broadcast", &compileBroadcast);
     engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
     engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
@@ -37,6 +37,11 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addField(this, "KEY_OPTION", KEY_OPTION);
 }
 
+void EventBlocks::compileWhenFlagClicked(Compiler *compiler)
+{
+    compiler->engine()->addGreenFlagScript(compiler->block());
+}
+
 void EventBlocks::compileBroadcast(Compiler *compiler)
 {
     auto input = compiler->input(BROADCAST_INPUT);
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index 5e9e4502..21f7e812 100644
--- a/src/blocks/eventblocks.h
+++ b/src/blocks/eventblocks.h
@@ -30,6 +30,7 @@ class EventBlocks : public IBlockSection
 
         void registerBlocks(IEngine *engine) override;
 
+        static void compileWhenFlagClicked(Compiler *compiler);
         static void compileBroadcast(Compiler *compiler);
         static void compileBroadcastAndWait(Compiler *compiler);
         static void compileWhenBroadcastReceived(Compiler *compiler);
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index fc2360d7..303787cd 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -737,6 +737,11 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
     return -1;
 }
 
+void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
+{
+    addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
+}
+
 void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast)
 {
     assert(!broadcast->isBackdropBroadcast());
@@ -1087,21 +1092,8 @@ std::vector<Script *> Engine::getHats(Target *target, HatType type)
     }
 
     switch (type) {
-        case HatType::GreenFlag: {
-            // TODO: Add a map for green flag hats and return reference
-            std::vector<Script *> out;
-            const auto &blocks = target->blocks();
-
-            for (auto block : blocks) {
-                if (block->opcode() == "event_whenflagclicked") {
-                    assert(block->topLevel());
-                    assert(m_scripts.find(block) != m_scripts.cend());
-                    out.push_back(m_scripts[block].get());
-                }
-            }
-
-            return out;
-        }
+        case HatType::GreenFlag:
+            return m_greenFlagHats[target];
 
         case HatType::BroadcastReceived:
             return m_broadcastHats[target];
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index ac2a7ffd..1b97e433 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -109,6 +109,7 @@ class Engine : public IEngine
         int findBroadcast(const std::string &broadcastName) const override;
         int findBroadcastById(const std::string &broadcastId) const override;
 
+        void addGreenFlagScript(std::shared_ptr<Block> hatBlock) override;
         void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) override;
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
         void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) override;
@@ -193,6 +194,7 @@ class Engine : public IEngine
         std::vector<BlockFunc> m_functions;
         std::recursive_mutex m_eventLoopMutex;
 
+        std::unordered_map<Target *, std::vector<Script *>> m_greenFlagHats;
         std::unordered_map<Target *, std::vector<Script *>> m_broadcastHats;
         std::unordered_map<Target *, std::vector<Script *>> m_cloneInitHats;
         std::unordered_map<Target *, std::vector<Script *>> m_whenKeyPressedHats;
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index f58512b4..f4555c3d 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -83,7 +83,7 @@ TEST_F(EventBlocksTest, CategoryVisible)
 TEST_F(EventBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addHatBlock(m_section.get(), "event_whenflagclicked"));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenflagclicked", &EventBlocks::compileWhenFlagClicked));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcast", &EventBlocks::compileBroadcast));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcastandwait", &EventBlocks::compileBroadcastAndWait));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbroadcastreceived", &EventBlocks::compileWhenBroadcastReceived));
@@ -101,6 +101,26 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     m_section->registerBlocks(&m_engineMock);
 }
 
+TEST_F(EventBlocksTest, WhenFlagClicked)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = createEventBlock("a", "event_whenflagclicked");
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, addGreenFlagScript(block));
+    compiler.setBlock(block);
+    EventBlocks::compileWhenFlagClicked(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
 TEST_F(EventBlocksTest, Broadcast)
 {
     Compiler compiler(&m_engineMock);
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 5b735f9c..574976c9 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -91,6 +91,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(int, findBroadcast, (const std::string &), (const, override));
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, override));
 
+        MOCK_METHOD(void, addGreenFlagScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Broadcast *), (override));
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, std::string), (override));

From af0377763d2a19b9e7f1c1c6b21337a607ebedd5 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 17:26:51 +0100
Subject: [PATCH 09/17] Add backdrop change script map to Engine

---
 include/scratchcpp/iengine.h      |  3 +++
 src/blocks/eventblocks.cpp        |  2 +-
 src/engine/internal/engine.cpp    | 36 ++++++++++++++-----------------
 src/engine/internal/engine.h      |  4 +++-
 test/blocks/event_blocks_test.cpp |  2 ++
 test/mocks/enginemock.h           |  1 +
 6 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 9c9fa7bb..a2747ac3 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -251,6 +251,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Registers the broadcast script. */
         virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) = 0;
 
+        /*! Registers the backdrop change script. */
+        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /* Registers the given "when I start as clone" script. */
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
 
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index faa8df92..fed9774c 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -82,7 +82,7 @@ void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 
 void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
 {
-    // TODO: Register this hat in engine
+    compiler->engine()->addBackdropChangeScript(compiler->block());
 }
 
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 303787cd..aca00d0d 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -588,8 +588,10 @@ bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceS
                 assert(it != m_scripts.end());
                 auto topBlock = it->first;
 
-                // TODO: Add a map for "when backdrop switches to" hats
-                if ((topBlock->opcode() == "event_whenbackdropswitchesto") && (topBlock->findFieldById(EventBlocks::BACKDROP)->value().toString() == broadcast->name()))
+                const auto &scripts = m_backdropChangeHats[script->target()];
+                auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+
+                if ((scriptIt != scripts.end()) && (topBlock->findFieldById(EventBlocks::BACKDROP)->value().toString() == broadcast->name()))
                     return true;
             }
         }
@@ -760,6 +762,11 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadc
     addHatToMap(m_broadcastHats, script);
 }
 
+void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock)
+{
+    addHatToMap(m_backdropChangeHats, m_scripts[hatBlock].get());
+}
+
 void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
 {
     addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
@@ -1078,7 +1085,7 @@ void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &ma
         map[target] = { script };
 }
 
-std::vector<Script *> Engine::getHats(Target *target, HatType type)
+const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
 {
     assert(target);
 
@@ -1098,21 +1105,8 @@ std::vector<Script *> Engine::getHats(Target *target, HatType type)
         case HatType::BroadcastReceived:
             return m_broadcastHats[target];
 
-        case HatType::BackdropChanged: {
-            // TODO: Add a map for "when backdrop switches to" hats and return reference
-            std::vector<Script *> out;
-            const auto &blocks = target->blocks();
-
-            for (auto block : blocks) {
-                if (block->opcode() == "event_whenbackdropswitchesto") {
-                    assert(block->topLevel());
-                    assert(m_scripts.find(block) != m_scripts.cend());
-                    out.push_back(m_scripts[block].get());
-                }
-            }
-
-            return out;
-        }
+        case HatType::BackdropChanged:
+            return m_backdropChangeHats[target];
 
         case HatType::CloneInit:
             return m_cloneInitHats[target];
@@ -1120,8 +1114,10 @@ std::vector<Script *> Engine::getHats(Target *target, HatType type)
         case HatType::KeyPressed:
             return m_whenKeyPressedHats[target];
 
-        default:
-            return {};
+        default: {
+            static const std::vector<Script *> empty = {};
+            return empty;
+        }
     }
 }
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 1b97e433..30870d0f 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -111,6 +111,7 @@ class Engine : public IEngine
 
         void addGreenFlagScript(std::shared_ptr<Block> hatBlock) override;
         void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) override;
+        void addBackdropChangeScript(std::shared_ptr<Block> hatBlock) override;
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
         void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) override;
 
@@ -163,7 +164,7 @@ class Engine : public IEngine
         std::shared_ptr<IBlockSection> blockSection(const std::string &opcode) const;
 
         void addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script);
-        std::vector<Script *> getHats(Target *target, HatType type);
+        const std::vector<libscratchcpp::Script *> &getHats(Target *target, HatType type);
 
         void updateSpriteLayerOrder();
 
@@ -195,6 +196,7 @@ class Engine : public IEngine
         std::recursive_mutex m_eventLoopMutex;
 
         std::unordered_map<Target *, std::vector<Script *>> m_greenFlagHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_backdropChangeHats;
         std::unordered_map<Target *, std::vector<Script *>> m_broadcastHats;
         std::unordered_map<Target *, std::vector<Script *>> m_cloneInitHats;
         std::unordered_map<Target *, std::vector<Script *>> m_whenKeyPressedHats;
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index f4555c3d..45de8f3f 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -310,6 +310,8 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     auto backdrop = std::make_shared<Costume>("backdrop2", "a", "svg");
     stage.addCostume(backdrop);
 
+    EXPECT_CALL(m_engineMock, addBackdropChangeScript(block1));
+
     compiler.init();
     compiler.setBlock(block1);
     EventBlocks::compileWhenBackdropSwitchesTo(&compiler);
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 574976c9..39ec92a2 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -93,6 +93,7 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(void, addGreenFlagScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Broadcast *), (override));
+        MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, std::string), (override));
 

From 3c8b34fa1a4c535d93898ee78c1b5c1191e9a449 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 17:34:12 +0100
Subject: [PATCH 10/17] Remove script assertion from Engine::addHatToMap()

---
 src/engine/internal/engine.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index aca00d0d..d4d82a16 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1070,7 +1070,9 @@ std::shared_ptr<IBlockSection> Engine::blockSection(const std::string &opcode) c
 
 void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script)
 {
-    assert(script);
+    if (!script)
+        return;
+
     assert(script->target());
     Target *target = script->target();
     auto it = map.find(target);

From 2b8d503d3363449feebdc4b4d96a30b72d596dfd Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 17:45:55 +0100
Subject: [PATCH 11/17] Remove obsolete parameters from broadcast methods

---
 include/scratchcpp/iengine.h      | 8 ++++----
 src/blocks/eventblocks.cpp        | 8 ++++----
 src/engine/internal/engine.cpp    | 6 +++---
 src/engine/internal/engine.h      | 4 ++--
 test/blocks/event_blocks_test.cpp | 8 ++++----
 test/mocks/enginemock.h           | 4 ++--
 6 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index a2747ac3..6497acd1 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -56,11 +56,11 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Starts a script with the given top level block as the given Target (a sprite or the stage). */
         virtual VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
 
-        /*! Starts the script of the broadcast with the given index. */
-        virtual void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) = 0;
+        /*! Starts the scripts of the broadcast with the given index. */
+        virtual void broadcast(unsigned int index) = 0;
 
-        /*! Starts the script of the given broadcast. */
-        virtual void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) = 0;
+        /*! Starts the scripts of the given broadcast. */
+        virtual void broadcastByPtr(Broadcast *broadcast) = 0;
 
         /*! Starts the "when backdrop switches to" scripts for the given backdrop broadcast. */
         virtual void startBackdropScripts(Broadcast *broadcast) = 0;
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index fed9774c..63ed12be 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -93,25 +93,25 @@ void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
 
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm);
+    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
     return 1;
 }
 
 unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm);
+    vm->engine()->broadcast(vm->getInput(0, 1)->toLong());
     return 1;
 }
 
 unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm, true);
+    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
     return 1;
 }
 
 unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm, true);
+    vm->engine()->broadcast(vm->getInput(0, 1)->toLong());
     return 1;
 }
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index d4d82a16..dff6b5d6 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -195,15 +195,15 @@ VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target
     return pushThread(topLevelBlock, target).get();
 }
 
-void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait)
+void Engine::broadcast(unsigned int index)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return;
 
-    broadcastByPtr(m_broadcasts[index].get(), sourceScript, wait);
+    broadcastByPtr(m_broadcasts[index].get());
 }
 
-void Engine::broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait)
+void Engine::broadcastByPtr(Broadcast *broadcast)
 {
     startHats(HatType::BroadcastReceived, { { EventBlocks::Fields::BROADCAST_OPTION, broadcast->name() } }, nullptr);
 }
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 30870d0f..43e70a2b 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -33,8 +33,8 @@ class Engine : public IEngine
         void start() override;
         void stop() override;
         VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *target) override;
-        void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) override;
-        void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) override;
+        void broadcast(unsigned int index) override;
+        void broadcastByPtr(Broadcast *broadcast) override;
         void startBackdropScripts(Broadcast *broadcast) override;
         void stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 45de8f3f..7cf567c7 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -165,14 +165,14 @@ TEST_F(EventBlocksTest, BroadcastImpl)
     vm.setConstValues(constValues);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1, &vm, false)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
 
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, broadcast(2, &vm, false)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(2)).Times(1);
 
     vm.setBytecode(bytecode2);
     vm.run();
@@ -230,7 +230,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     vm.setConstValues(constValues);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1, &vm, true)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
 
     vm.setBytecode(bytecode1);
     vm.run();
@@ -254,7 +254,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(vm.atEnd(), true);
 
-    EXPECT_CALL(m_engineMock, broadcast(3, &vm, true)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(3)).Times(1);
 
     vm.setBytecode(bytecode3);
     vm.run();
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 39ec92a2..5128fbf1 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -17,8 +17,8 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, start, (), (override));
         MOCK_METHOD(void, stop, (), (override));
         MOCK_METHOD(VirtualMachine *, startScript, (std::shared_ptr<Block>, Target *), (override));
-        MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
-        MOCK_METHOD(void, broadcastByPtr, (Broadcast *, VirtualMachine *, bool), (override));
+        MOCK_METHOD(void, broadcast, (unsigned int), (override));
+        MOCK_METHOD(void, broadcastByPtr, (Broadcast *), (override));
         MOCK_METHOD(void, startBackdropScripts, (Broadcast *), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));

From 4c21c196860fa792bc1b088bd89757cceeb8e3b1 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 17:57:53 +0100
Subject: [PATCH 12/17] Remove obsolete parameters from broadcast running
 methods

---
 include/scratchcpp/iengine.h      |  4 +-
 src/blocks/eventblocks.cpp        |  4 +-
 src/blocks/looksblocks.cpp        |  2 +-
 src/engine/internal/engine.cpp    |  6 +--
 src/engine/internal/engine.h      |  4 +-
 test/blocks/event_blocks_test.cpp |  8 ++--
 test/blocks/looks_blocks_test.cpp | 70 +++++++++++++++----------------
 test/mocks/enginemock.h           |  4 +-
 8 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 6497acd1..19b6e102 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -177,10 +177,10 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void setSpriteFencingEnabled(bool enable) = 0;
 
         /*! Returns true if there are any running script of the broadcast with the given index. */
-        virtual bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) = 0;
+        virtual bool broadcastRunning(unsigned int index) = 0;
 
         /*! Returns true if there are any running script of the given broadcast. */
-        virtual bool broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript) = 0;
+        virtual bool broadcastByPtrRunning(Broadcast *broadcast) = 0;
 
         /*!
          * Call this from a block implementation to force a redraw (screen refresh).
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 63ed12be..12642d02 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -117,14 +117,14 @@ unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
 
 unsigned int EventBlocks::checkBroadcast(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm))
+    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString())))
         vm->stop(true, true, true);
     return 1;
 }
 
 unsigned int EventBlocks::checkBroadcastByIndex(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong(), vm))
+    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong()))
         vm->stop(true, true, true);
     return 1;
 }
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index 18cca774..ab5290c0 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -898,7 +898,7 @@ unsigned int LooksBlocks::checkBackdropScripts(VirtualMachine *vm)
         long index = vm->getInput(0, 1)->toLong() - 1;
         assert(stage->costumes().size() == 0 || index >= 0);
 
-        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->costumeAt(index)->broadcast(), vm))
+        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->costumeAt(index)->broadcast()))
             vm->stop(true, true, true);
     }
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index dff6b5d6..f04d7e35 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -566,15 +566,15 @@ void Engine::setSpriteFencingEnabled(bool enable)
     m_spriteFencingEnabled = enable;
 }
 
-bool Engine::broadcastRunning(unsigned int index, VirtualMachine *sourceScript)
+bool Engine::broadcastRunning(unsigned int index)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return false;
 
-    return broadcastByPtrRunning(m_broadcasts[index].get(), sourceScript);
+    return broadcastByPtrRunning(m_broadcasts[index].get());
 }
 
-bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript)
+bool Engine::broadcastByPtrRunning(Broadcast *broadcast)
 {
     if (broadcast->isBackdropBroadcast()) {
         // This broadcast belongs to a backdrop
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 43e70a2b..065e28dd 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -85,8 +85,8 @@ class Engine : public IEngine
         bool spriteFencingEnabled() const override;
         void setSpriteFencingEnabled(bool enable) override;
 
-        bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) override;
-        bool broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript) override;
+        bool broadcastRunning(unsigned int index) override;
+        bool broadcastByPtrRunning(Broadcast *broadcast) override;
 
         void requestRedraw() override;
 
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 7cf567c7..830495c5 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -238,7 +238,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 0);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, broadcastRunning(2, &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
 
     vm.setBytecode(bytecode2);
     vm.run();
@@ -247,7 +247,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.atEnd(), false);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, broadcastRunning(2, &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(false));
 
     vm.run();
 
@@ -261,7 +261,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, broadcastRunning(3, &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(true));
 
     vm.setBytecode(bytecode4);
     vm.run();
@@ -269,7 +269,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.atEnd(), false);
 
-    EXPECT_CALL(m_engineMock, broadcastRunning(3, &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(false));
 
     vm.run();
 
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index 3e7a301b..a9eb1e24 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -2072,7 +2072,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // "backdrop2"
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode1);
     vm.run();
 
@@ -2081,7 +2081,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2090,7 +2090,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 0
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode2);
     vm.run();
 
@@ -2099,7 +2099,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2109,7 +2109,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2120,7 +2120,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 1
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode3);
     vm.run();
 
@@ -2131,7 +2131,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 2
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode4);
     vm.run();
 
@@ -2141,7 +2141,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 3
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode5);
     vm.run();
 
@@ -2157,7 +2157,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode6);
     vm.run();
 
@@ -2167,7 +2167,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // "next backdrop"
     EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode7);
     vm.run();
 
@@ -2176,7 +2176,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2184,7 +2184,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2193,7 +2193,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2204,7 +2204,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2214,7 +2214,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // "previous backdrop"
     EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode8);
     vm.run();
 
@@ -2223,7 +2223,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(false));
     stage.setCostumeIndex(2); // checkBackdropScripts() should still check index 3 even after changing the backdrop
     vm.run();
     stage.setCostumeIndex(3);
@@ -2233,7 +2233,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2244,7 +2244,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2255,7 +2255,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2267,7 +2267,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode9);
     vm.run();
 
@@ -2276,7 +2276,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2285,7 +2285,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 0 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode10);
     vm.run();
 
@@ -2296,7 +2296,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 5 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode11);
     vm.run();
 
@@ -2306,7 +2306,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // 6 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode12);
     vm.run();
 
@@ -2391,7 +2391,7 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 1);
@@ -2399,7 +2399,7 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2407,7 +2407,7 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2417,7 +2417,7 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2485,7 +2485,7 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 1);
@@ -2493,7 +2493,7 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2501,7 +2501,7 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2511,7 +2511,7 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2598,7 +2598,7 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.reset();
     vm.run();
 
@@ -2607,7 +2607,7 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2618,7 +2618,7 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
     EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 5128fbf1..c9941f3a 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -69,8 +69,8 @@ class EngineMock : public IEngine
         MOCK_METHOD(bool, spriteFencingEnabled, (), (const, override));
         MOCK_METHOD(void, setSpriteFencingEnabled, (bool), (override));
 
-        MOCK_METHOD(bool, broadcastRunning, (unsigned int, VirtualMachine *), (override));
-        MOCK_METHOD(bool, broadcastByPtrRunning, (Broadcast *, VirtualMachine *), (override));
+        MOCK_METHOD(bool, broadcastRunning, (unsigned int), (override));
+        MOCK_METHOD(bool, broadcastByPtrRunning, (Broadcast *), (override));
 
         MOCK_METHOD(void, requestRedraw, (), (override));
 

From 706254aeb1d4b2187af27ca811a7a7915dca374c Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 18:04:41 +0100
Subject: [PATCH 13/17] Remove obsolete key name parameter from
 IEngine::addKeyPressScript()

---
 include/scratchcpp/iengine.h      | 2 +-
 src/blocks/eventblocks.cpp        | 2 +-
 src/engine/internal/engine.cpp    | 3 +--
 src/engine/internal/engine.h      | 2 +-
 test/blocks/event_blocks_test.cpp | 4 ++--
 test/mocks/enginemock.h           | 2 +-
 6 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 19b6e102..07119afa 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -258,7 +258,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /* Registers the given "when key pressed" script. */
-        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) = 0;
+        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 12642d02..70a78dff 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -88,7 +88,7 @@ void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
 {
     // NOTE: Field values don't have to be registered because keys are referenced by their names
-    compiler->engine()->addKeyPressScript(compiler->block(), compiler->field(KEY_OPTION)->value().toString());
+    compiler->engine()->addKeyPressScript(compiler->block());
 }
 
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index f04d7e35..91ad6a93 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -772,9 +772,8 @@ void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
     addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName)
+void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock)
 {
-    std::transform(keyName.begin(), keyName.end(), keyName.begin(), ::tolower);
     addHatToMap(m_whenKeyPressedHats, m_scripts[hatBlock].get());
 }
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 065e28dd..1fb39eeb 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -113,7 +113,7 @@ class Engine : public IEngine
         void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) override;
         void addBackdropChangeScript(std::shared_ptr<Block> hatBlock) override;
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
-        void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) override;
+        void addKeyPressScript(std::shared_ptr<Block> hatBlock) override;
 
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 830495c5..cadbc16a 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -337,11 +337,11 @@ TEST_F(EventBlocksTest, WhenKeyPressed)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, "a"));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block1));
     compiler.setBlock(block1);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, "left arrow"));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block2));
     compiler.setBlock(block2);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index c9941f3a..1dcda64a 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -95,7 +95,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Broadcast *), (override));
         MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
-        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, std::string), (override));
+        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>), (override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));

From 87a3db9e7371052da5d41a37dfdaf24c4edfcccb Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 18:55:26 +0100
Subject: [PATCH 14/17] Move concrete field IDs out of Engine

---
 include/scratchcpp/iengine.h      |  6 +--
 src/blocks/eventblocks.cpp        |  6 +--
 src/engine/internal/engine.cpp    | 80 +++++++++++++++++++++++--------
 src/engine/internal/engine.h      | 18 +++++--
 test/blocks/event_blocks_test.cpp |  8 ++--
 test/mocks/enginemock.h           |  6 +--
 6 files changed, 86 insertions(+), 38 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 07119afa..4bb0a045 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -249,16 +249,16 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /*! Registers the broadcast script. */
-        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) = 0;
+        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast) = 0;
 
         /*! Registers the backdrop change script. */
-        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId) = 0;
 
         /* Registers the given "when I start as clone" script. */
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /* Registers the given "when key pressed" script. */
-        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) = 0;
 
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 70a78dff..4edd07b7 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -77,18 +77,18 @@ void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 {
     auto broadcast = std::static_pointer_cast<Broadcast>(compiler->field(BROADCAST_OPTION)->valuePtr());
 
-    compiler->engine()->addBroadcastScript(compiler->block(), broadcast.get());
+    compiler->engine()->addBroadcastScript(compiler->block(), BROADCAST_OPTION, broadcast.get());
 }
 
 void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
 {
-    compiler->engine()->addBackdropChangeScript(compiler->block());
+    compiler->engine()->addBackdropChangeScript(compiler->block(), BACKDROP);
 }
 
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
 {
     // NOTE: Field values don't have to be registered because keys are referenced by their names
-    compiler->engine()->addKeyPressScript(compiler->block());
+    compiler->engine()->addKeyPressScript(compiler->block(), KEY_OPTION);
 }
 
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 91ad6a93..ffd9818a 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -24,7 +24,6 @@
 #include "timer.h"
 #include "clock.h"
 #include "blocks/standardblocks.h"
-#include "blocks/eventblocks.h"
 
 using namespace libscratchcpp;
 
@@ -205,12 +204,12 @@ void Engine::broadcast(unsigned int index)
 
 void Engine::broadcastByPtr(Broadcast *broadcast)
 {
-    startHats(HatType::BroadcastReceived, { { EventBlocks::Fields::BROADCAST_OPTION, broadcast->name() } }, nullptr);
+    startHats(HatType::BroadcastReceived, { { HatField::BroadcastOption, broadcast->name() } }, nullptr);
 }
 
 void Engine::startBackdropScripts(Broadcast *broadcast)
 {
-    startHats(HatType::BackdropChanged, { { EventBlocks::Fields::BACKDROP, broadcast->name() } }, nullptr);
+    startHats(HatType::BackdropChanged, { { HatField::Backdrop, broadcast->name() } }, nullptr);
 }
 
 void Engine::stopScript(VirtualMachine *vm)
@@ -472,8 +471,8 @@ void Engine::setKeyState(const KeyEvent &event, bool pressed)
 
     // Start "when key pressed" scripts
     if (pressed) {
-        startHats(HatType::KeyPressed, { { EventBlocks::Fields::KEY_OPTION, event.name() } }, nullptr);
-        startHats(HatType::KeyPressed, { { EventBlocks::Fields::KEY_OPTION, "any" } }, nullptr);
+        startHats(HatType::KeyPressed, { { HatField::KeyOption, event.name() } }, nullptr);
+        startHats(HatType::KeyPressed, { { HatField::KeyOption, "any" } }, nullptr);
     }
 }
 
@@ -483,7 +482,7 @@ void Engine::setAnyKeyPressed(bool pressed)
 
     // Start "when key pressed" scripts
     if (pressed)
-        startHats(HatType::KeyPressed, { { EventBlocks::Fields::KEY_OPTION, "any" } }, nullptr);
+        startHats(HatType::KeyPressed, { { HatField::KeyOption, "any" } }, nullptr);
 }
 
 double Engine::mouseX() const
@@ -590,9 +589,17 @@ bool Engine::broadcastByPtrRunning(Broadcast *broadcast)
 
                 const auto &scripts = m_backdropChangeHats[script->target()];
                 auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+                auto scriptFieldMapIt = m_scriptHatFields.find(script);
 
-                if ((scriptIt != scripts.end()) && (topBlock->findFieldById(EventBlocks::BACKDROP)->value().toString() == broadcast->name()))
-                    return true;
+                if (scriptFieldMapIt != m_scriptHatFields.cend()) {
+                    const auto &fieldMap = scriptFieldMapIt->second;
+                    auto fieldIt = fieldMap.find(HatField::Backdrop);
+                    assert(fieldIt != fieldMap.cend());
+                    assert(topBlock->findFieldById(fieldIt->second));
+
+                    if ((scriptIt != scripts.end()) && (topBlock->findFieldById(fieldIt->second)->value().toString() == broadcast->name()))
+                        return true;
+                }
             }
         }
     } else {
@@ -744,7 +751,7 @@ void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
     addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast)
+void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast)
 {
     assert(!broadcast->isBackdropBroadcast());
     Script *script = m_scripts[whenReceivedBlock].get();
@@ -760,11 +767,14 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadc
         m_broadcastMap[broadcast] = { script };
 
     addHatToMap(m_broadcastHats, script);
+    addHatField(script, HatField::BroadcastOption, fieldId);
 }
 
-void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock)
+void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId)
 {
-    addHatToMap(m_backdropChangeHats, m_scripts[hatBlock].get());
+    Script *script = m_scripts[hatBlock].get();
+    addHatToMap(m_backdropChangeHats, script);
+    addHatField(script, HatField::Backdrop, fieldId);
 }
 
 void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
@@ -772,9 +782,11 @@ void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
     addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock)
+void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId)
 {
-    addHatToMap(m_whenKeyPressedHats, m_scripts[hatBlock].get());
+    Script *script = m_scripts[hatBlock].get();
+    addHatToMap(m_whenKeyPressedHats, script);
+    addHatField(script, HatField::KeyOption, fieldId);
 }
 
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
@@ -1086,6 +1098,18 @@ void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &ma
         map[target] = { script };
 }
 
+void Engine::addHatField(Script *script, HatField field, int fieldId)
+{
+    auto it = m_scriptHatFields.find(script);
+
+    if (it == m_scriptHatFields.cend())
+        m_scriptHatFields[script] = { { field, fieldId } };
+    else {
+        auto &fieldMap = it->second;
+        fieldMap[field] = fieldId;
+    }
+}
+
 const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
 {
     assert(target);
@@ -1269,7 +1293,7 @@ void Engine::allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget)
         delete targetsPtr;
 }
 
-std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType, const std::unordered_map<int, std::string> &optMatchFields, Target *optTarget)
+std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::string> &optMatchFields, Target *optTarget)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1818-L1889
     std::vector<std::shared_ptr<VirtualMachine>> newThreads;
@@ -1282,14 +1306,28 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType,
             assert(it != m_scripts.end());
             auto topBlock = it->first;
 
-            // Match any requested fields
-            for (const auto &[fieldId, fieldValue] : optMatchFields) {
-                assert(fieldId > -1);
-                assert(topBlock->findFieldById(fieldId));
+            if (!optMatchFields.empty()) {
+                // Get the field map for this script
+                auto fieldMapIt = m_scriptHatFields.find(script);
+                assert(fieldMapIt != m_scriptHatFields.cend());
+
+                if (fieldMapIt != m_scriptHatFields.cend()) {
+                    const auto &fieldMap = fieldMapIt->second;
 
-                if (topBlock->findFieldById(fieldId)->value().toString() != fieldValue) {
-                    // Field mismatch
-                    return;
+                    // Match any requested fields
+                    for (const auto &[fieldId, fieldValue] : optMatchFields) {
+                        auto fieldIt = fieldMap.find(fieldId);
+                        assert(fieldIt != fieldMap.cend());
+
+                        if (fieldIt != fieldMap.cend()) {
+                            assert(topBlock->findFieldById(fieldIt->second));
+
+                            if (topBlock->findFieldById(fieldIt->second)->value().toString() != fieldValue) {
+                                // Field mismatch
+                                return;
+                            }
+                        }
+                    }
                 }
             }
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 1fb39eeb..545d8006 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -110,10 +110,10 @@ class Engine : public IEngine
         int findBroadcastById(const std::string &broadcastId) const override;
 
         void addGreenFlagScript(std::shared_ptr<Block> hatBlock) override;
-        void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) override;
-        void addBackdropChangeScript(std::shared_ptr<Block> hatBlock) override;
+        void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast) override;
+        void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
-        void addKeyPressScript(std::shared_ptr<Block> hatBlock) override;
+        void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
 
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
@@ -148,6 +148,13 @@ class Engine : public IEngine
             KeyPressed
         };
 
+        enum class HatField
+        {
+            BroadcastOption,
+            Backdrop,
+            KeyOption
+        };
+
         void step();
         std::vector<std::shared_ptr<VirtualMachine>> stepThreads();
         void stepThread(std::shared_ptr<VirtualMachine> thread);
@@ -164,6 +171,7 @@ class Engine : public IEngine
         std::shared_ptr<IBlockSection> blockSection(const std::string &opcode) const;
 
         void addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script);
+        void addHatField(Script *script, HatField field, int fieldId);
         const std::vector<libscratchcpp::Script *> &getHats(Target *target, HatType type);
 
         void updateSpriteLayerOrder();
@@ -178,7 +186,7 @@ class Engine : public IEngine
         template<typename F>
         void allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget);
 
-        std::vector<std::shared_ptr<VirtualMachine>> startHats(HatType hatType, const std::unordered_map<int, std::string> &optMatchFields, Target *optTarget);
+        std::vector<std::shared_ptr<VirtualMachine>> startHats(HatType hatType, const std::unordered_map<HatField, std::string> &optMatchFields, Target *optTarget);
 
         static const std::unordered_map<HatType, bool> m_hatRestartExistingThreads; // used to check whether a hat should restart existing threads
 
@@ -201,6 +209,8 @@ class Engine : public IEngine
         std::unordered_map<Target *, std::vector<Script *>> m_cloneInitHats;
         std::unordered_map<Target *, std::vector<Script *>> m_whenKeyPressedHats;
 
+        std::unordered_map<Script *, std::unordered_map<HatField, int>> m_scriptHatFields; // HatField, field ID from the block implementation
+
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;
         double m_fps = 30;                         // default FPS
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index cadbc16a..60cbb47b 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -285,7 +285,7 @@ TEST_F(EventBlocksTest, WhenBroadcastReceived)
     auto block1 = createEventBlock("a", "event_whenbroadcastreceived");
     addBroadcastField(block1, "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION, m_broadcast);
 
-    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, m_broadcast.get())).Times(1);
+    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, EventBlocks::BROADCAST_OPTION, m_broadcast.get())).Times(1);
 
     compiler.init();
     compiler.setBlock(block1);
@@ -310,7 +310,7 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     auto backdrop = std::make_shared<Costume>("backdrop2", "a", "svg");
     stage.addCostume(backdrop);
 
-    EXPECT_CALL(m_engineMock, addBackdropChangeScript(block1));
+    EXPECT_CALL(m_engineMock, addBackdropChangeScript(block1, EventBlocks::BACKDROP));
 
     compiler.init();
     compiler.setBlock(block1);
@@ -337,11 +337,11 @@ TEST_F(EventBlocksTest, WhenKeyPressed)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block1));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, EventBlocks::KEY_OPTION));
     compiler.setBlock(block1);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block2));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, EventBlocks::KEY_OPTION));
     compiler.setBlock(block2);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 1dcda64a..19d24ff5 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -92,10 +92,10 @@ class EngineMock : public IEngine
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, override));
 
         MOCK_METHOD(void, addGreenFlagScript, (std::shared_ptr<Block>), (override));
-        MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Broadcast *), (override));
-        MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>), (override));
+        MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, int, Broadcast *), (override));
+        MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>, int), (override));
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
-        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>), (override));
+        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, int), (override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));

From ce6c1e5dde19f9f9be670dd8578dbc287ae1d949 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 19:06:33 +0100
Subject: [PATCH 15/17] Add topBlock property to Script

---
 include/scratchcpp/script.h                   |  4 +++-
 src/engine/internal/engine.cpp                | 12 +++---------
 src/engine/script.cpp                         |  9 +++++++--
 src/engine/script_p.cpp                       |  3 ++-
 src/engine/script_p.h                         |  5 ++++-
 test/script/script_test.cpp                   | 15 +++++++++------
 test/virtual_machine/virtual_machine_test.cpp |  2 +-
 7 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index 78afd2d4..bd80c86e 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -12,6 +12,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class Block;
 class IEngine;
 class Value;
 class VirtualMachine;
@@ -23,10 +24,11 @@ class ScriptPrivate;
 class LIBSCRATCHCPP_EXPORT Script
 {
     public:
-        Script(Target *target, IEngine *engine);
+        Script(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine);
         Script(const Script &) = delete;
 
         Target *target() const;
+        std::shared_ptr<Block> topBlock() const;
 
         unsigned int *bytecode() const;
         const std::vector<unsigned int> &bytecodeVector() const;
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index ffd9818a..0fe620ec 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -120,7 +120,7 @@ void Engine::compile()
             if (block->topLevel() && !block->shadow()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
-                    auto script = std::make_shared<Script>(target.get(), this);
+                    auto script = std::make_shared<Script>(target.get(), block, this);
                     m_scripts[block] = script;
 
                     compiler.compile(block);
@@ -581,11 +581,8 @@ bool Engine::broadcastByPtrRunning(Broadcast *broadcast)
 
         for (auto thread : m_threads) {
             if (!thread->atEnd()) {
-                // TODO: Store the top block in Script
                 Script *script = thread->script();
-                auto it = std::find_if(m_scripts.begin(), m_scripts.end(), [script](const std::pair<std::shared_ptr<Block>, std::shared_ptr<Script>> pair) { return pair.second.get() == script; });
-                assert(it != m_scripts.end());
-                auto topBlock = it->first;
+                auto topBlock = script->topBlock();
 
                 const auto &scripts = m_backdropChangeHats[script->target()];
                 auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
@@ -1301,10 +1298,7 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType,
     allScriptsByOpcodeDo(
         hatType,
         [this, hatType, &optMatchFields, &newThreads](Script *script, Target *target) {
-            // TODO: Store the top block in Script
-            auto it = std::find_if(m_scripts.begin(), m_scripts.end(), [script](const std::pair<std::shared_ptr<Block>, std::shared_ptr<Script>> pair) { return pair.second.get() == script; });
-            assert(it != m_scripts.end());
-            auto topBlock = it->first;
+            auto topBlock = script->topBlock();
 
             if (!optMatchFields.empty()) {
                 // Get the field map for this script
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index 82afea52..52d4df6b 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -13,8 +13,8 @@
 using namespace libscratchcpp;
 
 /*! Constructs Script. */
-Script::Script(Target *target, IEngine *engine) :
-    impl(spimpl::make_unique_impl<ScriptPrivate>(target, engine))
+Script::Script(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine) :
+    impl(spimpl::make_unique_impl<ScriptPrivate>(target, topBlock, engine))
 {
 }
 
@@ -24,6 +24,11 @@ Target *Script::target() const
     return impl->target;
 }
 
+std::shared_ptr<Block> Script::topBlock() const
+{
+    return impl->topBlock;
+}
+
 /*! Returns the bytecode array. */
 unsigned int *Script::bytecode() const
 {
diff --git a/src/engine/script_p.cpp b/src/engine/script_p.cpp
index b4a9839e..fff08764 100644
--- a/src/engine/script_p.cpp
+++ b/src/engine/script_p.cpp
@@ -4,8 +4,9 @@
 
 using namespace libscratchcpp;
 
-ScriptPrivate::ScriptPrivate(Target *target, IEngine *engine) :
+ScriptPrivate::ScriptPrivate(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine) :
     target(target),
+    topBlock(topBlock),
     engine(engine)
 {
 }
diff --git a/src/engine/script_p.h b/src/engine/script_p.h
index f80e30ad..b21d6517 100644
--- a/src/engine/script_p.h
+++ b/src/engine/script_p.h
@@ -3,25 +3,28 @@
 #pragma once
 
 #include <vector>
+#include <memory>
 #include <scratchcpp/value.h>
 
 namespace libscratchcpp
 {
 
 class Target;
+class Block;
 class IEngine;
 class Variable;
 class List;
 
 struct ScriptPrivate
 {
-        ScriptPrivate(Target *target, IEngine *engine);
+        ScriptPrivate(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine);
         ScriptPrivate(const ScriptPrivate &) = delete;
 
         unsigned int *bytecode = nullptr;
         std::vector<unsigned int> bytecodeVector;
 
         Target *target = nullptr;
+        std::shared_ptr<Block> topBlock;
         IEngine *engine = nullptr;
 
         unsigned int **procedures = nullptr;
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 2847338f..760fa6f6 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/script.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/virtualmachine.h>
 #include <scratchcpp/target.h>
 #include <scratchcpp/sprite.h>
@@ -22,13 +23,15 @@ class ScriptTest : public testing::Test
 
 TEST_F(ScriptTest, Constructors)
 {
-    Script script(&m_target, &m_engine);
+    auto block = std::make_shared<Block>("", "");
+    Script script(&m_target, block, &m_engine);
     ASSERT_EQ(script.target(), &m_target);
+    ASSERT_EQ(script.topBlock(), block);
 }
 
 TEST_F(ScriptTest, Bytecode)
 {
-    Script script(nullptr, nullptr);
+    Script script(nullptr, nullptr, nullptr);
     ASSERT_EQ(script.bytecode(), nullptr);
     ASSERT_TRUE(script.bytecodeVector().empty());
 
@@ -58,7 +61,7 @@ TEST_F(ScriptTest, Start)
     std::shared_ptr<List> list2 = std::make_unique<List>("d", "");
     static std::vector<List *> lists = { list1.get(), list2.get() };
 
-    Script script1(nullptr, nullptr);
+    Script script1(nullptr, nullptr, nullptr);
 
     std::shared_ptr<VirtualMachine> vm = script1.start();
     ASSERT_TRUE(vm);
@@ -71,14 +74,14 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->variables(), nullptr);
     ASSERT_EQ(vm->lists(), nullptr);
 
-    Script script2(&m_target, &m_engine);
+    Script script2(&m_target, nullptr, &m_engine);
 
     vm = script2.start();
     ASSERT_TRUE(vm);
     ASSERT_EQ(vm->target(), &m_target);
     ASSERT_EQ(vm->engine(), &m_engine);
 
-    Script script3(&m_target, &m_engine);
+    Script script3(&m_target, nullptr, &m_engine);
     script3.setBytecode(bytecode);
     script3.setProcedures(procedures);
     script3.setFunctions(functions);
@@ -120,7 +123,7 @@ TEST_F(ScriptTest, Start)
     EXPECT_CALL(m_engine, requestRedraw());
     auto clone = root.clone();
 
-    Script script4(&root, &m_engine);
+    Script script4(&root, nullptr, &m_engine);
     script4.setBytecode(bytecode);
     script4.setProcedures(procedures);
     script4.setFunctions(functions);
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index 307dc5a4..587d562b 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -23,7 +23,7 @@ TEST(VirtualMachineTest, Constructors)
 
     Target target;
     Engine engine;
-    Script script(&target, &engine);
+    Script script(&target, nullptr, &engine);
     VirtualMachine vm2(&target, &engine, &script);
     ASSERT_EQ(vm2.target(), &target);
     ASSERT_EQ(vm2.engine(), &engine);

From be6c341e968c6fdefb48ba165de09fea8da6c2de Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 19:38:47 +0100
Subject: [PATCH 16/17] Add FPS limit

---
 src/engine/internal/engine.cpp |  6 ++++--
 test/engine/engine_test.cpp    | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 0fe620ec..744d03b1 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -422,8 +422,10 @@ double Engine::fps() const
 
 void Engine::setFps(double fps)
 {
-    m_fps = fps;
-    updateFrameDuration();
+    if (fps > 0) {
+        m_fps = std::min(fps, 250.0);
+        updateFrameDuration();
+    }
 }
 
 bool Engine::turboModeEnabled() const
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index f982a374..8b1e5438 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -87,6 +87,21 @@ TEST(EngineTest, Fps)
 
     engine.setFps(60.25);
     ASSERT_EQ(engine.fps(), 60.25);
+
+    engine.setFps(0);
+    ASSERT_EQ(engine.fps(), 60.25);
+
+    engine.setFps(-5);
+    ASSERT_EQ(engine.fps(), 60.25);
+
+    engine.setFps(250);
+    ASSERT_EQ(engine.fps(), 250);
+
+    engine.setFps(30);
+    ASSERT_EQ(engine.fps(), 30);
+
+    engine.setFps(300);
+    ASSERT_EQ(engine.fps(), 250);
 }
 
 TEST(EngineTest, FpsProject)

From c6954ec1a80333233b2c7e3fdd040cb5db4b0bb4 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 30 Dec 2023 19:55:08 +0100
Subject: [PATCH 17/17] Engine: Add support for matching field values by
 pointer

---
 src/engine/internal/engine.cpp | 23 ++++++++++++++++++-----
 src/engine/internal/engine.h   |  4 +++-
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 744d03b1..58df9aac 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -204,7 +204,7 @@ void Engine::broadcast(unsigned int index)
 
 void Engine::broadcastByPtr(Broadcast *broadcast)
 {
-    startHats(HatType::BroadcastReceived, { { HatField::BroadcastOption, broadcast->name() } }, nullptr);
+    startHats(HatType::BroadcastReceived, { { HatField::BroadcastOption, broadcast } }, nullptr);
 }
 
 void Engine::startBackdropScripts(Broadcast *broadcast)
@@ -1292,7 +1292,8 @@ void Engine::allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget)
         delete targetsPtr;
 }
 
-std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::string> &optMatchFields, Target *optTarget)
+std::vector<std::shared_ptr<VirtualMachine>>
+Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1818-L1889
     std::vector<std::shared_ptr<VirtualMachine>> newThreads;
@@ -1318,9 +1319,21 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::startHats(HatType hatType,
                         if (fieldIt != fieldMap.cend()) {
                             assert(topBlock->findFieldById(fieldIt->second));
 
-                            if (topBlock->findFieldById(fieldIt->second)->value().toString() != fieldValue) {
-                                // Field mismatch
-                                return;
+                            if (std::holds_alternative<std::string>(fieldValue)) {
+                                if (topBlock->findFieldById(fieldIt->second)->value().toString() != std::get<std::string>(fieldValue)) {
+                                    // Field mismatch
+                                    return;
+                                }
+                            } else if (std::holds_alternative<const char *>(fieldValue)) {
+                                if (topBlock->findFieldById(fieldIt->second)->value().toString() != std::string(std::get<const char *>(fieldValue))) {
+                                    // Field mismatch
+                                    return;
+                                }
+                            } else {
+                                if (topBlock->findFieldById(fieldIt->second)->valuePtr().get() != std::get<Entity *>(fieldValue)) {
+                                    // Field mismatch
+                                    return;
+                                }
                             }
                         }
                     }
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 545d8006..8bc4f47d 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -10,6 +10,7 @@
 #include <chrono>
 #include <mutex>
 #include <set>
+#include <variant>
 
 #include "blocksectioncontainer.h"
 
@@ -186,7 +187,8 @@ class Engine : public IEngine
         template<typename F>
         void allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget);
 
-        std::vector<std::shared_ptr<VirtualMachine>> startHats(HatType hatType, const std::unordered_map<HatField, std::string> &optMatchFields, Target *optTarget);
+        std::vector<std::shared_ptr<VirtualMachine>>
+        startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget);
 
         static const std::unordered_map<HatType, bool> m_hatRestartExistingThreads; // used to check whether a hat should restart existing threads