Merge pull request #264 from scratchcpp/event_whenkeypressed_block

Implement when key pressed block

Author: adazem009

include/scratchcpp/iengine.h

@@ -210,6 +210,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /* Registers the given "when I start as clone" script. */
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
 
+        /* Registers the given "when key pressed" script. */
+        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) = 0;
+
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
 

src/blocks/eventblocks.cpp

@@ -26,13 +26,15 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
     engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
     engine->addCompileFunction(this, "event_whenbackdropswitchesto", &compileWhenBackdropSwitchesTo);
+    engine->addCompileFunction(this, "event_whenkeypressed", &compileWhenKeyPressed);
 
     // Inputs
     engine->addInput(this, "BROADCAST_INPUT", BROADCAST_INPUT);
 
     // Fields
     engine->addField(this, "BROADCAST_OPTION", BROADCAST_OPTION);
     engine->addField(this, "BACKDROP", BACKDROP);
+    engine->addField(this, "KEY_OPTION", KEY_OPTION);
 }
 
 void EventBlocks::compileBroadcast(Compiler *compiler)
@@ -84,6 +86,12 @@ void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
     }
 }
 
+void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
+{
+    // NOTE: Field values don't have to be registered because keys are referenced by their names
+    compiler->engine()->addKeyPressScript(compiler->block(), compiler->field(KEY_OPTION)->value().toString());
+}
+
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
     vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm);

src/blocks/eventblocks.h

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

src/engine/internal/engine.cpp

@@ -620,6 +620,22 @@ void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
     }
 }
 
+void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName)
+{
+    std::transform(keyName.begin(), keyName.end(), keyName.begin(), ::tolower);
+    Script *script = m_scripts[hatBlock].get();
+    auto it = m_whenKeyPressedScripts.find(keyName);
+
+    if (it == m_whenKeyPressedScripts.cend())
+        m_whenKeyPressedScripts[keyName] = { script };
+    else {
+        auto &scripts = it->second;
+
+        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
+            scripts.push_back(script);
+    }
+}
+
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 {
     return m_targets;

src/engine/internal/engine.h

@@ -83,8 +83,8 @@ class Engine : public IEngine
         int findBroadcastById(const std::string &broadcastId) const 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;
 
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
@@ -120,6 +120,7 @@ class Engine : public IEngine
         std::unordered_map<Broadcast *, std::vector<Script *>> m_broadcastMap;
         std::unordered_map<Broadcast *, std::vector<std::pair<VirtualMachine *, VirtualMachine *>>> m_runningBroadcastMap; // source script, "when received" script
         std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;                                         // target (no clones), "when I start as a clone" scripts
+        std::unordered_map<std::string, std::vector<Script *>> m_whenKeyPressedScripts;                                    // key name, "when key pressed" scripts
         std::vector<std::string> m_extensions;
         std::vector<std::shared_ptr<VirtualMachine>> m_runningScripts;
         std::vector<VirtualMachine *> m_scriptsToRemove;

test/blocks/event_blocks_test.cpp

@@ -92,13 +92,15 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     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));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenkeypressed", &EventBlocks::compileWhenKeyPressed));
 
     // 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));
+    EXPECT_CALL(m_engineMock, addField(m_section.get(), "KEY_OPTION", EventBlocks::KEY_OPTION));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -271,3 +273,33 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
+
+TEST_F(EventBlocksTest, WhenKeyPressed)
+{
+    Compiler compiler(&m_engineMock);
+
+    // when key "a" pressed
+    auto block1 = createEventBlock("a", "event_whenkeypressed");
+    addValueField(block1, "KEY_OPTION", EventBlocks::KEY_OPTION, "a");
+
+    // when key "left arrow" pressed
+    auto block2 = createEventBlock("b", "event_whenkeypressed");
+    addValueField(block2, "KEY_OPTION", EventBlocks::KEY_OPTION, "left arrow");
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, "a"));
+    compiler.setBlock(block1);
+    EventBlocks::compileWhenKeyPressed(&compiler);
+
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, "left arrow"));
+    compiler.setBlock(block2);
+    EventBlocks::compileWhenKeyPressed(&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/mocks/enginemock.h

@@ -69,8 +69,8 @@ class EngineMock : public IEngine
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, 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));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));