Merge pull request #324 from scratchcpp/ifonedgebounce_block

Implement "if on edge, bounce" block

Author: adazem009

README.md

@@ -117,7 +117,7 @@ int main(int argc, char **argv) {
 <!-- ROADMAP -->
 ## Roadmap
 
-- [ ] Motion blocks
+- [x] Motion blocks
 - [ ] Looks blocks
 - [ ] Sound blocks
 - [ ] Event blocks

include/scratchcpp/sprite.h

@@ -65,6 +65,7 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
         void setRotationStyle(const char *newRotationStyle);
 
         Rect boundingRect() const;
+        void keepInFence(double newX, double newY, double *fencedX, double *fencedY) const;
 
         double graphicsEffectValue(IGraphicsEffect *effect) const;
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value);

src/blocks/motionblocks.cpp

@@ -5,6 +5,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/rect.h>
 
 #include "motionblocks.h"
 #include "../engine/internal/randomgenerator.h"
@@ -38,6 +39,7 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_setx", &compileSetX);
     engine->addCompileFunction(this, "motion_changeyby", &compileChangeYBy);
     engine->addCompileFunction(this, "motion_sety", &compileSetY);
+    engine->addCompileFunction(this, "motion_ifonedgebounce", &compileIfOnEdgeBounce);
     engine->addCompileFunction(this, "motion_setrotationstyle", &compileSetRotationStyle);
     engine->addCompileFunction(this, "motion_xposition", &compileXPosition);
     engine->addCompileFunction(this, "motion_yposition", &compileYPosition);
@@ -196,6 +198,11 @@ void MotionBlocks::compileSetY(Compiler *compiler)
     compiler->addFunctionCall(&setY);
 }
 
