Implement event_broadcastandwait

Author: adazem009

src/dev/blocks/eventblocks.cpp

@@ -7,6 +7,7 @@
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/dev/executioncontext.h>
 #include <scratchcpp/thread.h>
+#include <scratchcpp/dev/compilerconstant.h>
 
 #include "eventblocks.h"
 
@@ -32,6 +33,7 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_whenbackdropswitchesto", &compileWhenBackdropSwitchesTo);
     engine->addCompileFunction(this, "event_whengreaterthan", &compileWhenGreaterThan);
     engine->addCompileFunction(this, "event_broadcast", &compileBroadcast);
+    engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
 }
 
 CompilerValue *EventBlocks::compileWhenTouchingObject(Compiler *compiler)
@@ -91,16 +93,25 @@ CompilerValue *EventBlocks::compileWhenGreaterThan(Compiler *compiler)
 CompilerValue *EventBlocks::compileBroadcast(Compiler *compiler)
 {
     auto input = compiler->addInput("BROADCAST_INPUT");
-    compiler->addFunctionCallWithCtx("event_broadcast", Compiler::StaticType::Void, { Compiler::StaticType::String }, { input });
+    auto wait = compiler->addConstValue(false);
+    compiler->addFunctionCallWithCtx("event_broadcast", Compiler::StaticType::Void, { Compiler::StaticType::String, Compiler::StaticType::Bool }, { input, wait });
     return nullptr;
 }
 
-extern "C" void event_broadcast(ExecutionContext *ctx, const char *name)
+CompilerValue *EventBlocks::compileBroadcastAndWait(Compiler *compiler)
+{
+    auto input = compiler->addInput("BROADCAST_INPUT");
+    auto wait = compiler->addConstValue(true);
+    compiler->addFunctionCallWithCtx("event_broadcast", Compiler::StaticType::Void, { Compiler::StaticType::String, Compiler::StaticType::Bool }, { input, wait });
+    return nullptr;
+}
+
+extern "C" void event_broadcast(ExecutionContext *ctx, const char *name, bool wait)
 {
     Thread *thread = ctx->thread();
     IEngine *engine = thread->engine();
     std::vector<int> broadcasts = engine->findBroadcasts(name);
 
     for (int index : broadcasts)
-        engine->broadcast(index, thread, false);
+        engine->broadcast(index, thread, wait);
 }

src/dev/blocks/eventblocks.h

@@ -24,6 +24,7 @@ class EventBlocks : public IExtension
         static CompilerValue *compileWhenBackdropSwitchesTo(Compiler *compiler);
         static CompilerValue *compileWhenGreaterThan(Compiler *compiler);
         static CompilerValue *compileBroadcast(Compiler *compiler);
+        static CompilerValue *compileBroadcastAndWait(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/event_blocks_test.cpp

@@ -182,3 +182,50 @@ TEST_F(EventBlocksTest, Broadcast)
         thread.run();
     }
 }
+
+TEST_F(EventBlocksTest, BroadcastAndWait)
+{
+    auto broadcast = std::make_shared<Broadcast>("", "test");
+    m_engine->setBroadcasts({ broadcast });
+
+    auto target = std::make_shared<Sprite>();
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    builder.addBlock("event_broadcastandwait");
+    builder.addEntityInput("BROADCAST_INPUT", "test", InputValue::Type::Broadcast, broadcast);
+    auto block1 = builder.currentBlock();
+
+    builder.addBlock("event_broadcastandwait");
+    builder.addNullObscuredInput("BROADCAST_INPUT");
+    auto block2 = builder.currentBlock();
+
+    block1->setNext(nullptr);
+    block2->setParent(nullptr);
+
+    {
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block1);
+        Script script(target.get(), block1, &m_engineMock);
+        script.setCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+
+        EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 1, 4 })));
+        EXPECT_CALL(m_engineMock, broadcast(1, &thread, true));
+        EXPECT_CALL(m_engineMock, broadcast(4, &thread, true));
+        thread.run();
+    }
+
+    {
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block2);
+        Script script(target.get(), block2, &m_engineMock);
+        script.setCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+
+        EXPECT_CALL(m_engineMock, findBroadcasts("0")).WillOnce(Return(std::vector<int>({ 5, 7, 8 })));
+        EXPECT_CALL(m_engineMock, broadcast(5, &thread, true));
+        EXPECT_CALL(m_engineMock, broadcast(7, &thread, true));
+        EXPECT_CALL(m_engineMock, broadcast(8, &thread, true));
+        thread.run();
+    }
+}