Implement motion_direction block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -41,6 +41,7 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_setrotationstyle", &compileSetRotationStyle);
     engine->addCompileFunction(this, "motion_xposition", &compileXPosition);
     engine->addCompileFunction(this, "motion_yposition", &compileYPosition);
+    engine->addCompileFunction(this, "motion_direction", &compileDirection);
 
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
@@ -227,6 +228,11 @@ void MotionBlocks::compileYPosition(Compiler *compiler)
     compiler->addFunctionCall(&yPosition);
 }
 
+void MotionBlocks::compileDirection(Compiler *compiler)
+{
+    compiler->addFunctionCall(&direction);
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -682,3 +688,15 @@ unsigned int MotionBlocks::yPosition(VirtualMachine *vm)
 
     return 0;
 }
+
+unsigned int MotionBlocks::direction(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        vm->addReturnValue(sprite->direction());
+    else
+        vm->addReturnValue(0);
+
+    return 0;
+}

src/blocks/motionblocks.h

@@ -64,6 +64,7 @@ class MotionBlocks : public IBlockSection
         static void compileSetRotationStyle(Compiler *compiler);
         static void compileXPosition(Compiler *compiler);
         static void compileYPosition(Compiler *compiler);
+        static void compileDirection(Compiler *compiler);
 
         static unsigned int moveSteps(VirtualMachine *vm);
         static unsigned int turnRight(VirtualMachine *vm);
@@ -102,6 +103,7 @@ class MotionBlocks : public IBlockSection
         static unsigned int setAllAroundRotationStyle(VirtualMachine *vm);
         static unsigned int xPosition(VirtualMachine *vm);
         static unsigned int yPosition(VirtualMachine *vm);
+        static unsigned int direction(VirtualMachine *vm);
 
         static IRandomGenerator *rng;
         static IClock *clock;

test/blocks/motion_blocks_test.cpp

@@ -113,6 +113,7 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_setrotationstyle", &MotionBlocks::compileSetRotationStyle));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_xposition", &MotionBlocks::compileXPosition));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_yposition", &MotionBlocks::compileYPosition));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_direction", &MotionBlocks::compileDirection));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
@@ -1223,3 +1224,37 @@ TEST_F(MotionBlocksTest, YPositionImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.getInput(0, 1)->toDouble(), -68.5408);
 }
+
+TEST_F(MotionBlocksTest, Direction)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "motion_direction");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::direction)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    MotionBlocks::compileDirection(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(MotionBlocksTest, DirectionImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &MotionBlocks::direction };
+
+    Sprite sprite;
+    sprite.setDirection(179.605);
+
+    VirtualMachine vm(&sprite, nullptr, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 179.605);
+}