Implement event_whenbroadcastreceived

Author: adazem009

src/dev/blocks/eventblocks.cpp

@@ -2,6 +2,9 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/field.h>
+#include <scratchcpp/broadcast.h>
 
 #include "eventblocks.h"
 
@@ -23,6 +26,7 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_whenflagclicked", &compileWhenFlagClicked);
     engine->addCompileFunction(this, "event_whenthisspriteclicked", &compileWhenThisSpriteClicked);
     engine->addCompileFunction(this, "event_whenstageclicked", &compileWhenStageClicked);
+    engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
 }
 
 CompilerValue *EventBlocks::compileWhenTouchingObject(Compiler *compiler)
@@ -48,3 +52,16 @@ CompilerValue *EventBlocks::compileWhenStageClicked(Compiler *compiler)
     compiler->engine()->addTargetClickScript(compiler->block());
     return nullptr;
 }
+
+CompilerValue *EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
+{
+    auto block = compiler->block();
+    Field *field = compiler->field("BROADCAST_OPTION");
+
+    if (field) {
+        auto broadcast = std::static_pointer_cast<Broadcast>(field->valuePtr());
+        compiler->engine()->addBroadcastScript(block, field, broadcast.get());
+    }
+
+    return nullptr;
+}

src/dev/blocks/eventblocks.h

@@ -20,6 +20,7 @@ class EventBlocks : public IExtension
         static CompilerValue *compileWhenFlagClicked(Compiler *compiler);
         static CompilerValue *compileWhenThisSpriteClicked(Compiler *compiler);
         static CompilerValue *compileWhenStageClicked(Compiler *compiler);
+        static CompilerValue *compileWhenBroadcastReceived(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/event_blocks_test.cpp

@@ -2,6 +2,8 @@
 #include <scratchcpp/dev/test/scriptbuilder.h>
 #include <scratchcpp/dev/compiler.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/broadcast.h>
+#include <scratchcpp/block.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -80,3 +82,20 @@ TEST_F(EventBlocksTest, WhenStageClicked)
     EXPECT_CALL(m_engineMock, addTargetClickScript(block));
     compiler.compile(block);
 }
+
+TEST_F(EventBlocksTest, WhenBroadcastReceived)
+{
+    auto broadcast = std::make_shared<Broadcast>("", "");
+    m_engine->setBroadcasts({ broadcast });
+
+    auto target = std::make_shared<Sprite>();
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    builder.addBlock("event_whenbroadcastreceived");
+    builder.addEntityField("BROADCAST_OPTION", broadcast);
+    auto block = builder.currentBlock();
+
+    Compiler compiler(&m_engineMock, target.get());
+    EXPECT_CALL(m_engineMock, addBroadcastScript(block, block->fieldAt(0).get(), broadcast.get()));
+    compiler.compile(block);
+}