Implement motion_turnright block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -19,9 +19,11 @@ void MotionBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
     engine->addCompileFunction(this, "motion_movesteps", &compileMoveSteps);
+    engine->addCompileFunction(this, "motion_turnright", &compileTurnRight);
 
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
+    engine->addInput(this, "DEGREES", DEGREES);
 }
 
 void MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -30,6 +32,12 @@ void MotionBlocks::compileMoveSteps(Compiler *compiler)
     compiler->addFunctionCall(&moveSteps);
 }
 
+void MotionBlocks::compileTurnRight(Compiler *compiler)
+{
+    compiler->addInput(DEGREES);
+    compiler->addFunctionCall(&turnRight);
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -43,3 +51,13 @@ unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 
     return 1;
 }
+
+unsigned int MotionBlocks::turnRight(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->setDirection(sprite->direction() + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}

src/blocks/motionblocks.h

@@ -13,16 +13,19 @@ class MotionBlocks : public IBlockSection
     public:
         enum Inputs
         {
-            STEPS
+            STEPS,
+            DEGREES
         };
 
         std::string name() const override;
 
         void registerBlocks(IEngine *engine) override;
 
         static void compileMoveSteps(Compiler *compiler);
+        static void compileTurnRight(Compiler *compiler);
 
         static unsigned int moveSteps(VirtualMachine *vm);
+        static unsigned int turnRight(VirtualMachine *vm);
 };
 
 } // namespace libscratchcpp

test/blocks/motion_blocks_test.cpp

@@ -52,9 +52,11 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
 {
     // Blocks
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_movesteps", &MotionBlocks::compileMoveSteps));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_turnright", &MotionBlocks::compileTurnRight));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DEGREES", MotionBlocks::DEGREES));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -100,3 +102,42 @@ TEST_F(MotionBlocksTest, MoveStepsImpl)
     ASSERT_EQ(std::round(sprite.x() * 100) / 100, -21.36);
     ASSERT_EQ(std::round(sprite.y() * 100) / 100, 14.22);
 }
+
+TEST_F(MotionBlocksTest, TurnRight)
+{
+    Compiler compiler(&m_engineMock);
+
+    // turn right (12.05) degrees
+    auto block = std::make_shared<Block>("a", "motion_turnright");
+    addValueInput(block, "DEGREES", MotionBlocks::DEGREES, 12.05);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::turnRight)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    MotionBlocks::compileTurnRight(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0].toDouble(), 12.05);
+}
+
+TEST_F(MotionBlocksTest, TurnRightImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &MotionBlocks::turnRight };
+    static Value constValues[] = { 12.05 };
+
+    Sprite sprite;
+    sprite.setDirection(124.37);
+
+    VirtualMachine vm(&sprite, nullptr, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(std::round(sprite.direction() * 100) / 100, 136.42);
+}