Implement motion_glideto block

adazem009 · adazem009 · commit e7890217df29 · 2023-09-24T10:39:16.000+02:00
diff --git a/src/blocks/motionblocks.cpp b/src/blocks/motionblocks.cpp
@@ -32,6 +32,7 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_gotoxy", &compileGoToXY);
     engine->addCompileFunction(this, "motion_goto", &compileGoTo);
     engine->addCompileFunction(this, "motion_glidesecstoxy", &compileGlideSecsToXY);
+    engine->addCompileFunction(this, "motion_glideto", &compileGlideTo);
 
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
@@ -130,6 +131,33 @@ void MotionBlocks::compileGlideSecsToXY(Compiler *compiler)
     compiler->addFunctionCall(&glideSecsTo);
 }
 
+void MotionBlocks::compileGlideTo(Compiler *compiler)
+{
+    compiler->addInput(SECS);
+
+    Input *input = compiler->input(TO);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string value = input->selectedMenuItem();
+
+        if (value == "_mouse_")
+            compiler->addFunctionCall(&startGlideToMousePointer);
+        else if (value == "_random_")
+            compiler->addFunctionCall(&startGlideToRandomPosition);
+        else {
+            int index = compiler->engine()->findTarget(value);
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&startGlideToByIndex);
+        }
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&startGlideTo);
+    }
+
+    compiler->addFunctionCall(&glideSecsTo);
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -265,12 +293,13 @@ unsigned int MotionBlocks::goToXY(VirtualMachine *vm)
 
 unsigned int MotionBlocks::goTo(VirtualMachine *vm)
 {
-    std::string value = vm->getInput(0, 1)->toString();
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
 
     if (!sprite)
         return 1;
 
+    std::string value = vm->getInput(0, 1)->toString();
+
     if (value == "_mouse_") {
         sprite->setX(vm->engine()->mouseX());
         sprite->setY(vm->engine()->mouseY());
@@ -419,3 +448,74 @@ unsigned int MotionBlocks::glideSecsTo(VirtualMachine *vm)
 
     return 0;
 }
+
+unsigned int MotionBlocks::startGlideTo(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (!sprite)
+        return 1;
+
+    std::string value = vm->getInput(1, 2)->toString();
+
+    if (value == "_mouse_")
+        startGlidingToPos(vm, vm->engine()->mouseX(), vm->engine()->mouseY(), vm->getInput(0, 2)->toDouble());
+    else if (value == "_random_") {
+        // TODO: Read stage size from engine (#224)
+        static const unsigned int stageWidth = 480;
+        static const unsigned int stageHeight = 360;
+
+        if (!rng)
+            rng = RandomGenerator::instance().get();
+
+        startGlidingToPos(vm, rng->randint(-static_cast<int>(stageWidth / 2), stageWidth / 2), rng->randint(-static_cast<int>(stageHeight / 2), stageHeight / 2), vm->getInput(0, 2)->toDouble());
+    } else {
+        Target *target = vm->engine()->targetAt(vm->engine()->findTarget(value));
+        Sprite *targetSprite = dynamic_cast<Sprite *>(target);
+
+        if (targetSprite)
+            startGlidingToPos(vm, targetSprite->x(), targetSprite->y(), vm->getInput(0, 2)->toDouble());
+    }
+
+    return 2;
+}
+
+unsigned int MotionBlocks::startGlideToByIndex(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+    Target *target = vm->engine()->targetAt(vm->getInput(1, 2)->toInt());
+    Sprite *targetSprite = dynamic_cast<Sprite *>(target);
+
+    if (sprite && targetSprite)
+        startGlidingToPos(vm, targetSprite->x(), targetSprite->y(), vm->getInput(0, 2)->toDouble());
+
+    return 2;
+}
+
+unsigned int MotionBlocks::startGlideToMousePointer(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        startGlidingToPos(vm, vm->engine()->mouseX(), vm->engine()->mouseY(), vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int MotionBlocks::startGlideToRandomPosition(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite) {
+        // TODO: Read stage size from engine (#224)
+        static const unsigned int stageWidth = 480;
+        static const unsigned int stageHeight = 360;
+
+        if (!rng)
+            rng = RandomGenerator::instance().get();
+
+        startGlidingToPos(vm, rng->randint(-static_cast<int>(stageWidth / 2), stageWidth / 2), rng->randint(-static_cast<int>(stageHeight / 2), stageHeight / 2), vm->getInput(0, 1)->toDouble());
+    }
+
+    return 1;
+}
diff --git a/src/blocks/motionblocks.h b/src/blocks/motionblocks.h
@@ -50,6 +50,7 @@ class MotionBlocks : public IBlockSection
         static void compileGoToXY(Compiler *compiler);
         static void compileGoTo(Compiler *compiler);
         static void compileGlideSecsToXY(Compiler *compiler);
+        static void compileGlideTo(Compiler *compiler);
 
         static unsigned int moveSteps(VirtualMachine *vm);
         static unsigned int turnRight(VirtualMachine *vm);
@@ -74,6 +75,10 @@ class MotionBlocks : public IBlockSection
 
         static unsigned int startGlideSecsTo(VirtualMachine *vm);
         static unsigned int glideSecsTo(VirtualMachine *vm);
+        static unsigned int startGlideTo(VirtualMachine *vm);
+        static unsigned int startGlideToByIndex(VirtualMachine *vm);
+        static unsigned int startGlideToMousePointer(VirtualMachine *vm);
+        static unsigned int startGlideToRandomPosition(VirtualMachine *vm);
 
         static IRandomGenerator *rng;
         static IClock *clock;
diff --git a/test/blocks/motion_blocks_test.cpp b/test/blocks/motion_blocks_test.cpp
@@ -105,6 +105,7 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_gotoxy", &MotionBlocks::compileGoToXY));
     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));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
