Implement event_whenbackdropswitchesto block

Author: adazem009

src/blocks/eventblocks.cpp

@@ -6,6 +6,8 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/stage.h>
+#include <scratchcpp/costume.h>
 
 #include "eventblocks.h"
 
@@ -23,12 +25,14 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_broadcast", &compileBroadcast);
     engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
     engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
+    engine->addCompileFunction(this, "event_whenbackdropswitchesto", &compileWhenBackdropSwitchesTo);
 
     // Inputs
     engine->addInput(this, "BROADCAST_INPUT", BROADCAST_INPUT);
 
     // Fields
     engine->addField(this, "BROADCAST_OPTION", BROADCAST_OPTION);
+    engine->addField(this, "BACKDROP", BACKDROP);
 }
 
 void EventBlocks::compileBroadcast(Compiler *compiler)
@@ -69,6 +73,17 @@ void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
     compiler->engine()->addBroadcastScript(compiler->block(), broadcast.get());
 }
 
+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());
+    }
+}
+
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
     vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm);

src/blocks/eventblocks.h

@@ -21,7 +21,8 @@ class EventBlocks : public IBlockSection
 
         enum Fields
         {
-            BROADCAST_OPTION
+            BROADCAST_OPTION,
+            BACKDROP
         };
 
         std::string name() const override;
@@ -31,6 +32,7 @@ class EventBlocks : public IBlockSection
         static void compileBroadcast(Compiler *compiler);
         static void compileBroadcastAndWait(Compiler *compiler);
         static void compileWhenBroadcastReceived(Compiler *compiler);
+        static void compileWhenBackdropSwitchesTo(Compiler *compiler);
 
         static unsigned int broadcast(VirtualMachine *vm);
         static unsigned int broadcastByIndex(VirtualMachine *vm);

test/blocks/event_blocks_test.cpp

@@ -4,6 +4,8 @@
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/broadcast.h>
+#include <scratchcpp/stage.h>
+#include <scratchcpp/costume.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -50,6 +52,14 @@ class EventBlocksTest : public testing::Test
             block->updateInputMap();
         }
 
+        void addValueField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, const std::string &value) const
+        {
+            auto field = std::make_shared<Field>(name, value);
+            field->setFieldId(id);
+            block->addField(field);
+            block->updateFieldMap();
+        }
+
         void addBroadcastField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, std::shared_ptr<Broadcast> broadcast) const
         {
             auto field = std::make_shared<Field>(name, Value(), broadcast);
@@ -77,16 +87,18 @@ TEST_F(EventBlocksTest, CategoryVisible)
 TEST_F(EventBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addHatBlock(m_section.get(), "event_whenflagclicked")).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcast", &EventBlocks::compileBroadcast)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcastandwait", &EventBlocks::compileBroadcastAndWait)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbroadcastreceived", &EventBlocks::compileWhenBroadcastReceived)).Times(1);
+    EXPECT_CALL(m_engineMock, addHatBlock(m_section.get(), "event_whenflagclicked"));
+    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));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbackdropswitchesto", &EventBlocks::compileWhenBackdropSwitchesTo));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT)).Times(1);
 
     // Fields
     EXPECT_CALL(m_engineMock, addField(m_section.get(), "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION));
+    EXPECT_CALL(m_engineMock, addField(m_section.get(), "BACKDROP", EventBlocks::BACKDROP));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -233,3 +245,29 @@ TEST_F(EventBlocksTest, WhenBroadcastReceived)
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
+
+TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
+{
+    Compiler compiler(&m_engineMock);
+    Stage stage;
+
+    // when backdrop switches to "backdrop2"
+    auto block1 = createEventBlock("a", "event_whenbackdropswitchesto");
+    addValueField(block1, "BACKDROP", EventBlocks::BACKDROP, "backdrop2");
+
+    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);
+    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());
+}