+void MotionBlocks::compileIfOnEdgeBounce(Compiler *compiler)
+{
+    compiler->addFunctionCall(&ifOnEdgeBounce);
+}
+
 void MotionBlocks::compileSetRotationStyle(Compiler *compiler)
 {
     int option = compiler->field(STYLE)->specialValueId();
@@ -628,6 +635,99 @@ unsigned int MotionBlocks::setY(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int MotionBlocks::ifOnEdgeBounce(VirtualMachine *vm)
+{
+    // See https://github.com/scratchfoundation/scratch-vm/blob/c37745e97e6d8a77ad1dc31a943ea728dd17ba78/src/blocks/scratch3_motion.js#L186-L240
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+    IEngine *engine = vm->engine();
+
+    if (!sprite || !engine)
+        return 0;
+
+    Rect bounds = sprite->boundingRect();
+
+    // Measure distance to edges
+    // Values are zero when the sprite is beyond
+    unsigned int stageWidth = engine->stageWidth();
+    unsigned int stageHeight = engine->stageHeight();
+    double distLeft = std::max(0.0, (stageWidth / 2.0) + bounds.left());
+    double distTop = std::max(0.0, (stageHeight / 2.0) - bounds.top());
+    double distRight = std::max(0.0, (stageWidth / 2.0) - bounds.right());
+    double distBottom = std::max(0.0, (stageHeight / 2.0) + bounds.bottom());
+
+    // Find the nearest edge
+    // 1 - left
+    // 2 - top
+    // 3 - right
+    // 4 - bottom
+    unsigned short nearestEdge = 0;
+    double minDist = std::numeric_limits<double>::infinity();
+
+    if (distLeft < minDist) {
+        minDist = distLeft;
+        nearestEdge = 1;
+    }
+
+    if (distTop < minDist) {
+        minDist = distTop;
+        nearestEdge = 2;
+    }
+
+    if (distRight < minDist) {
+        minDist = distRight;
+        nearestEdge = 3;
+    }
+
+    if (distBottom < minDist) {
+        minDist = distBottom;
+        nearestEdge = 4;
+    }
+
+    if (minDist > 0) {
+        return 0; // Not touching any edge
+    }
+
+    assert(nearestEdge != 0);
+
+    // Point away from the nearest edge
+    double radians = (90 - sprite->direction()) * pi / 180;
+    double dx = std::cos(radians);
+    double dy = -std::sin(radians);
+
+    switch (nearestEdge) {
+        case 1:
+            // Left
+            dx = std::max(0.2, std::abs(dx));
+            break;
+
+        case 2:
+            // Top
+            dy = std::max(0.2, std::abs(dy));
+            break;
+
+        case 3:
+            // Right
+            dx = 0 - std::max(0.2, std::abs(dx));
+            break;
+
+        case 4:
+            // Bottom
+            dy = 0 - std::max(0.2, std::abs(dy));
+            break;
+    }
+
+    double newDirection = (180 / pi) * (std::atan2(dy, dx)) + 90;
+    sprite->setDirection(newDirection);
+
+    // Keep within the stage
+    double fencedX, fencedY;
+    sprite->keepInFence(sprite->x(), sprite->y(), &fencedX, &fencedY);
+    sprite->setX(fencedX);
+    sprite->setY(fencedY);
+
+    return 0;
+}
+
 unsigned int MotionBlocks::setLeftRightRotationStyle(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());

src/blocks/motionblocks.h

@@ -61,6 +61,7 @@ class MotionBlocks : public IBlockSection
         static void compileSetX(Compiler *compiler);
         static void compileChangeYBy(Compiler *compiler);
         static void compileSetY(Compiler *compiler);
+        static void compileIfOnEdgeBounce(Compiler *compiler);
         static void compileSetRotationStyle(Compiler *compiler);
         static void compileXPosition(Compiler *compiler);
         static void compileYPosition(Compiler *compiler);
@@ -98,9 +99,13 @@ class MotionBlocks : public IBlockSection
         static unsigned int setX(VirtualMachine *vm);
         static unsigned int changeYBy(VirtualMachine *vm);
         static unsigned int setY(VirtualMachine *vm);
+
+        static unsigned int ifOnEdgeBounce(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);

src/scratch/sprite.cpp

@@ -353,6 +353,54 @@ Rect Sprite::boundingRect() const
     return ret;
 }
 
+/*!
+ * Keeps the desired position within the stage.
+ * \param[in] New desired X position.
+ * \param[in] New desired Y position.
+ * \param[out] Fenced X position.
+ * \param[out] Fenced Y position.
+ */
+void Sprite::keepInFence(double newX, double newY, double *fencedX, double *fencedY) const
+{
+    // See https://github.com/scratchfoundation/scratch-vm/blob/05dcbc176f51da34aeb9165559fc6acba8087ff8/src/sprites/rendered-target.js#L915-L948
+    IEngine *eng = engine();
+
+    if (!(fencedX && fencedY && eng))
+        return;
+
+    double stageWidth = eng->stageWidth();
+    double stageHeight = eng->stageHeight();
+    Rect fence(-stageWidth / 2, stageHeight / 2, stageWidth / 2, -stageHeight / 2);
+    Rect bounds;
+    impl->getBoundingRect(&bounds);
+
+    // Adjust the known bounds to the target position
+    bounds.setLeft(bounds.left() + newX - impl->x);
+    bounds.setRight(bounds.right() + newX - impl->x);
+    bounds.setTop(bounds.top() + newY - impl->y);
+    bounds.setBottom(bounds.bottom() + newY - impl->y);
+
+    // Find how far we need to move the target position
+    double dx = 0;
+    double dy = 0;
+
+    if (bounds.left() < fence.left()) {
+        dx += fence.left() - bounds.left();
+    }
+    if (bounds.right() > fence.right()) {
+        dx += fence.right() - bounds.right();
+    }
+    if (bounds.top() > fence.top()) {
+        dy += fence.top() - bounds.top();
+    }
+    if (bounds.bottom() < fence.bottom()) {
+        dy += fence.bottom() - bounds.bottom();
+    }
+
+    *fencedX = newX + dx;
+    *fencedY = newY + dy;
+}
+
 /*! Returns the value of the given graphics effect. */
 double Sprite::graphicsEffectValue(IGraphicsEffect *effect) const
 {

test/blocks/motion_blocks_test.cpp

@@ -3,9 +3,13 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/costume.h>
+#include <scratchcpp/scratchconfiguration.h>
 #include <enginemock.h>
 #include <randomgeneratormock.h>
 #include <clockmock.h>
+#include <imageformatfactorymock.h>
+#include <imageformatmock.h>
 
 #include "../common.h"
 #include "blocks/motionblocks.h"
@@ -115,6 +119,7 @@ TEST_F(MotionBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_setx", &MotionBlocks::compileSetX));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_changeyby", &MotionBlocks::compileChangeYBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_sety", &MotionBlocks::compileSetY));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_ifonedgebounce", &MotionBlocks::compileIfOnEdgeBounce));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_setrotationstyle", &MotionBlocks::compileSetRotationStyle));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_xposition", &MotionBlocks::compileXPosition));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_yposition", &MotionBlocks::compileYPosition));
@@ -1085,6 +1090,142 @@ TEST_F(MotionBlocksTest, SetYImpl)
     ASSERT_EQ(sprite.y(), 189.42);
 }
 
