Implement motion_gotoxy block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -27,12 +27,15 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_turnleft", &compileTurnLeft);
     engine->addCompileFunction(this, "motion_pointindirection", &compilePointInDirection);
     engine->addCompileFunction(this, "motion_pointtowards", &compilePointTowards);
+    engine->addCompileFunction(this, "motion_gotoxy", &compileGoToXY);
 
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
     engine->addInput(this, "DEGREES", DEGREES);
     engine->addInput(this, "DIRECTION", DIRECTION);
     engine->addInput(this, "TOWARDS", TOWARDS);
+    engine->addInput(this, "X", X);
+    engine->addInput(this, "Y", Y);
 }
 
 void MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -82,6 +85,13 @@ void MotionBlocks::compilePointTowards(Compiler *compiler)
     }
 }
 
+void MotionBlocks::compileGoToXY(Compiler *compiler)
+{
+    compiler->addInput(X);
+    compiler->addInput(Y);
+    compiler->addFunctionCall(&goToXY);
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -203,3 +213,15 @@ unsigned int MotionBlocks::pointTowardsRandomPosition(VirtualMachine *vm)
 
     return 0;
 }
+
+unsigned int MotionBlocks::goToXY(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite) {
+        sprite->setX(vm->getInput(0, 2)->toDouble());
+        sprite->setY(vm->getInput(1, 2)->toDouble());
+    }
+
+    return 2;
+}

src/blocks/motionblocks.h

@@ -19,7 +19,9 @@ class MotionBlocks : public IBlockSection
             STEPS,
             DEGREES,
             DIRECTION,
-            TOWARDS
+            TOWARDS,
+            X,
+            Y
         };
 
         enum Fields
@@ -39,6 +41,7 @@ class MotionBlocks : public IBlockSection
         static void compileTurnLeft(Compiler *compiler);
         static void compilePointInDirection(Compiler *compiler);
         static void compilePointTowards(Compiler *compiler);
+        static void compileGoToXY(Compiler *compiler);
 
         static unsigned int moveSteps(VirtualMachine *vm);
         static unsigned int turnRight(VirtualMachine *vm);
@@ -52,6 +55,8 @@ class MotionBlocks : public IBlockSection
         static unsigned int pointTowardsMousePointer(VirtualMachine *vm);
         static unsigned int pointTowardsRandomPosition(VirtualMachine *vm);
 
+        static unsigned int goToXY(VirtualMachine *vm);
+
         static IRandomGenerator *rng;
 };
 

test/blocks/motion_blocks_test.cpp

@@ -99,12 +99,15 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_turnleft", &MotionBlocks::compileTurnLeft));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_pointindirection", &MotionBlocks::compilePointInDirection));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_pointtowards", &MotionBlocks::compilePointTowards));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_gotoxy", &MotionBlocks::compileGoToXY));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DEGREES", MotionBlocks::DEGREES));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DIRECTION", MotionBlocks::DIRECTION));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TOWARDS", MotionBlocks::TOWARDS));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "X", MotionBlocks::X));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "Y", MotionBlocks::Y));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -436,3 +439,42 @@ TEST_F(MotionBlocksTest, PointTowardsImpl)
         ASSERT_EQ(std::round(sprite.direction() * 100) / 100, intPosResults[i]);
     }
 }
+
+TEST_F(MotionBlocksTest, GoToXY)
+{
+    Compiler compiler(&m_engineMock);
+
+    // turn right (12.05) degrees
+    auto block = std::make_shared<Block>("a", "motion_gotoxy");
+    addValueInput(block, "X", MotionBlocks::X, 95.2);
+    addValueInput(block, "Y", MotionBlocks::Y, -175.9);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::goToXY)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    MotionBlocks::compileGoToXY(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 95.2, -175.9 }));
+}
+
+TEST_F(MotionBlocksTest, GoToXYImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &MotionBlocks::goToXY };
+    static Value constValues[] = { 95.2, -175.9 };
+
+    Sprite sprite;
+
+    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(), 95.2);
+    ASSERT_EQ(sprite.y(), -175.9);
+}