Implement pen_setPenSizeTo block

Author: adazem009

src/blocks/penblocks.cpp

@@ -87,6 +87,7 @@ void PenBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "pen_changePenColorParamBy", &compileChangePenColorParamBy);
     engine->addCompileFunction(this, "pen_setPenColorParamTo", &compileSetPenColorParamTo);
     engine->addCompileFunction(this, "pen_changePenSizeBy", &compileChangePenSizeBy);
+    engine->addCompileFunction(this, "pen_setPenSizeTo", &compileSetPenSizeTo);
 }
 
 CompilerValue *PenBlocks::compileClear(Compiler *compiler)
@@ -190,6 +191,13 @@ CompilerValue *PenBlocks::compileChangePenSizeBy(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *PenBlocks::compileSetPenSizeTo(Compiler *compiler)
+{
+    CompilerValue *size = compiler->addInput("SIZE");
+    compiler->addTargetFunctionCall("pen_setPenSizeTo", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { size });
+    return nullptr;
+}
+
 static TargetModel *getTargetModel(Target *target)
 {
     if (target->isStage()) {
@@ -323,3 +331,9 @@ BLOCK_EXPORT void pen_changePenSizeBy(Target *target, double value)
     PenAttributes &penAttributes = getTargetModel(target)->penAttributes();
     penAttributes.diameter = std::clamp(penAttributes.diameter + value, PEN_SIZE_MIN, PEN_SIZE_MAX);
 }
+
+BLOCK_EXPORT void pen_setPenSizeTo(Target *target, double value)
+{
+    PenAttributes &penAttributes = getTargetModel(target)->penAttributes();
+    penAttributes.diameter = std::clamp(value, PEN_SIZE_MIN, PEN_SIZE_MAX);
+}

src/blocks/penblocks.h

@@ -22,6 +22,7 @@ class PenBlocks : public libscratchcpp::IExtension
         static libscratchcpp::CompilerValue *compileChangePenColorParamBy(libscratchcpp::Compiler *compiler);
         static libscratchcpp::CompilerValue *compileSetPenColorParamTo(libscratchcpp::Compiler *compiler);
         static libscratchcpp::CompilerValue *compileChangePenSizeBy(libscratchcpp::Compiler *compiler);
+        static libscratchcpp::CompilerValue *compileSetPenSizeTo(libscratchcpp::Compiler *compiler);
 };
 
 } // namespace scratchcpprender

test/blocks/pen_blocks_test.cpp

@@ -2077,3 +2077,128 @@ TEST_F(PenBlocksTest, ChangePenSizeBy_Stage)
     thread->run();
     ASSERT_EQ(model.penAttributes().diameter, 513.8);
 }
+
+TEST_F(PenBlocksTest, SetPenSizeTo)
+{
+    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_setPenSizeTo");
+    builder.addValueInput("SIZE", 511.5);
+
+    model.penAttributes().diameter = 2.3;
+
+    auto thread = buildScript(builder, sprite.get());
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+
+    thread->run();
+    ASSERT_EQ(model.penAttributes().diameter, 511.5);
+}
+
+TEST_F(PenBlocksTest, SetPenSizeTo_Negative)
+{
+    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_setPenSizeTo");
+    builder.addValueInput("SIZE", -0.5);
+
+    model.penAttributes().diameter = 2.3;
+
+    auto thread = buildScript(builder, sprite.get());
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+
+    thread->run();
+    ASSERT_EQ(model.penAttributes().diameter, 1);
+}
+
+TEST_F(PenBlocksTest, SetPenSizeTo_AboveMaximum)
+{
+    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_setPenSizeTo");
+    builder.addValueInput("SIZE", 1200.6);
+
+    model.penAttributes().diameter = 513.8;
+
+    auto thread = buildScript(builder, sprite.get());
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+
+    thread->run();
+    ASSERT_EQ(model.penAttributes().diameter, 1200);
+}
+
+TEST_F(PenBlocksTest, SetPenSizeTo_BelowMinimum)
+{
+    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_setPenSizeTo");
+    builder.addValueInput("SIZE", 0.5);
+
+    model.penAttributes().diameter = 12.5;
+
+    auto thread = buildScript(builder, sprite.get());
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+
+    thread->run();
+    ASSERT_EQ(model.penAttributes().diameter, 1);
+}
+
+TEST_F(PenBlocksTest, SetPenSizeTo_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_setPenSizeTo");
+    builder.addValueInput("SIZE", 511.5);
+
+    model.penAttributes().diameter = 2.3;
+
+    auto thread = buildScript(builder, stage.get());
+
+    EXPECT_CALL(m_engineMock, requestRedraw).Times(0);
+
+    thread->run();
+    ASSERT_EQ(model.penAttributes().diameter, 511.5);
+}