Implement broadcast and wait block

Author: adazem009

src/blocks/eventblocks.cpp

@@ -11,6 +11,7 @@ EventBlocks::EventBlocks()
     // Blocks
     addHatBlock("event_whenflagclicked");
     addCompileFunction("event_broadcast", &compileBroadcast);
+    addCompileFunction("event_broadcastandwait", &compileBroadcastAndWait);
     addCompileFunction("event_whenbroadcastreceived", &compileWhenBroadcastReceived);
 
     // Inputs
@@ -36,6 +37,22 @@ void EventBlocks::compileBroadcast(Compiler *compiler)
         compiler->addFunctionCall(&broadcast);
 }
 
+void EventBlocks::compileBroadcastAndWait(Compiler *compiler)
+{
+    auto input = compiler->input(BROADCAST_INPUT);
+    compiler->addInput(input);
+    if (input->type() != Input::Type::ObscuredShadow) {
+        input->primaryValue()->setValue(compiler->engine()->findBroadcast(input->primaryValue()->value().toString()));
+        compiler->addFunctionCall(&broadcastByIndex);
+        compiler->addInput(input);
+        compiler->addFunctionCall(&checkBroadcastByIndex);
+    } else {
+        compiler->addFunctionCall(&broadcast);
+        compiler->addInput(input);
+        compiler->addFunctionCall(&checkBroadcast);
+    }
+}
+
 void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 {
     auto broadcast = std::static_pointer_cast<Broadcast>(compiler->field(BROADCAST_OPTION)->valuePtr());
@@ -53,3 +70,17 @@ unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
     vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm);
     return 1;
 }
+
+unsigned int EventBlocks::checkBroadcast(VirtualMachine *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->stop(true, true, true);
+    return 1;
+}

src/blocks/eventblocks.h

@@ -26,11 +26,14 @@ class LIBSCRATCHCPP_EXPORT EventBlocks : public IBlockSection
         std::string name() const override;
 
         static void compileBroadcast(Compiler *compiler);
+        static void compileBroadcastAndWait(Compiler *compiler);
         static void compileWhenBroadcastReceived(Compiler *compiler);
 
     private:
         static unsigned int broadcast(VirtualMachine *vm);
         static unsigned int broadcastByIndex(VirtualMachine *vm);
+        static unsigned int checkBroadcast(VirtualMachine *vm);
+        static unsigned int checkBroadcastByIndex(VirtualMachine *vm);
 };
 
 } // namespace libscratchcpp

src/engine/engine.cpp

@@ -121,11 +121,19 @@ void Engine::frame()
         m_breakFrame = false;
 
         do {
+            std::string opcode;
+            for (auto const &[key, value] : m_scripts) {
+                if (value.get() == script)
+                    opcode = key->opcode();
+            }
             auto ret = script->run(m_scriptPositions[i]);
             if (script->savePos())
                 m_scriptPositions[i] = ret;
-            if (script->atEnd())
+            if (script->atEnd()) {
+                for (auto &[key, value] : m_broadcastMap)
+                    value.erase(std::remove(value.begin(), value.end(), script), value.end());
                 m_scriptsToRemove.push_back(script);
+            }
         } while (!script->atEnd() && !m_breakFrame);
     }
 
@@ -185,7 +193,7 @@ void Engine::startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<T
 /*! Starts the script of the broadcast with the given index. */
 void libscratchcpp::Engine::broadcast(unsigned int index, VirtualMachine *sourceScript)
 {
-    const std::vector<VirtualMachine *> scripts = m_broadcastMap[index];
+    const std::vector<VirtualMachine *> &scripts = m_broadcastMap[index];
     for (auto vm : scripts) {
         auto it = std::find(m_runningScripts.begin(), m_runningScripts.end(), vm);
         if (it != m_runningScripts.end()) {
@@ -256,6 +264,12 @@ void Engine::run()
     }
 }
 
+/*! Returns true if there are any running script of the broadcast with the given index. */
+bool Engine::broadcastRunning(unsigned int index)
+{
+    return !m_broadcastMap[index].empty();
+}
+
 /*!
  * Call this from a block implementation to force a "screen refresh".
  * \note This has no effect in "run without screen refresh" custom blocks.

src/engine/engine.h

@@ -40,6 +40,8 @@ class LIBSCRATCHCPP_EXPORT Engine
         void stopTarget(Target *target, VirtualMachine *exceptScript);
         void run();
 
+        bool broadcastRunning(unsigned int index);
+
         void breakFrame();
         void stayOnCurrentBlock();
         void breakAtomicScript();

src/engine/virtualmachine.cpp

@@ -612,22 +612,27 @@ do_list_get_item : {
     FREE_REGS(1);
     DISPATCH();
 
-do_exec:
-    FREE_REGS(m_functions[*++pos](this));
+do_exec : {
+    auto ret = m_functions[*++pos](this);
     if (m_stop) {
         m_stop = false;
-        if (m_regCount > 0) {
-            std::cout << "warning: VM: " << m_regCount << " registers were leaked by the script; this is most likely a bug in the VM or in the compiler" << std::endl;
-        }
         m_callTree.clear();
         m_procedureArgTree.clear();
         m_procedureArgs = nullptr;
         m_nextProcedureArgs = nullptr;
         if (!m_atomic)
             m_engine->breakFrame();
+        if (m_goBack) {
+            m_goBack = false;
+            pos -= instruction_arg_count[OP_EXEC] + 1;
+            m_freeExecRegs = ret;
+        } else
+            FREE_REGS(ret);
         return pos;
     }
+    FREE_REGS(ret);
     DISPATCH();
+}
 
 do_init_procedure:
     m_procedureArgTree.push_back({});

src/engine/virtualmachine.h

@@ -115,12 +115,14 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
          * Use this to stop the script from a function.
          * \param[in] savePos Changes the return value of savePos().
          * \param[in] breakAtomic Whether to break the frame after stopping the script.
+         * \param[in] goBack Whether to go back so that the current instruction can run again in the future.
          */
-        void stop(bool savePos = true, bool breakAtomic = false)
+        void stop(bool savePos = true, bool breakAtomic = false, bool goBack = false)
         {
             m_stop = true;
             m_savePos = savePos;
             m_atomic = !breakAtomic;
+            m_goBack = goBack;
         }
 
         /*! Returns true if the VM has reached the vm::OP_HALT instruction. */
@@ -155,6 +157,8 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         bool m_atomic;
         bool m_stop = false;
         bool m_savePos = true;
+        bool m_goBack = false;
+        unsigned int m_freeExecRegs;
 
         unsigned int **m_procedures = nullptr;
         std::vector<unsigned int *> m_proceduresVector;