Implement sensing_answer block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -29,6 +29,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     // Blocks
     engine->addCompileFunction(this, "sensing_distanceto", &compileDistanceTo);
     engine->addCompileFunction(this, "sensing_askandwait", &compileAskAndWait);
+    engine->addCompileFunction(this, "sensing_answer", &compileAnswer);
     engine->addCompileFunction(this, "sensing_keypressed", &compileKeyPressed);
     engine->addCompileFunction(this, "sensing_mousedown", &compileMouseDown);
     engine->addCompileFunction(this, "sensing_mousex", &compileMouseX);
@@ -110,6 +111,11 @@ void SensingBlocks::compileAskAndWait(Compiler *compiler)
     compiler->addFunctionCall(&askAndWait);
 }
 
+void SensingBlocks::compileAnswer(Compiler *compiler)
+{
+    compiler->addFunctionCall(&answer);
+}
+
 void SensingBlocks::compileKeyPressed(Compiler *compiler)
 {
     compiler->addInput(KEY_OPTION);
@@ -531,6 +537,12 @@ unsigned int SensingBlocks::askAndWait(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int SensingBlocks::answer(VirtualMachine *vm)
+{
+    vm->addReturnValue(m_answer);
+    return 0;
+}
+
 unsigned int SensingBlocks::timer(VirtualMachine *vm)
 {
     vm->addReturnValue(vm->engine()->timer()->value());

src/blocks/sensingblocks.h

@@ -60,6 +60,7 @@ class SensingBlocks : public IBlockSection
 
         static void compileDistanceTo(Compiler *compiler);
         static void compileAskAndWait(Compiler *compiler);
+        static void compileAnswer(Compiler *compiler);
         static void compileKeyPressed(Compiler *compiler);
         static void compileMouseDown(Compiler *compiler);
         static void compileMouseX(Compiler *compiler);
@@ -92,6 +93,7 @@ class SensingBlocks : public IBlockSection
 
         static void onAnswer(const std::string &answer);
         static unsigned int askAndWait(VirtualMachine *vm);
+        static unsigned int answer(VirtualMachine *vm);
 
         static unsigned int timer(VirtualMachine *vm);
         static unsigned int resetTimer(VirtualMachine *vm);

test/blocks/sensing_blocks_test.cpp

@@ -123,6 +123,7 @@ TEST_F(SensingBlocksTest, RegisterBlocks)
     // Blocks
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_distanceto", &SensingBlocks::compileDistanceTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_askandwait", &SensingBlocks::compileAskAndWait));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_answer", &SensingBlocks::compileAnswer));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_keypressed", &SensingBlocks::compileKeyPressed));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousedown", &SensingBlocks::compileMouseDown));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousex", &SensingBlocks::compileMouseX));
@@ -343,12 +344,31 @@ TEST_F(SensingBlocksTest, AskAndWait)
     ASSERT_EQ(compiler.constValues()[0].toString(), "test");
 }
 
-TEST_F(SensingBlocksTest, AskAndWaitImpl)
+TEST_F(SensingBlocksTest, Answer)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sensing_answer");
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::answer)).WillOnce(Return(0));
+    compiler.setBlock(block);
+    SensingBlocks::compileAnswer(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
 {
     static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
     static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
     static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_HALT };
-    static BlockFunc functions[] = { &SensingBlocks::askAndWait };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::askAndWait, &SensingBlocks::answer };
     static Value constValues[] = { "test1", "test2", "test3" };
 
     Sprite sprite;
@@ -415,19 +435,40 @@ TEST_F(SensingBlocksTest, AskAndWaitImpl)
     ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
     ASSERT_EQ(sprite.bubbleText(), "test2");
 
+    vm1.reset();
+    vm1.setBytecode(bytecode4);
+    vm1.run();
+    ASSERT_EQ(vm1.registerCount(), 1);
+    ASSERT_EQ(vm1.getInput(0, 1)->toString(), "hi");
+
     EXPECT_CALL(m_engineMock, questionAsked()).WillOnce(ReturnRef(asked));
     EXPECT_CALL(spy, asked("test3"));
     SensingBlocks::onAnswer("hello");
     ASSERT_TRUE(sprite.bubbleText().empty());
 
+    vm1.reset();
+    vm1.run();
+    ASSERT_EQ(vm1.registerCount(), 1);
+    ASSERT_EQ(vm1.getInput(0, 1)->toString(), "hello");
+
     EXPECT_CALL(m_engineMock, questionAsked()).WillOnce(ReturnRef(asked));
     EXPECT_CALL(spy, asked("test2"));
     SensingBlocks::onAnswer("world");
     ASSERT_TRUE(sprite.bubbleText().empty());
     ASSERT_TRUE(stage.bubbleText().empty());
 
+    vm1.reset();
+    vm1.run();
+    ASSERT_EQ(vm1.registerCount(), 1);
+    ASSERT_EQ(vm1.getInput(0, 1)->toString(), "world");
+
     EXPECT_CALL(m_engineMock, questionAsked).Times(0);
     SensingBlocks::onAnswer("test");
+
+    vm1.reset();
+    vm1.run();
+    ASSERT_EQ(vm1.registerCount(), 1);
+    ASSERT_EQ(vm1.getInput(0, 1)->toString(), "test");
 }
 
 TEST_F(SensingBlocksTest, KeyPressed)