Implement motion_pointtowards block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -2,8 +2,17 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/compilerconstant.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/input.h>
+#include <scratchcpp/value.h>
+#include <scratchcpp/executioncontext.h>
+#include <scratchcpp/thread.h>
+#include <scratchcpp/irandomgenerator.h>
+#include <scratchcpp/stringptr.h>
+#include <scratchcpp/string_functions.h>
 #include <cmath>
+#include <utf8.h>
 
 #include "motionblocks.h"
 
@@ -32,6 +41,7 @@ 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);
 }
 
 CompilerValue *MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -74,6 +84,35 @@ CompilerValue *MotionBlocks::compilePointInDirection(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *MotionBlocks::compilePointTowards(Compiler *compiler)
+{
+    if (compiler->target()->isStage())
+        return nullptr;
+
+    Input *input = compiler->input("TOWARDS");
+
+    if (input->pointsToDropdownMenu()) {
+        std::string value = input->selectedMenuItem();
+
+        if (value == "_mouse_")
+            compiler->addTargetFunctionCall("motion_point_towards_mouse");
+        else if (value == "_random_")
+            compiler->addFunctionCallWithCtx("motion_point_towards_random_pos");
+        else {
+            int index = compiler->engine()->findTarget(value);
+            Target *anotherTarget = compiler->engine()->targetAt(index);
+
+            if (anotherTarget && !anotherTarget->isStage())
+                compiler->addTargetFunctionCall("motion_point_towards_target_by_index", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { compiler->addConstValue(index) });
+        }
+    } else {
+        CompilerValue *towards = compiler->addInput(input);
+        compiler->addFunctionCallWithCtx("motion_pointtowards", Compiler::StaticType::Void, { Compiler::StaticType::String }, { towards });
+    }
+
+    return nullptr;
+}
+
 extern "C" void motion_movesteps(Sprite *sprite, double steps)
 {
     double dir = sprite->direction();
@@ -94,3 +133,66 @@ extern "C" void motion_pointindirection(Sprite *sprite, double direction)
 {
     sprite->setDirection(direction);
 }
+
+inline void motion_point_towards_pos(Sprite *sprite, double x, double y)
+{
+    // 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));
+}
+
+extern "C" void motion_point_towards_mouse(Sprite *sprite)
+{
+    IEngine *engine = sprite->engine();
+    motion_point_towards_pos(sprite, engine->mouseX(), engine->mouseY());
+}
+
+extern "C" void motion_point_towards_random_pos(ExecutionContext *ctx)
+{
+    Sprite *sprite = static_cast<Sprite *>(ctx->thread()->target());
+    IEngine *engine = ctx->engine();
+    const int stageWidth = engine->stageWidth();
+    const int stageHeight = engine->stageHeight();
+    IRandomGenerator *rng = ctx->rng();
+    motion_point_towards_pos(sprite, rng->randintDouble(-stageWidth / 2.0, stageWidth / 2.0), rng->randintDouble(-stageHeight / 2.0, stageHeight / 2.0));
+}
+
+extern "C" void motion_point_towards_target_by_index(Sprite *sprite, double index)
+{
+    Sprite *anotherSprite = static_cast<Sprite *>(sprite->engine()->targetAt(index));
+    motion_point_towards_pos(sprite, anotherSprite->x(), anotherSprite->y());
+}
+
+extern "C" void motion_pointtowards(ExecutionContext *ctx, const StringPtr *towards)
+{
+    static const StringPtr MOUSE_STR("_mouse_");
+    static const StringPtr RANDOM_STR("_random_");
+
+    Sprite *sprite = static_cast<Sprite *>(ctx->thread()->target());
+
+    if (string_compare_case_sensitive(towards, &MOUSE_STR) == 0)
+        motion_point_towards_mouse(sprite);
+    else if (string_compare_case_sensitive(towards, &RANDOM_STR) == 0)
+        motion_point_towards_random_pos(ctx);
+    else {
+        // TODO: Use UTF-16 in engine
+        std::string u8name = utf8::utf16to8(std::u16string(towards->data));
+        IEngine *engine = ctx->engine();
+        Target *anotherTarget = engine->targetAt(engine->findTarget(u8name));
+
+        if (anotherTarget && !anotherTarget->isStage()) {
+            Sprite *anotherSprite = static_cast<Sprite *>(anotherTarget);
+            motion_point_towards_pos(sprite, anotherSprite->x(), anotherSprite->y());
+        }
+    }
+}

src/blocks/motionblocks.h

@@ -21,6 +21,7 @@ class MotionBlocks : public IExtension
         static CompilerValue *compileTurnRight(Compiler *compiler);
         static CompilerValue *compileTurnLeft(Compiler *compiler);
         static CompilerValue *compilePointInDirection(Compiler *compiler);
+        static CompilerValue *compilePointTowards(Compiler *compiler);
 };
 
 } // namespace libscratchcpp