Implement pen_penDown block

Author: adazem009

src/blocks/penblocks.cpp

@@ -32,6 +32,7 @@ void PenBlocks::registerBlocks(IEngine *engine)
 {
     engine->addCompileFunction(this, "pen_clear", &compileClear);
     engine->addCompileFunction(this, "pen_stamp", &compileStamp);
+    engine->addCompileFunction(this, "pen_penDown", &compilePenDown);
 }
 
 CompilerValue *PenBlocks::compileClear(Compiler *compiler)
@@ -46,6 +47,23 @@ CompilerValue *PenBlocks::compileStamp(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *PenBlocks::compilePenDown(Compiler *compiler)
+{
+    compiler->addTargetFunctionCall("pen_penDown");
+    return nullptr;
+}
+
+static TargetModel *getTargetModel(Target *target)
+{
+    if (target->isStage()) {
+        Stage *stage = static_cast<Stage *>(target);
+        return static_cast<StageModel *>(stage->getInterface());
+    } else {
+        Sprite *sprite = static_cast<Sprite *>(target);
+        return static_cast<SpriteModel *>(sprite->getInterface());
+    }
+}
+
 BLOCK_EXPORT void pen_clear(ExecutionContext *ctx)
 {
     IEngine *engine = ctx->engine();
@@ -77,3 +95,8 @@ BLOCK_EXPORT void pen_stamp(Target *target)
         engine->requestRedraw();
     }
 }
+
+BLOCK_EXPORT void pen_penDown(Target *target)
+{
+    getTargetModel(target)->setPenDown(true);
+}

src/blocks/penblocks.h

@@ -15,6 +15,7 @@ class PenBlocks : public libscratchcpp::IExtension
     private:
         static libscratchcpp::CompilerValue *compileClear(libscratchcpp::Compiler *compiler);
         static libscratchcpp::CompilerValue *compileStamp(libscratchcpp::Compiler *compiler);
+        static libscratchcpp::CompilerValue *compilePenDown(libscratchcpp::Compiler *compiler);
 };
 
 } // namespace scratchcpprender

test/blocks/pen_blocks_test.cpp

@@ -116,3 +116,55 @@ TEST_F(PenBlocksTest, Stamp_Stage)
     EXPECT_CALL(m_engineMock, requestRedraw());
     thread->run();
 }
+
+TEST_F(PenBlocksTest, PenDown_Sprite)
+{
+    auto sprite = std::make_shared<Sprite>();
+    sprite->setEngine(&m_engineMock);
+
+    RenderedTarget renderedTarget;
+    SpriteModel model;
+    model.init(sprite.get());
+    model.setRenderedTarget(&renderedTarget);
+    sprite->setInterface(&model);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, sprite);
+    builder.addBlock("pen_penDown");
+
+    auto thread = buildScript(builder, sprite.get());
+
+    model.setPenDown(false);
+
+    // EXPECT_CALL(m_engineMock, requestRedraw());
+    thread->run();
+    ASSERT_TRUE(model.penDown());
+
+    thread->run();
+    ASSERT_TRUE(model.penDown());
+}
+
+TEST_F(PenBlocksTest, PenDown_Stage)
+{
+    auto stage = std::make_shared<Stage>();
+    stage->setEngine(&m_engineMock);
+
+    RenderedTarget renderedTarget;
+    StageModel model;
+    model.init(stage.get());
+    model.setRenderedTarget(&renderedTarget);
+    stage->setInterface(&model);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, stage);
+    builder.addBlock("pen_penDown");
+
+    auto thread = buildScript(builder, stage.get());
+
+    model.setPenDown(false);
+
+    // EXPECT_CALL(m_engineMock, requestRedraw());
+    thread->run();
+    ASSERT_TRUE(model.penDown());
+
+    thread->run();
+    ASSERT_TRUE(model.penDown());
+}