Implement pen_penDown block

Author: adazem009

src/blocks/penblocks.cpp

@@ -19,13 +19,19 @@ void PenBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
     engine->addCompileFunction(this, "pen_clear", &compileClear);
+    engine->addCompileFunction(this, "pen_penDown", &compilePenDown);
 }
 
 void PenBlocks::compileClear(Compiler *compiler)
 {
     compiler->addFunctionCall(&clear);
 }
 
+void PenBlocks::compilePenDown(Compiler *compiler)
+{
+    compiler->addFunctionCall(&penDown);
+}
+
 unsigned int PenBlocks::clear(VirtualMachine *vm)
 {
     IPenLayer *penLayer = PenLayer::getProjectPenLayer(vm->engine());
@@ -37,3 +43,20 @@ unsigned int PenBlocks::clear(VirtualMachine *vm)
 
     return 0;
 }
+
+unsigned int PenBlocks::penDown(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(true);
+
+    return 0;
+}
+

src/blocks/penblocks.h

@@ -19,8 +19,10 @@ class PenBlocks : public libscratchcpp::IBlockSection
         void registerBlocks(libscratchcpp::IEngine *engine) override;
 
         static void compileClear(libscratchcpp::Compiler *compiler);
+        static void compilePenDown(libscratchcpp::Compiler *compiler);
 
         static unsigned int clear(libscratchcpp::VirtualMachine *vm);
+        static unsigned int penDown(libscratchcpp::VirtualMachine *vm);
 };
 
 } // namespace scratchcpprender

test/blocks/pen_blocks_test.cpp

@@ -2,6 +2,7 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <penlayer.h>
+#include <spritemodel.h>
 #include <blocks/penblocks.h>
 #include <enginemock.h>
 #include <penlayermock.h>
@@ -44,6 +45,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));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -84,3 +86,44 @@ TEST_F(PenBlocksTest, ClearImpl)
 
     ASSERT_EQ(vm.registerCount(), 0);
 }
+
+TEST_F(PenBlocksTest, PenDown)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "pen_penDown");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&PenBlocks::penDown)).WillOnce(Return(2));
+    compiler.init();
+    compiler.setBlock(block);
+    PenBlocks::compilePenDown(&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, PenDownImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &PenBlocks::penDown };
+
+    SpriteModel model;
+    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_TRUE(model.penDown());
+
+    vm.reset();
+    vm.run();
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_TRUE(model.penDown());
+}