Implement motion_changexby block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -33,6 +33,7 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_goto", &compileGoTo);
     engine->addCompileFunction(this, "motion_glidesecstoxy", &compileGlideSecsToXY);
     engine->addCompileFunction(this, "motion_glideto", &compileGlideTo);
+    engine->addCompileFunction(this, "motion_changexby", &compileChangeXBy);
 
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
@@ -43,6 +44,7 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addInput(this, "Y", Y);
     engine->addInput(this, "TO", TO);
     engine->addInput(this, "SECS", SECS);
+    engine->addInput(this, "DX", DX);
 }
 
 void MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -158,6 +160,12 @@ void MotionBlocks::compileGlideTo(Compiler *compiler)
     compiler->addFunctionCall(&glideSecsTo);
 }
 
+void MotionBlocks::compileChangeXBy(Compiler *compiler)
+{
+    compiler->addInput(DX);
+    compiler->addFunctionCall(&changeXBy);
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -519,3 +527,13 @@ unsigned int MotionBlocks::startGlideToRandomPosition(VirtualMachine *vm)
 
     return 1;
 }
+
+unsigned int MotionBlocks::changeXBy(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->setX(sprite->x() + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}

src/blocks/motionblocks.h

@@ -27,7 +27,8 @@ class MotionBlocks : public IBlockSection
             X,
             Y,
             TO,
-            SECS
+            SECS,
+            DX
         };
 
         enum Fields
@@ -51,6 +52,7 @@ class MotionBlocks : public IBlockSection
         static void compileGoTo(Compiler *compiler);
         static void compileGlideSecsToXY(Compiler *compiler);
         static void compileGlideTo(Compiler *compiler);
+        static void compileChangeXBy(Compiler *compiler);
 
         static unsigned int moveSteps(VirtualMachine *vm);
         static unsigned int turnRight(VirtualMachine *vm);
@@ -80,6 +82,8 @@ class MotionBlocks : public IBlockSection
         static unsigned int startGlideToMousePointer(VirtualMachine *vm);
         static unsigned int startGlideToRandomPosition(VirtualMachine *vm);
 
+        static unsigned int changeXBy(VirtualMachine *vm);
+
         static IRandomGenerator *rng;
         static IClock *clock;
 

test/blocks/motion_blocks_test.cpp

@@ -106,6 +106,7 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_goto", &MotionBlocks::compileGoTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_glidesecstoxy", &MotionBlocks::compileGlideSecsToXY));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_glideto", &MotionBlocks::compileGlideTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_changexby", &MotionBlocks::compileChangeXBy));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
@@ -116,6 +117,7 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "Y", MotionBlocks::Y));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TO", MotionBlocks::TO));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SECS", MotionBlocks::SECS));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DX", MotionBlocks::DX));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -920,3 +922,42 @@ TEST_F(MotionBlocksTest, GlideToImpl)
     MotionBlocks::clock = Clock::instance().get();
     MotionBlocks::rng = RandomGenerator::instance().get();
 }
+
+TEST_F(MotionBlocksTest, ChangeXBy)
+{
+    Compiler compiler(&m_engineMock);
+
+    // change x by (56.54)
+    auto block = std::make_shared<Block>("a", "motion_changexby");
+    addValueInput(block, "DX", MotionBlocks::DX, 56.54);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::changeXBy)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    MotionBlocks::compileChangeXBy(&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(), 56.54);
+}
+
+TEST_F(MotionBlocksTest, ChangeXByImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &MotionBlocks::changeXBy };
+    static Value constValues[] = { 56.54 };
+
+    Sprite sprite;
+    sprite.setX(-23.4);
+
+    VirtualMachine vm(&sprite, nullptr, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(sprite.x(), 33.14);
+}