+TEST_F(MotionBlocksTest, IfOnEdgeBounce)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "motion_ifonedgebounce");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&MotionBlocks::ifOnEdgeBounce)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    MotionBlocks::compileIfOnEdgeBounce(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(MotionBlocksTest, IfOnEdgeBounceImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &MotionBlocks::ifOnEdgeBounce };
+
+    auto imageFormatFactory = std::make_shared<ImageFormatFactoryMock>();
+    auto imageFormat = std::make_shared<ImageFormatMock>();
+
+    ScratchConfiguration::registerImageFormat("test", imageFormatFactory);
+    EXPECT_CALL(*imageFormatFactory, createInstance()).WillOnce(Return(imageFormat));
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(0));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(0));
+    auto costume = std::make_shared<Costume>("costume1", "a", "test");
+
+    Sprite sprite;
+    sprite.addCostume(costume);
+    sprite.setCostumeIndex(0);
+
+    static char data[5] = "abcd";
+    EXPECT_CALL(*imageFormat, setData(5, data));
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+
+    EXPECT_CALL(*imageFormat, colorAt(0, 0, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    EXPECT_CALL(*imageFormat, colorAt(1, 0, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    EXPECT_CALL(*imageFormat, colorAt(2, 0, 1)).WillOnce(Return(rgba(0, 0, 0, 255)));
+    EXPECT_CALL(*imageFormat, colorAt(3, 0, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+
+    EXPECT_CALL(*imageFormat, colorAt(0, 1, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    EXPECT_CALL(*imageFormat, colorAt(1, 1, 1)).WillOnce(Return(rgba(0, 0, 0, 255)));
+    EXPECT_CALL(*imageFormat, colorAt(2, 1, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    EXPECT_CALL(*imageFormat, colorAt(3, 1, 1)).WillOnce(Return(rgba(0, 0, 0, 255)));
+
+    EXPECT_CALL(*imageFormat, colorAt(0, 2, 1)).WillOnce(Return(rgba(0, 0, 0, 255)));
+    EXPECT_CALL(*imageFormat, colorAt(1, 2, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    EXPECT_CALL(*imageFormat, colorAt(2, 2, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    EXPECT_CALL(*imageFormat, colorAt(3, 2, 1)).WillOnce(Return(rgba(0, 0, 0, 0)));
+    costume->setData(5, data);
+
+    sprite.setEngine(&m_engineMock);
+
+    VirtualMachine vm(&sprite, &m_engineMock, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+
+    EXPECT_CALL(*imageFormat, width()).Times(9).WillRepeatedly(Return(4));
+    EXPECT_CALL(*imageFormat, height()).Times(9).WillRepeatedly(Return(3));
+    EXPECT_CALL(m_engineMock, stageWidth()).Times(9).WillRepeatedly(Return(480));
+    EXPECT_CALL(m_engineMock, stageHeight()).Times(9).WillRepeatedly(Return(360));
+
+    // No edge
+    EXPECT_CALL(m_engineMock, requestRedraw()).Times(3);
+    EXPECT_CALL(m_engineMock, spriteFencingEnabled()).Times(2).WillRepeatedly(Return(false));
+    sprite.setX(100);
+    sprite.setY(60);
+    sprite.setDirection(-45);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(sprite.x(), 100);
+    ASSERT_EQ(sprite.y(), 60);
+    ASSERT_EQ(sprite.direction(), -45);
+
+    // Left edge
+    EXPECT_CALL(m_engineMock, requestRedraw()).Times(5);
+    EXPECT_CALL(m_engineMock, spriteFencingEnabled()).Times(4).WillRepeatedly(Return(false));
+    sprite.setX(-240);
+    sprite.setY(60);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(std::round(sprite.x() * 100) / 100, -238.23);
+    ASSERT_EQ(sprite.y(), 60);
+    ASSERT_EQ(std::round(sprite.direction() * 100) / 100, 45);
+
+    // Top edge
+    EXPECT_CALL(m_engineMock, requestRedraw()).Times(6);
+    EXPECT_CALL(m_engineMock, spriteFencingEnabled()).Times(4).WillRepeatedly(Return(false));
+    sprite.setX(100);
+    sprite.setY(180);
+    sprite.setDirection(45);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(sprite.x(), 100);
+    ASSERT_EQ(std::round(sprite.y() * 100) / 100, 178.23);
+    ASSERT_EQ(sprite.direction(), 135);
+
+    // Right edge
+    EXPECT_CALL(m_engineMock, requestRedraw()).Times(5);
+    EXPECT_CALL(m_engineMock, spriteFencingEnabled()).Times(4).WillRepeatedly(Return(false));
+    sprite.setX(240);
+    sprite.setY(60);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(std::round(sprite.x() * 100) / 100, 238.23);
+    ASSERT_EQ(sprite.y(), 60);
+    ASSERT_EQ(sprite.direction(), -135);
+
+    // Bottom edge
+    EXPECT_CALL(m_engineMock, requestRedraw()).Times(5);
+    EXPECT_CALL(m_engineMock, spriteFencingEnabled()).Times(4).WillRepeatedly(Return(false));
+    sprite.setX(-100);
+    sprite.setY(-180);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(sprite.x(), -100);
+    ASSERT_EQ(std::round(sprite.y() * 100) / 100, -178.23);
+    ASSERT_EQ(std::round(sprite.direction() * 100) / 100, -45);
+
+    ScratchConfiguration::removeImageFormat("test");
+}
+
 TEST_F(MotionBlocksTest, SetRotationStyle)
 {
     Compiler compiler(&m_engineMock);