Add green flag script map to Engine

Author: adazem009

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;
 

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);

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);

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];

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;

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);

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));