Implement pen_penUp block

Author: adazem009

src/blocks/penblocks.cpp

@@ -4,6 +4,8 @@
 #include <scratchcpp/target.h>
 #include <scratchcpp/ispritehandler.h>
 #include <scratchcpp/istagehandler.h>
+#include <scratchcpp/value.h>
+#include <scratchcpp/compilerconstant.h>
 
 #include "penblocks.h"
 #include "penlayer.h"
@@ -33,6 +35,7 @@ void PenBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "pen_clear", &compileClear);
     engine->addCompileFunction(this, "pen_stamp", &compileStamp);
     engine->addCompileFunction(this, "pen_penDown", &compilePenDown);
+    engine->addCompileFunction(this, "pen_penUp", &compilePenUp);
 }
 
 CompilerValue *PenBlocks::compileClear(Compiler *compiler)
@@ -49,7 +52,15 @@ CompilerValue *PenBlocks::compileStamp(Compiler *compiler)
 
 CompilerValue *PenBlocks::compilePenDown(Compiler *compiler)
 {
-    compiler->addTargetFunctionCall("pen_penDown");
+    CompilerValue *arg = compiler->addConstValue(true);
+    compiler->addTargetFunctionCall("pen_set_pen_down", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { arg });
+    return nullptr;
+}
+
+CompilerValue *PenBlocks::compilePenUp(Compiler *compiler)
+{
+    CompilerValue *arg = compiler->addConstValue(false);
+    compiler->addTargetFunctionCall("pen_set_pen_down", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { arg });
     return nullptr;
 }
 
@@ -96,7 +107,7 @@ BLOCK_EXPORT void pen_stamp(Target *target)
     }
 }
 
-BLOCK_EXPORT void pen_penDown(Target *target)
+BLOCK_EXPORT void pen_set_pen_down(Target *target, bool down)
 {
-    getTargetModel(target)->setPenDown(true);
+    getTargetModel(target)->setPenDown(down);
 }

src/blocks/penblocks.h

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

test/blocks/pen_blocks_test.cpp

@@ -168,3 +168,55 @@ TEST_F(PenBlocksTest, PenDown_Stage)
     thread->run();
     ASSERT_TRUE(model.penDown());
 }
+
+TEST_F(PenBlocksTest, PenUp_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_penUp");
+
+    auto thread = buildScript(builder, sprite.get());
+
+    model.setPenDown(true);
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+    thread->run();
+    ASSERT_FALSE(model.penDown());
+
+    thread->run();
+    ASSERT_FALSE(model.penDown());
+}
+
+TEST_F(PenBlocksTest, PenUp_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_penUp");
+
+    auto thread = buildScript(builder, stage.get());
+
+    model.setPenDown(true);
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+    thread->run();
+    ASSERT_FALSE(model.penDown());
+
+    thread->run();
+    ASSERT_FALSE(model.penDown());
+}