Implement pen_penUp block

Author: adazem009

src/blocks/penblocks.cpp

@@ -20,6 +20,7 @@ void PenBlocks::registerBlocks(IEngine *engine)
     // Blocks
     engine->addCompileFunction(this, "pen_clear", &compileClear);
     engine->addCompileFunction(this, "pen_penDown", &compilePenDown);
+    engine->addCompileFunction(this, "pen_penUp", &compilePenUp);
 }
 
 void PenBlocks::compileClear(Compiler *compiler)
@@ -32,6 +33,11 @@ void PenBlocks::compilePenDown(Compiler *compiler)
     compiler->addFunctionCall(&penDown);
 }
 
+void PenBlocks::compilePenUp(Compiler *compiler)
+{
+    compiler->addFunctionCall(&penUp);
+}
+
 unsigned int PenBlocks::clear(VirtualMachine *vm)
 {
     IPenLayer *penLayer = PenLayer::getProjectPenLayer(vm->engine());
@@ -60,3 +66,18 @@ unsigned int PenBlocks::penDown(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int PenBlocks::penUp(libscratchcpp::VirtualMachine *vm)
+{
+    Target *target = vm->target();
+
+    if (!target || target->isStage())
+        return 0;
+
+    Sprite *sprite = static_cast<Sprite *>(target);
+    SpriteModel *model = static_cast<SpriteModel *>(sprite->getInterface());
+
+    if (model)
+        model->setPenDown(false);
+
+    return 0;
+}

src/blocks/penblocks.h

@@ -20,9 +20,11 @@ class PenBlocks : public libscratchcpp::IBlockSection
 
         static void compileClear(libscratchcpp::Compiler *compiler);
         static void compilePenDown(libscratchcpp::Compiler *compiler);
+        static void compilePenUp(libscratchcpp::Compiler *compiler);
 
         static unsigned int clear(libscratchcpp::VirtualMachine *vm);
         static unsigned int penDown(libscratchcpp::VirtualMachine *vm);
+        static unsigned int penUp(libscratchcpp::VirtualMachine *vm);
 };
 
 } // namespace scratchcpprender

test/blocks/pen_blocks_test.cpp

@@ -46,6 +46,7 @@ TEST_F(PenBlocksTest, RegisterBlocks)
     // Blocks
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_clear", &PenBlocks::compileClear));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_penDown", &PenBlocks::compilePenDown));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_penUp", &PenBlocks::compilePenUp));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -127,3 +128,45 @@ TEST_F(PenBlocksTest, PenDownImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(model.penDown());
 }
+
+TEST_F(PenBlocksTest, PenUp)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "pen_penUp");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&PenBlocks::penUp)).WillOnce(Return(2));
+    compiler.init();
+    compiler.setBlock(block);
+    PenBlocks::compilePenUp(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(PenBlocksTest, PenUpImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &PenBlocks::penUp };
+
+    SpriteModel model;
+    model.setPenDown(true);
+    Sprite sprite;
+    sprite.setInterface(&model);
+
+    VirtualMachine vm(&sprite, &m_engineMock, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+
+    vm.run();
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_FALSE(model.penDown());
+
+    vm.reset();
+    vm.run();
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_FALSE(model.penDown());
+}