@@ -660,8 +661,8 @@ TEST_F(MotionBlocksTest, GlideSecsToXYImpl)
     static BlockFunc functions[] = { &MotionBlocks::startGlideSecsTo, &MotionBlocks::glideSecsTo };
     static Value constValues[] = { 2.5, 95.2, -175.9 };
 
-    double startX = 100.32;
-    double startY = -50.12;
+    static const double startX = 100.32;
+    static const double startY = -50.12;
 
     Sprite sprite;
     sprite.setX(startX);
@@ -716,3 +717,206 @@ TEST_F(MotionBlocksTest, GlideSecsToXYImpl)
 
     MotionBlocks::clock = Clock::instance().get();
 }
+
+TEST_F(MotionBlocksTest, GlideTo)
+{
+    Compiler compiler(&m_engineMock);
+
+    // glide (3.25) secs to (mouse-pointer)
+    auto block1 = std::make_shared<Block>("a", "motion_glideto");
+    addValueInput(block1, "SECS", MotionBlocks::SECS, 3.25);
+    addDropdownInput(block1, "TO", MotionBlocks::TO, "_mouse_");
+
+    // glide (2.5) secs to (random position)
+    auto block2 = std::make_shared<Block>("b", "motion_glideto");
+    addValueInput(block2, "SECS", MotionBlocks::SECS, 2.5);
+    addDropdownInput(block2, "TO", MotionBlocks::TO, "_random_");
+
+    // glide (5.01) secs to (Sprite2)
+    auto block3 = std::make_shared<Block>("c", "motion_glideto");
+    addValueInput(block3, "SECS", MotionBlocks::SECS, 3.25);
+    addDropdownInput(block3, "TO", MotionBlocks::TO, "Sprite2");
+
+    // glide (6.5) secs to (join "" "")
+    auto joinBlock = std::make_shared<Block>("e", "operator_join");
+    joinBlock->setCompileFunction(&OperatorBlocks::compileJoin);
+    auto block4 = std::make_shared<Block>("d", "motion_glideto");
+    addValueInput(block4, "SECS", MotionBlocks::SECS, 6.5);
+    addDropdownInput(block4, "TO", MotionBlocks::TO, "", joinBlock);
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::startGlideToMousePointer)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::glideSecsTo)).WillOnce(Return(4));
+    compiler.setBlock(block1);
+    MotionBlocks::compileGlideTo(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::startGlideToRandomPosition)).WillOnce(Return(1));
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::glideSecsTo)).WillOnce(Return(4));
+    compiler.setBlock(block2);
+    MotionBlocks::compileGlideTo(&compiler);
+
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(5));
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::startGlideToByIndex)).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::glideSecsTo)).WillOnce(Return(4));
+    compiler.setBlock(block3);
+    MotionBlocks::compileGlideTo(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::startGlideTo)).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::glideSecsTo)).WillOnce(Return(4));
+    compiler.setBlock(block4);
+    MotionBlocks::compileGlideTo(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(
+        compiler.bytecode(),
+        std::vector<unsigned int>(
+            { vm::OP_START,
+              vm::OP_CONST,
+              0,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              4,
+              vm::OP_CONST,
+              1,
+              vm::OP_EXEC,
+              1,
+              vm::OP_EXEC,
+              4,
+              vm::OP_CONST,
+              2,
+              vm::OP_CONST,
+              3,
+              vm::OP_EXEC,
+              2,
+              vm::OP_EXEC,
+              4,
+              vm::OP_CONST,
+              4,
+              vm::OP_NULL,
+              vm::OP_NULL,
+              vm::OP_STR_CONCAT,
+              vm::OP_EXEC,
+              3,
+              vm::OP_EXEC,
+              4,
+              vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 3.25, 2.5, 3.25, 5, 6.5 }));
+}
+
+TEST_F(MotionBlocksTest, GlideToImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 4, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 2, vm::OP_EXEC, 1, vm::OP_EXEC, 4, vm::OP_HALT };
+    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 4, vm::OP_HALT };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 3, vm::OP_EXEC, 4, vm::OP_HALT };
+    static unsigned int *scripts[] = { bytecode1, bytecode2, bytecode3, bytecode4 };
+    static BlockFunc functions
+        [] = { &MotionBlocks::startGlideTo, &MotionBlocks::startGlideToByIndex, &MotionBlocks::startGlideToMousePointer, &MotionBlocks::startGlideToRandomPosition, &MotionBlocks::glideSecsTo };
+    static Value constValues[] = { 2.5, "Sprite2", 3 };
+
+    static const double startX = 100.32;
+    static const double startY = -50.12;
+    static const double endX = 95.2;
+    static const double endY = -175.9;
+
+    Sprite sprite;
+    Sprite anotherSprite;
+    anotherSprite.setX(endX);
+    anotherSprite.setY(endY);
+
+    VirtualMachine vm(&sprite, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    ClockMock clock;
+    RandomGeneratorMock rng;
+    MotionBlocks::clock = &clock;
+    MotionBlocks::rng = &rng;
+    int i = 0;
+
+    for (auto script : scripts) {
+        sprite.setX(startX);
+        sprite.setY(startY);
+
+        switch (i) {
+            case 0:
+                EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(3));
+                EXPECT_CALL(m_engineMock, targetAt(3)).WillOnce(Return(&anotherSprite));
+                break;
+
+            case 1:
+                EXPECT_CALL(m_engineMock, targetAt(3)).WillOnce(Return(&anotherSprite));
+                break;
+
+            case 2:
+                EXPECT_CALL(m_engineMock, mouseX()).WillOnce(Return(endX));
+                EXPECT_CALL(m_engineMock, mouseY()).WillOnce(Return(endY));
+                break;
+            case 3:
+                EXPECT_CALL(rng, randint(-240, 240)).WillOnce(Return(std::round(endX)));
+                EXPECT_CALL(rng, randint(-180, 180)).WillOnce(Return(std::round(endY)));
+            default:
+                break;
+        }
+
+        vm.setBytecode(script);
+        std::chrono::steady_clock::time_point startTime(std::chrono::milliseconds(1000));
+        EXPECT_CALL(clock, currentSteadyTime()).Times(2).WillRepeatedly(Return(startTime));
+        EXPECT_CALL(m_engineMock, lockFrame()).Times(1);
+        EXPECT_CALL(m_engineMock, breakFrame()).Times(1);
+        vm.run();
+
+        ASSERT_EQ(vm.registerCount(), 0);
+        ASSERT_TRUE(MotionBlocks::m_timeMap.find(&vm) != MotionBlocks::m_timeMap.cend());
+        ASSERT_TRUE(MotionBlocks::m_glideMap.find(&vm) != MotionBlocks::m_glideMap.cend());
+        ASSERT_FALSE(vm.atEnd());
+        ASSERT_EQ(sprite.x(), startX);
+        ASSERT_EQ(sprite.y(), startY);
+
+        std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(3456));
+        EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time1));
+        EXPECT_CALL(m_engineMock, lockFrame()).Times(1);
+        EXPECT_CALL(m_engineMock, breakFrame()).Times(1);
+        vm.run();
+
+        ASSERT_EQ(vm.registerCount(), 0);
+        ASSERT_TRUE(MotionBlocks::m_timeMap.find(&vm) != MotionBlocks::m_timeMap.cend());
+        ASSERT_TRUE(MotionBlocks::m_glideMap.find(&vm) != MotionBlocks::m_glideMap.cend());
+        ASSERT_FALSE(vm.atEnd());
+
+        if (i == 3) {
+            ASSERT_EQ(std::round(sprite.x() * 100) / 100, 95.09);
+            ASSERT_EQ(std::round(sprite.y() * 100) / 100, -173.78);
+        } else {
+            ASSERT_EQ(std::round(sprite.x() * 100) / 100, 95.29);
+            ASSERT_EQ(std::round(sprite.y() * 100) / 100, -173.69);
+        }
+
+        std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(3500));
+        EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
+        EXPECT_CALL(m_engineMock, lockFrame()).Times(0);
+        EXPECT_CALL(m_engineMock, breakFrame()).Times(0);
+        vm.run();
+
+        ASSERT_EQ(vm.registerCount(), 0);
+        ASSERT_TRUE(MotionBlocks::m_timeMap.find(&vm) == MotionBlocks::m_timeMap.cend());
+        ASSERT_TRUE(MotionBlocks::m_glideMap.find(&vm) == MotionBlocks::m_glideMap.cend());
+        ASSERT_TRUE(vm.atEnd());
+
+        if (i == 3) {
+            ASSERT_EQ(sprite.x(), std::round(endX));
+            ASSERT_EQ(sprite.y(), std::round(endY));
+        } else {
+            ASSERT_EQ(std::round(sprite.x() * 100) / 100, endX);
+            ASSERT_EQ(std::round(sprite.y() * 100) / 100, endY);
+        }
+
+        i++;
+    }
+
+    MotionBlocks::clock = Clock::instance().get();
+    MotionBlocks::rng = RandomGenerator::instance().get();
+}
