Merge pull request #233 from scratchcpp/motion_blocks3

Implement motion blocks (part 3)

Author: adazem009

src/blocks/motionblocks.cpp

@@ -4,6 +4,7 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 
 #include "motionblocks.h"
 #include "../engine/internal/randomgenerator.h"
@@ -36,6 +37,11 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_changexby", &compileChangeXBy);
     engine->addCompileFunction(this, "motion_setx", &compileSetX);
     engine->addCompileFunction(this, "motion_changeyby", &compileChangeYBy);
+    engine->addCompileFunction(this, "motion_sety", &compileSetY);
+    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);
@@ -48,6 +54,9 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addInput(this, "SECS", SECS);
     engine->addInput(this, "DX", DX);
     engine->addInput(this, "DY", DY);
+
+    // Fields
+    engine->addField(this, "STYLE", STYLE);
 }
 
 void MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -181,6 +190,49 @@ void MotionBlocks::compileChangeYBy(Compiler *compiler)
     compiler->addFunctionCall(&changeYBy);
 }
 
+void MotionBlocks::compileSetY(Compiler *compiler)
+{
+    compiler->addInput(Y);
+    compiler->addFunctionCall(&setY);
+}
+
+void MotionBlocks::compileSetRotationStyle(Compiler *compiler)
+{
+    int option = compiler->field(STYLE)->specialValueId();
+
+    switch (option) {
+        case LeftRight:
+            compiler->addFunctionCall(&setLeftRightRotationStyle);
+            break;
+
+        case DoNotRotate:
+            compiler->addFunctionCall(&setDoNotRotateRotationStyle);
+            break;
+
+        case AllAround:
+            compiler->addFunctionCall(&setAllAroundRotationStyle);
+            break;
+
+        default:
+            break;
+    }
+}
+
+void MotionBlocks::compileXPosition(Compiler *compiler)
+{
+    compiler->addFunctionCall(&xPosition);
+}
+
+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());
@@ -572,3 +624,79 @@ unsigned int MotionBlocks::changeYBy(VirtualMachine *vm)
 
     return 1;
 }
+
+unsigned int MotionBlocks::setY(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->setY(vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int MotionBlocks::setLeftRightRotationStyle(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->setRotationStyle(Sprite::RotationStyle::LeftRight);
+
+    return 0;
+}
+
+unsigned int MotionBlocks::setDoNotRotateRotationStyle(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->setRotationStyle(Sprite::RotationStyle::DoNotRotate);
+
+    return 0;
+}
+
+unsigned int MotionBlocks::setAllAroundRotationStyle(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->setRotationStyle(Sprite::RotationStyle::AllAround);
+
+    return 0;
+}
+
+unsigned int MotionBlocks::xPosition(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        vm->addReturnValue(sprite->x());
+    else
+        vm->addReturnValue(0);
+
+    return 0;
+}
+
+unsigned int MotionBlocks::yPosition(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        vm->addReturnValue(sprite->y());
+    else
+        vm->addReturnValue(0);
+
+    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

@@ -34,10 +34,14 @@ class MotionBlocks : public IBlockSection
 
         enum Fields
         {
+            STYLE
         };
 
         enum FieldValues
         {
+            LeftRight,
+            AllAround,
+            DoNotRotate
         };
 
         std::string name() const override;
@@ -56,6 +60,11 @@ class MotionBlocks : public IBlockSection
         static void compileChangeXBy(Compiler *compiler);
         static void compileSetX(Compiler *compiler);
         static void compileChangeYBy(Compiler *compiler);
+        static void compileSetY(Compiler *compiler);
+        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);
@@ -88,6 +97,13 @@ class MotionBlocks : public IBlockSection
         static unsigned int changeXBy(VirtualMachine *vm);
         static unsigned int setX(VirtualMachine *vm);
         static unsigned int changeYBy(VirtualMachine *vm);
+        static unsigned int setY(VirtualMachine *vm);
+        static unsigned int setLeftRightRotationStyle(VirtualMachine *vm);
+        static unsigned int setDoNotRotateRotationStyle(VirtualMachine *vm);
+        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;