Implement motion_pointtowards block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -3,13 +3,17 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/input.h>
 
 #include "motionblocks.h"
+#include "../engine/internal/randomgenerator.h"
 
 using namespace libscratchcpp;
 
 static const double pi = std::acos(-1); // TODO: Use std::numbers::pi in C++20
 
+IRandomGenerator *MotionBlocks::rng = nullptr;
+
 std::string MotionBlocks::name() const
 {
     return "Motion";
@@ -22,11 +26,13 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_turnright", &compileTurnRight);
     engine->addCompileFunction(this, "motion_turnleft", &compileTurnLeft);
     engine->addCompileFunction(this, "motion_pointindirection", &compilePointInDirection);
+    engine->addCompileFunction(this, "motion_pointtowards", &compilePointTowards);
 
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
     engine->addInput(this, "DEGREES", DEGREES);
     engine->addInput(this, "DIRECTION", DIRECTION);
+    engine->addInput(this, "TOWARDS", TOWARDS);
 }
 
 void MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -53,6 +59,29 @@ void MotionBlocks::compilePointInDirection(Compiler *compiler)
     compiler->addFunctionCall(&pointInDirection);
 }
 
+void MotionBlocks::compilePointTowards(Compiler *compiler)
+{
+    Input *input = compiler->input(TOWARDS);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string value = input->selectedMenuItem();
+
+        if (value == "_mouse_")
+            compiler->addFunctionCall(&pointTowardsMousePointer);
+        else if (value == "_random_")
+            compiler->addFunctionCall(&pointTowardsRandomPosition);
+        else {
+            int index = compiler->engine()->findTarget(value);
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&pointTowardsByIndex);
+        }
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&pointTowards);
+    }
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -96,3 +125,81 @@ unsigned int MotionBlocks::pointInDirection(VirtualMachine *vm)
 
     return 1;
 }
+
+void MotionBlocks::pointTowardsPos(Sprite *sprite, double x, double y)
+{
+    if (!sprite)
+        return;
+
+    // https://en.scratch-wiki.info/wiki/Point_Towards_()_(block)#Workaround
+    double deltaX = x - sprite->x();
+    double deltaY = y - sprite->y();
+
+    if (deltaY == 0) {
+        if (deltaX < 0)
+            sprite->setDirection(-90);
+        else
+            sprite->setDirection(90);
+    } else if (deltaY < 0)
+        sprite->setDirection(180 + (180 / pi) * std::atan(deltaX / deltaY));
+    else
+        sprite->setDirection((180 / pi) * std::atan(deltaX / deltaY));
+}
+
+unsigned int MotionBlocks::pointTowards(VirtualMachine *vm)
+{
+    std::string value = vm->getInput(0, 1)->toString();
+    Target *target;
+
+    if (value == "_mouse_")
+        pointTowardsPos(dynamic_cast<Sprite *>(vm->target()), vm->engine()->mouseX(), vm->engine()->mouseY());
+    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();
+
+        pointTowardsPos(dynamic_cast<Sprite *>(vm->target()), rng->randint(-static_cast<int>(stageWidth / 2), stageWidth / 2), rng->randint(-static_cast<int>(stageHeight / 2), stageHeight / 2));
+    } else {
+        target = vm->engine()->targetAt(vm->engine()->findTarget(value));
+        Sprite *sprite = dynamic_cast<Sprite *>(target);
+
+        if (sprite)
+            pointTowardsPos(dynamic_cast<Sprite *>(vm->target()), sprite->x(), sprite->y());
+    }
+
+    return 1;
+}
+
+unsigned int MotionBlocks::pointTowardsByIndex(VirtualMachine *vm)
+{
+    Target *target = vm->engine()->targetAt(vm->getInput(0, 1)->toInt());
+    Sprite *sprite = dynamic_cast<Sprite *>(target);
+
+    if (sprite)
+        pointTowardsPos(dynamic_cast<Sprite *>(vm->target()), sprite->x(), sprite->y());
+
+    return 1;
+}
+
+unsigned int MotionBlocks::pointTowardsMousePointer(VirtualMachine *vm)
+{
+    pointTowardsPos(dynamic_cast<Sprite *>(vm->target()), vm->engine()->mouseX(), vm->engine()->mouseY());
+    return 0;
+}
+
+unsigned int MotionBlocks::pointTowardsRandomPosition(VirtualMachine *vm)
+{
+    // 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();
+
+    pointTowardsPos(dynamic_cast<Sprite *>(vm->target()), rng->randint(-static_cast<int>(stageWidth / 2), stageWidth / 2), rng->randint(-static_cast<int>(stageHeight / 2), stageHeight / 2));
+
+    return 0;
+}

src/blocks/motionblocks.h

@@ -7,6 +7,9 @@
 namespace libscratchcpp
 {
 
+class Sprite;
+class IRandomGenerator;
+
 /*! \brief The MotionBlocks class contains the implementation of motion blocks. */
 class MotionBlocks : public IBlockSection
 {
@@ -15,7 +18,16 @@ class MotionBlocks : public IBlockSection
         {
             STEPS,
             DEGREES,
-            DIRECTION
+            DIRECTION,
+            TOWARDS
+        };
+
+        enum Fields
+        {
+        };
+
+        enum FieldValues
+        {
         };
 
         std::string name() const override;
@@ -26,11 +38,21 @@ class MotionBlocks : public IBlockSection
         static void compileTurnRight(Compiler *compiler);
         static void compileTurnLeft(Compiler *compiler);
         static void compilePointInDirection(Compiler *compiler);
+        static void compilePointTowards(Compiler *compiler);
 
         static unsigned int moveSteps(VirtualMachine *vm);
         static unsigned int turnRight(VirtualMachine *vm);
         static unsigned int turnLeft(VirtualMachine *vm);
         static unsigned int pointInDirection(VirtualMachine *vm);
+
+        static void pointTowardsPos(Sprite *sprite, double x, double y);
+
+        static unsigned int pointTowards(VirtualMachine *vm);
+        static unsigned int pointTowardsByIndex(VirtualMachine *vm);
+        static unsigned int pointTowardsMousePointer(VirtualMachine *vm);
+        static unsigned int pointTowardsRandomPosition(VirtualMachine *vm);
+
+        static IRandomGenerator *rng;
 };
 
 } // namespace libscratchcpp