Implement looks_think block

Author: adazem009

src/blocks/looksblocks.cpp

@@ -30,6 +30,7 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "looks_sayforsecs", &compileSayForSecs);
     engine->addCompileFunction(this, "looks_say", &compileSay);
     engine->addCompileFunction(this, "looks_thinkforsecs", &compileThinkForSecs);
+    engine->addCompileFunction(this, "looks_think", &compileThink);
     engine->addCompileFunction(this, "looks_show", &compileShow);
     engine->addCompileFunction(this, "looks_hide", &compileHide);
     engine->addCompileFunction(this, "looks_changeeffectby", &compileChangeEffectBy);
@@ -106,6 +107,12 @@ void LooksBlocks::compileThinkForSecs(Compiler *compiler)
     compiler->addFunctionCall(&thinkForSecs);
 }
 
+void LooksBlocks::compileThink(Compiler *compiler)
+{
+    compiler->addInput(MESSAGE);
+    compiler->addFunctionCall(&think);
+}
+
 void LooksBlocks::compileShow(Compiler *compiler)
 {
     compiler->addFunctionCall(&show);
@@ -646,6 +653,12 @@ unsigned int LooksBlocks::thinkForSecs(VirtualMachine *vm)
     return sayForSecs(vm); // there isn't any difference
 }
 
+unsigned int LooksBlocks::think(VirtualMachine *vm)
+{
+    showBubble(vm, Target::BubbleType::Think, vm->getInput(0, 1)->toString());
+    return 1;
+}
+
 unsigned int LooksBlocks::show(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());

src/blocks/looksblocks.h

@@ -65,6 +65,7 @@ class LooksBlocks : public IBlockSection
         static void compileSayForSecs(Compiler *compiler);
         static void compileSay(Compiler *compiler);
         static void compileThinkForSecs(Compiler *compiler);
+        static void compileThink(Compiler *compiler);
         static void compileShow(Compiler *compiler);
         static void compileHide(Compiler *compiler);
         static void compileChangeEffectBy(Compiler *compiler);
@@ -98,6 +99,7 @@ class LooksBlocks : public IBlockSection
 
         static unsigned int startThinkForSecs(VirtualMachine *vm);
         static unsigned int thinkForSecs(VirtualMachine *vm);
+        static unsigned int think(VirtualMachine *vm);
 
         static unsigned int show(VirtualMachine *vm);
         static unsigned int hide(VirtualMachine *vm);

test/blocks/looks_blocks_test.cpp

@@ -109,6 +109,7 @@ TEST_F(LooksBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_sayforsecs", &LooksBlocks::compileSayForSecs));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_say", &LooksBlocks::compileSay));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_thinkforsecs", &LooksBlocks::compileThinkForSecs));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_think", &LooksBlocks::compileThink));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_show", &LooksBlocks::compileShow));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_hide", &LooksBlocks::compileHide));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_changeeffectby", &LooksBlocks::compileChangeEffectBy));
@@ -395,9 +396,9 @@ TEST_F(LooksBlocksTest, ThinkForSecs)
 TEST_F(LooksBlocksTest, ThinkForSecsImpl)
 {
     static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    // static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 2, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 2, vm::OP_HALT };
     static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::startThinkForSecs, &LooksBlocks::thinkForSecs /*, &LooksBlocks::think*/ };
+    static BlockFunc functions[] = { &LooksBlocks::startThinkForSecs, &LooksBlocks::thinkForSecs, &LooksBlocks::think };
     static Value constValues[] = { "test", 5.5, "hello" };
 
     Target target;
@@ -452,7 +453,7 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_TRUE(target.bubbleText().empty());
 
     // Run the say block while waiting
-    /*VirtualMachine vm2(&target, &m_engineMock, nullptr);
+    VirtualMachine vm2(&target, &m_engineMock, nullptr);
     vm2.setFunctions(functions);
     vm2.setConstValues(constValues);
     vm2.setBytecode(bytecode2);
@@ -526,11 +527,57 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm2.atEnd());
     ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");*/
+    ASSERT_EQ(target.bubbleText(), "test");
 
     LooksBlocks::clock = Clock::instance().get();
 }
 
+TEST_F(LooksBlocksTest, Think)
+{
+    Compiler compiler(&m_engineMock);
+
+    // say "Hmm..."
+    auto block = std::make_shared<Block>("a", "looks_think");
+    addValueInput(block, "MESSAGE", LooksBlocks::MESSAGE, "Hmm...");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::think)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    LooksBlocks::compileThink(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0].toString(), "Hmm...");
+}
+
+TEST_F(LooksBlocksTest, ThinkImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::think };
+    static Value constValues[] = { "test" };
+
+    Target target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
+    ASSERT_EQ(target.bubbleText(), "test");
+
+    target.setBubbleType(Target::BubbleType::Say);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
+    ASSERT_EQ(target.bubbleText(), "test");
+}
+
 TEST_F(LooksBlocksTest, Show)
 {
     Compiler compiler(&m_engineMock);