Implement motion_ifonedgebounce block

Author: adazem009

src/blocks/motionblocks.cpp

@@ -51,6 +51,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);
 }
 
 CompilerValue *MotionBlocks::compileMoveSteps(Compiler *compiler)
@@ -290,6 +291,14 @@ CompilerValue *MotionBlocks::compileSetY(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *MotionBlocks::compileIfOnEdgeBounce(Compiler *compiler)
+{
+    if (!compiler->target()->isStage())
+        compiler->addTargetFunctionCall("motion_ifonedgebounce");
+
+    return nullptr;
+}
+
 extern "C" void motion_movesteps(Sprite *sprite, double steps)
 {
     double dir = sprite->direction();
@@ -574,6 +583,90 @@ extern "C" void motion_sety(Sprite *sprite, double y)
     sprite->setY(y);
 }
 
+extern "C" void motion_ifonedgebounce(Sprite *sprite)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/c37745e97e6d8a77ad1dc31a943ea728dd17ba78/src/blocks/scratch3_motion.js#L186-L240
+    IEngine *engine = sprite->engine();
+    Rect bounds = sprite->boundingRect();
+
+    // Measure distance to edges
+    // Values are zero when the sprite is beyond
+    double stageWidth = engine->stageWidth();
+    double 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; // 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->setPosition(fencedX, fencedY);
+}
+
 extern "C" double motion_xposition(Sprite *sprite)
 {
     return sprite->x();

src/blocks/motionblocks.h

@@ -30,6 +30,7 @@ class MotionBlocks : public IExtension
         static CompilerValue *compileSetX(Compiler *compiler);
         static CompilerValue *compileChangeYBy(Compiler *compiler);
         static CompilerValue *compileSetY(Compiler *compiler);
+        static CompilerValue *compileIfOnEdgeBounce(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/blocks/motion_blocks_test.cpp

@@ -10,6 +10,7 @@
 #include <enginemock.h>
 #include <randomgeneratormock.h>
 #include <stacktimermock.h>
+#include <spritehandlermock.h>
 
 #include "../common.h"
 #include "blocks/motionblocks.h"
@@ -1730,3 +1731,94 @@ TEST_F(MotionBlocksTest, SetY)
         builder.run();
     }
 }
+
+TEST_F(MotionBlocksTest, IfOnEdgeBounce)
+{
+    {
+        auto sprite = std::make_shared<Sprite>();
+        SpriteHandlerMock handler;
+        sprite->setInterface(&handler);
+        sprite->setEngine(&m_engineMock);
+
+        ScriptBuilder builder(m_extension.get(), m_engine, sprite);
+
+        builder.addBlock("motion_ifonedgebounce");
+        auto block = builder.currentBlock();
+
+        Compiler compiler(&m_engineMock, sprite.get());
+        auto code = compiler.compile(block);
+        Script script(sprite.get(), block, &m_engineMock);
+        script.setCode(code);
+        Thread thread(sprite.get(), &m_engineMock, &script);
+
+        EXPECT_CALL(m_engineMock, stageWidth()).WillRepeatedly(Return(480));
+        EXPECT_CALL(m_engineMock, stageHeight()).WillRepeatedly(Return(360));
+        EXPECT_CALL(m_engineMock, spriteFencingEnabled()).WillRepeatedly(Return(false));
+
+        // No edge
+        EXPECT_CALL(handler, boundingRect()).WillOnce(Return(Rect(80, 80, 120, 40)));
+        sprite->setX(100);
+        sprite->setY(60);
+        sprite->setDirection(-45);
+        thread.run();
+
+        ASSERT_EQ(sprite->x(), 100);
+        ASSERT_EQ(sprite->y(), 60);
+        ASSERT_EQ(sprite->direction(), -45);
+
+        // Left edge
+        EXPECT_CALL(handler, boundingRect()).Times(2).WillRepeatedly(Return(Rect(-260, 80, -220, 40)));
+        sprite->setX(-240);
+        sprite->setY(60);
+        thread.reset();
+        thread.run();
+
+        ASSERT_EQ(sprite->x(), -220);
+        ASSERT_EQ(sprite->y(), 60);
+        ASSERT_EQ(std::round(sprite->direction() * 100) / 100, 45);
+
+        // Top edge
+        EXPECT_CALL(handler, boundingRect()).Times(2).WillRepeatedly(Return(Rect(80, 200, 120, 160)));
+        sprite->setX(100);
+        sprite->setY(180);
+        sprite->setDirection(45);
+        thread.reset();
+        thread.run();
+
+        ASSERT_EQ(sprite->x(), 100);
+        ASSERT_EQ(sprite->y(), 160);
+        ASSERT_EQ(sprite->direction(), 135);
+
+        // Right edge
+        EXPECT_CALL(handler, boundingRect()).Times(2).WillRepeatedly(Return(Rect(220, 80, 260, 40)));
+        sprite->setX(240);
+        sprite->setY(60);
+        thread.reset();
+        thread.run();
+
+        ASSERT_EQ(sprite->x(), 220);
+        ASSERT_EQ(sprite->y(), 60);
+        ASSERT_EQ(sprite->direction(), -135);
+
+        // Bottom edge
+        EXPECT_CALL(handler, boundingRect()).Times(2).WillRepeatedly(Return(Rect(-120, -160, -80, -200)));
+        sprite->setX(-100);
+        sprite->setY(-180);
+        thread.reset();
+        thread.run();
+
+        ASSERT_EQ(sprite->x(), -100);
+        ASSERT_EQ(sprite->y(), -160);
+        ASSERT_EQ(std::round(sprite->direction() * 100) / 100, -45);
+    }
+
+    {
+        auto stage = std::make_shared<Stage>();
+        ScriptBuilder builder(m_extension.get(), m_engine, stage);
+
+        builder.addBlock("motion_ifonedgebounce");
+
+        builder.build();
+        builder.run();
+    }
+}