Implement pen_setPenSizeTo block

Author: adazem009

src/blocks/penblocks.cpp

@@ -26,6 +26,7 @@ void PenBlocks::registerBlocks(IEngine *engine)
  engine->addCompileFunction(this, "pen_penDown", &compilePenDown);
  engine->addCompileFunction(this, "pen_penUp", &compilePenUp);
  engine->addCompileFunction(this, "pen_changePenSizeBy", &compileChangePenSizeBy);
+ engine->addCompileFunction(this, "pen_setPenSizeTo", &compileSetPenSizeTo);
 
  // Inputs
  engine->addInput(this, "SIZE", SIZE);
@@ -52,6 +53,12 @@ void PenBlocks::compileChangePenSizeBy(libscratchcpp::Compiler *compiler)
  compiler->addFunctionCall(&changePenSizeBy);
 }
 
+void PenBlocks::compileSetPenSizeTo(libscratchcpp::Compiler *compiler)
+{
+ compiler->addInput(SIZE);
+ compiler->addFunctionCall(&setPenSizeTo);
+}
+
 unsigned int PenBlocks::clear(VirtualMachine *vm)
 {
  IPenLayer *penLayer = PenLayer::getProjectPenLayer(vm->engine());
@@ -94,6 +101,16 @@ unsigned int PenBlocks::changePenSizeBy(libscratchcpp::VirtualMachine *vm)
  return 1;
 }
 
+unsigned int PenBlocks::setPenSizeTo(libscratchcpp::VirtualMachine *vm)
+{
+ SpriteModel *model = getSpriteModel(vm);
+
+ if (model)
+ model->penAttributes().diameter = std::clamp(vm->getInput(0, 1)->toDouble(), PEN_SIZE_MIN, PEN_SIZE_MAX);
+
+ return 1;
+}
+
 SpriteModel *PenBlocks::getSpriteModel(libscratchcpp::VirtualMachine *vm)
 {
  Target *target = vm->target();

src/blocks/penblocks.h

@@ -25,11 +25,13 @@ class PenBlocks : public libscratchcpp::IBlockSection
  static void compilePenDown(libscratchcpp::Compiler *compiler);
  static void compilePenUp(libscratchcpp::Compiler *compiler);
  static void compileChangePenSizeBy(libscratchcpp::Compiler *compiler);
+ static void compileSetPenSizeTo(libscratchcpp::Compiler *compiler);
 
  static unsigned int clear(libscratchcpp::VirtualMachine *vm);
  static unsigned int penDown(libscratchcpp::VirtualMachine *vm);
  static unsigned int penUp(libscratchcpp::VirtualMachine *vm);
  static unsigned int changePenSizeBy(libscratchcpp::VirtualMachine *vm);
+ static unsigned int setPenSizeTo(libscratchcpp::VirtualMachine *vm);
 
  private:
  static SpriteModel *getSpriteModel(libscratchcpp::VirtualMachine *vm);

test/blocks/pen_blocks_test.cpp

@@ -65,6 +65,7 @@ TEST_F(PenBlocksTest, RegisterBlocks)
  EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_penDown", &PenBlocks::compilePenDown));
  EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_penUp", &PenBlocks::compilePenUp));
  EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_changePenSizeBy", &PenBlocks::compileChangePenSizeBy));
+ EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_setPenSizeTo", &PenBlocks::compileSetPenSizeTo));
 
  // Inputs
  EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SIZE", PenBlocks::SIZE));
@@ -264,3 +265,68 @@ TEST_F(PenBlocksTest, ChangePenSizeByImpl)
  ASSERT_EQ(vm.registerCount(), 0);
  ASSERT_EQ(model.penAttributes().diameter, 1);
 }
+
+TEST_F(PenBlocksTest, SetPenSizeTo)
+{
+ Compiler compiler(&m_engineMock);
+
+ // set pen size to (51.46)
+ auto block1 = std::make_shared<Block>("a", "pen_setPenSizeTo");
+ addValueInput(block1, "SIZE", PenBlocks::SIZE, 51.46);
+
+ // change pen size by (null block)
+ auto block2 = std::make_shared<Block>("b", "pen_setPenSizeTo");
+ addObscuredInput(block2, "SIZE", PenBlocks::SIZE, createNullBlock("c"));
+
+ compiler.init();
+
+ EXPECT_CALL(m_engineMock, functionIndex(&PenBlocks::setPenSizeTo)).WillOnce(Return(2));
+ compiler.setBlock(block1);
+ PenBlocks::compileSetPenSizeTo(&compiler);
+
+ EXPECT_CALL(m_engineMock, functionIndex(&PenBlocks::setPenSizeTo)).WillOnce(Return(2));
+ compiler.setBlock(block2);
+ PenBlocks::compileSetPenSizeTo(&compiler);
+
+ compiler.end();
+
+ ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 2, vm::OP_NULL, vm::OP_EXEC, 2, vm::OP_HALT }));
+ ASSERT_EQ(compiler.constValues().size(), 1);
+ ASSERT_EQ(compiler.constValues()[0].toDouble(), 51.46);
+ ASSERT_TRUE(compiler.variables().empty());
+ ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(PenBlocksTest, SetPenSizeToImpl)
+{
+ static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+ static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+ static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_HALT };
+ static BlockFunc functions[] = { &PenBlocks::setPenSizeTo };
+ static Value constValues[] = { 511.5, -650.08, 1500 };
+
+ SpriteModel model;
+ Sprite sprite;
+ sprite.setInterface(&model);
+
+ VirtualMachine vm(&sprite, &m_engineMock, nullptr);
+ vm.setBytecode(bytecode1);
+ vm.setFunctions(functions);
+ vm.setConstValues(constValues);
+
+ vm.run();
+ ASSERT_EQ(vm.registerCount(), 0);
+ ASSERT_EQ(model.penAttributes().diameter, 511.5);
+
+ vm.reset();
+ vm.setBytecode(bytecode2);
+ vm.run();
+ ASSERT_EQ(vm.registerCount(), 0);
+ ASSERT_EQ(model.penAttributes().diameter, 1);
+
+ vm.reset();
+ vm.setBytecode(bytecode3);
+ vm.run();
+ ASSERT_EQ(vm.registerCount(), 0);
+ ASSERT_EQ(model.penAttributes().diameter, 1200);
+}