Implement event_whenkeypressed block

Author: adazem009

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

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());
+}