Implement looks_say block

Author: adazem009

src/blocks/looksblocks.cpp

@@ -25,6 +25,7 @@ std::string LooksBlocks::name() const
 void LooksBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
+    engine->addCompileFunction(this, "looks_say", &compileSay);
     engine->addCompileFunction(this, "looks_show", &compileShow);
     engine->addCompileFunction(this, "looks_hide", &compileHide);
     engine->addCompileFunction(this, "looks_changeeffectby", &compileChangeEffectBy);
@@ -49,6 +50,7 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addMonitorNameFunction(this, "looks_size", &sizeMonitorName);
 
     // Inputs
+    engine->addInput(this, "MESSAGE", MESSAGE);
     engine->addInput(this, "CHANGE", CHANGE);
     engine->addInput(this, "SIZE", SIZE);
     engine->addInput(this, "COSTUME", COSTUME);
@@ -77,6 +79,12 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addFieldValue(this, "backward", Backward);
 }
 
+void LooksBlocks::compileSay(Compiler *compiler)
+{
+    compiler->addInput(MESSAGE);
+    compiler->addFunctionCall(&say);
+}
+
 void LooksBlocks::compileShow(Compiler *compiler)
 {
     compiler->addFunctionCall(&show);
@@ -515,6 +523,18 @@ const std::string &LooksBlocks::sizeMonitorName(Block *block)
     return name;
 }
 
+unsigned int LooksBlocks::say(VirtualMachine *vm)
+{
+    Target *target = vm->target();
+
+    if (target) {
+        target->setBubbleType(Target::BubbleType::Say);
+        target->setBubbleText(vm->getInput(0, 1)->toString());
+    }
+
+    return 1;
+}
+
 unsigned int LooksBlocks::show(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());

src/blocks/looksblocks.h

@@ -20,6 +20,7 @@ class LooksBlocks : public IBlockSection
     public:
         enum Inputs
         {
+            MESSAGE,
             CHANGE,
             SIZE,
             COSTUME,
@@ -57,6 +58,7 @@ class LooksBlocks : public IBlockSection
 
         void registerBlocks(IEngine *engine) override;
 
+        static void compileSay(Compiler *compiler);
         static void compileShow(Compiler *compiler);
         static void compileHide(Compiler *compiler);
         static void compileChangeEffectBy(Compiler *compiler);
@@ -79,6 +81,7 @@ class LooksBlocks : public IBlockSection
         static const std::string &backdropNumberNameMonitorName(Block *block);
         static const std::string &sizeMonitorName(Block *block);
 
+        static unsigned int say(VirtualMachine *vm);
         static unsigned int show(VirtualMachine *vm);
         static unsigned int hide(VirtualMachine *vm);
 

test/blocks/looks_blocks_test.cpp

@@ -104,6 +104,7 @@ TEST_F(LooksBlocksTest, CategoryVisible)
 TEST_F(LooksBlocksTest, RegisterBlocks)
 {
     // Blocks
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_say", &LooksBlocks::compileSay));
     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));
@@ -128,6 +129,7 @@ TEST_F(LooksBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "looks_size", &LooksBlocks::sizeMonitorName));
 
     // Inputs
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "MESSAGE", LooksBlocks::MESSAGE));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "CHANGE", LooksBlocks::CHANGE));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SIZE", LooksBlocks::SIZE));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "COSTUME", LooksBlocks::COSTUME));
@@ -158,6 +160,52 @@ TEST_F(LooksBlocksTest, RegisterBlocks)
     m_section->registerBlocks(&m_engineMock);
 }
 
+TEST_F(LooksBlocksTest, Say)
+{
+    Compiler compiler(&m_engineMock);
+
+    // say "Hello!"
+    auto block = std::make_shared<Block>("a", "looks_say");
+    addValueInput(block, "MESSAGE", LooksBlocks::MESSAGE, "Hello!");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::say)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    LooksBlocks::compileSay(&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(), "Hello!");
+}
+
+TEST_F(LooksBlocksTest, SayImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::say };
+    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::Say);
+    ASSERT_EQ(target.bubbleText(), "test");
+
+    target.setBubbleType(Target::BubbleType::Think);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
+    ASSERT_EQ(target.bubbleText(), "test");
+}
+
 TEST_F(LooksBlocksTest, Show)
 {
     Compiler compiler(&m_engineMock);