Implement motion_movesteps block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -1,14 +1,45 @@
 // SPDX-License-Identifier: Apache-2.0
 
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/sprite.h>
+
 #include "motionblocks.h"
 
 using namespace libscratchcpp;
 
+static const double pi = std::acos(-1); // TODO: Use std::numbers::pi in C++20
+
 std::string MotionBlocks::name() const
 {
     return "Motion";
 }
 
 void MotionBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
+    engine->addCompileFunction(this, "motion_movesteps", &compileMoveSteps);
+
+    // Inputs
+    engine->addInput(this, "STEPS", STEPS);
+}
+
+void MotionBlocks::compileMoveSteps(Compiler *compiler)
+{
+    compiler->addInput(STEPS);
+    compiler->addFunctionCall(&moveSteps);
+}
+
+unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite) {
+        double dir = sprite->direction();
+        double steps = vm->getInput(0, 1)->toDouble();
+        sprite->setX(sprite->x() + std::sin(dir * pi / 180) * steps);
+        sprite->setY(sprite->y() + std::cos(dir * pi / 180) * steps);
+    }
+
+    return 1;
 }

src/blocks/motionblocks.h

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

test/blocks/motion_blocks_test.cpp

@@ -1,5 +1,7 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/block.h>
+#include <scratchcpp/input.h>
+#include <scratchcpp/sprite.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -19,6 +21,18 @@ class MotionBlocksTest : public testing::Test
             m_section->registerBlocks(&m_engine);
         }
 
+        // For any motion block
+        std::shared_ptr<Block> createMotionBlock(const std::string &id, const std::string &opcode) const { return std::make_shared<Block>(id, opcode); }
+
+        void addValueInput(std::shared_ptr<Block> block, const std::string &name, MotionBlocks::Inputs id, const Value &value) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::Shadow);
+            input->setPrimaryValue(value);
+            input->setInputId(id);
+            block->addInput(input);
+            block->updateInputMap();
+        }
+
         std::unique_ptr<IBlockSection> m_section;
         EngineMock m_engineMock;
         Engine m_engine;
@@ -36,5 +50,53 @@ TEST_F(MotionBlocksTest, CategoryVisible)
 
 TEST_F(MotionBlocksTest, RegisterBlocks)
 {
+    // Blocks
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_movesteps", &MotionBlocks::compileMoveSteps));
+
+    // Inputs
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
+
     m_section->registerBlocks(&m_engineMock);
 }
+
+TEST_F(MotionBlocksTest, MoveSteps)
+{
+    Compiler compiler(&m_engineMock);
+
+    // move (30.25) steps
+    auto block = std::make_shared<Block>("a", "motion_movesteps");
+    addValueInput(block, "STEPS", MotionBlocks::STEPS, 30.25);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::moveSteps)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    MotionBlocks::compileMoveSteps(&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(), 30.25);
+}
+
+TEST_F(MotionBlocksTest, MoveStepsImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &MotionBlocks::moveSteps };
+    static Value constValues[] = { 30.25 };
+
+    Sprite sprite;
+    sprite.setX(5.2);
+    sprite.setY(-0.25);
+    sprite.setDirection(-61.42);
+
+    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.x() * 100) / 100, -21.36);
+    ASSERT_EQ(std::round(sprite.y() * 100) / 100, 14.22);
+}