Merge pull request #299 from scratchcpp/sprite_fencing

Add sprite fencing

Author: adazem009

include/scratchcpp/sprite.h

@@ -67,6 +67,7 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
 
     private:
         Target *dataSource() const override;
+        void setXY(double x, double y);
 
         spimpl::unique_impl_ptr<SpritePrivate> impl;
 };

src/scratch/costume.cpp

@@ -26,7 +26,11 @@ double Costume::bitmapResolution() const
 /*! Sets the reciprocal of the costume scaling factor for bitmap costumes. */
 void Costume::setBitmapResolution(double newBitmapResolution)
 {
+    if (impl->bitmapResolution == newBitmapResolution)
+        return;
+
     impl->bitmapResolution = newBitmapResolution;
+    impl->updateImage();
 }
 
 /*! Returns the x-coordinate of the rotation center. */
@@ -56,13 +60,13 @@ void Costume::setRotationCenterY(int newRotationCenterY)
 /*! Returns the costume width. */
 unsigned int Costume::width() const
 {
-    return impl->image->width() * impl->scale;
+    return impl->image->width() * impl->scale / impl->bitmapResolution;
 }
 
 /*! Returns the costume height. */
 unsigned int Costume::height() const
 {
-    return impl->image->height() * impl->scale;
+    return impl->image->height() * impl->scale / impl->bitmapResolution;
 }
 
 /*! Returns the image scale. */

src/scratch/costume_p.cpp

@@ -16,29 +16,30 @@ CostumePrivate::~CostumePrivate()
 
 void CostumePrivate::updateImage()
 {
-    unsigned int scaledWidth = image->width() * scale;
-    unsigned int scaledHeight = image->height() * scale;
+    unsigned int scaledWidth = image->width() * scale / bitmapResolution;
+    unsigned int scaledHeight = image->height() * scale / bitmapResolution;
 
     if (scaledWidth == 0 || scaledHeight == 0) {
         freeImage();
         return;
     }
 
-    if (!bitmap || (scale != oldScale)) {
+    if (!bitmap || (scale != oldScale) || (bitmapResolution != oldBitmapResolution)) {
         freeImage();
         bitmap = static_cast<Rgb **>(malloc(sizeof(Rgb *) * scaledHeight));
 
         for (unsigned int i = 0; i < scaledHeight; i++)
             bitmap[i] = static_cast<Rgb *>(malloc(sizeof(Rgb) * scaledWidth));
 
         oldScale = scale;
+        oldBitmapResolution = bitmapResolution;
         oldWidth = scaledWidth;
         oldHeight = scaledHeight;
     }
 
     for (unsigned int i = 0; i < scaledHeight; i++) {
         for (unsigned int j = 0; j < scaledWidth; j++) {
-            Rgb color = image->colorAt(mirrorHorizontally ? (scaledWidth - 1 - j) : j, i, scale);
+            Rgb color = image->colorAt(mirrorHorizontally ? (scaledWidth - 1 - j) : j, i, scale / bitmapResolution);
 
             // TODO: Apply graphics effects here
 

src/scratch/costume_p.h

@@ -19,6 +19,7 @@ struct CostumePrivate
         void updateImage();
         void freeImage();
 
+        double oldBitmapResolution = 1;
         double bitmapResolution = 1;
         int rotationCenterX = 0;
         int rotationCenterY = 0;

src/scratch/sprite.cpp

@@ -162,7 +162,8 @@ double Sprite::x() const
 /*! Sets the X position of the sprite. */
 void Sprite::setX(double newX)
 {
-    impl->x = newX;
+    setXY(newX, impl->y);
+
     if (impl->iface)
         impl->iface->onXChanged(impl->x);
 }
@@ -176,7 +177,8 @@ double Sprite::y() const
 /*! Sets the Y position of the sprite. */
 void Sprite::setY(double newY)
 {
-    impl->y = newY;
+    setXY(impl->x, newY);
+
     if (impl->iface)
         impl->iface->onYChanged(impl->y);
 }
@@ -311,3 +313,8 @@ Target *Sprite::dataSource() const
 {
     return impl->cloneRoot;
 }
+
+void Sprite::setXY(double x, double y)
+{
+    impl->getFencedPosition(x, y, &impl->x, &impl->y);
+}

src/scratch/sprite_p.cpp

@@ -3,13 +3,15 @@
 #include <scratchcpp/ispritehandler.h>
 #include <scratchcpp/rect.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/iengine.h>
 #include <cmath>
 
 #include "sprite_p.h"
 
 using namespace libscratchcpp;
 
 static const double pi = std::acos(-1); // TODO: Use std::numbers::pi in C++20
+static const double FENCE_WIDTH = 15;
 
 SpritePrivate::SpritePrivate(Sprite *sprite) :
     sprite(sprite)
@@ -43,10 +45,10 @@ void SpritePrivate::getBoundingRect(Rect *out) const
     auto costume = sprite->costumeAt(sprite->currentCostume() - 1);
 
     if (!costume) {
-        out->setLeft(0);
-        out->setTop(0);
-        out->setRight(0);
-        out->setBottom(0);
+        out->setLeft(x);
+        out->setTop(y);
+        out->setRight(x);
+        out->setBottom(y);
         return;
     }
 
@@ -90,3 +92,43 @@ void SpritePrivate::getBoundingRect(Rect *out) const
     out->setRight(x + maxX);
     out->setBottom(y + minY);
 }
+
+void SpritePrivate::getFencedPosition(double x, double y, double *outX, double *outY) const
+{
+    assert(outX);
+    assert(outY);
+
+    if (!sprite->engine()) {
+        *outX = x;
+        *outY = y;
+        return;
+    }
+
+    // https://github.com/scratchfoundation/scratch-render/blob/0b51e5a66ae1c8102fe881107145d7ef3d71a1ab/src/RenderWebGL.js#L1526
+    double dx = x - this->x;
+    double dy = y - this->y;
+    Rect rect;
+    getBoundingRect(&rect);
+    double inset = std::floor(std::min(rect.width(), rect.height()) / 2);
+
+    double xRight = sprite->engine()->stageWidth() / 2;
+    double sx = xRight - std::min(FENCE_WIDTH, inset);
+
+    if (rect.right() + dx < -sx) {
+        x = std::ceil(this->x - (sx + rect.right()));
+    } else if (rect.left() + dx > sx) {
+        x = std::floor(this->x + (sx - rect.left()));
+    }
+
+    double yTop = sprite->engine()->stageHeight() / 2;
+    double sy = yTop - std::min(FENCE_WIDTH, inset);
+
+    if (rect.top() + dy < -sy) {
+        y = std::ceil(this->y - (sy + rect.top()));
+    } else if (rect.bottom() + dy > sy) {
+        y = std::floor(this->y + (sy - rect.bottom()));
+    }
+
+    *outX = x;
+    *outY = y;
+}

src/scratch/sprite_p.h

@@ -18,6 +18,7 @@ struct SpritePrivate
 
         void setCostumeData(const char *data);
         void getBoundingRect(Rect *out) const;
+        void getFencedPosition(double inX, double inY, double *outX, double *outY) const;
 
         Sprite *sprite = nullptr;
         ISpriteHandler *iface = nullptr;

test/scratch_classes/sprite_test.cpp

@@ -1,9 +1,11 @@
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/stage.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/scratchconfiguration.h>
 #include <scratchcpp/rect.h>
+#include <scratchcpp/project.h>
 #include <enginemock.h>
 #include <imageformatfactorymock.h>
 #include <imageformatmock.h>
@@ -206,28 +208,142 @@ TEST(SpriteTest, Clone)
     sprite.reset();
 }
 
-TEST(SpriteTest, X)
+TEST(SpriteTest, XY)
 {
     Sprite sprite;
     ASSERT_EQ(sprite.x(), 0);
+    ASSERT_EQ(sprite.y(), 0);
 
     sprite.setX(-53.25);
     ASSERT_EQ(sprite.x(), -53.25);
 
     sprite.setX(239.999);
     ASSERT_EQ(sprite.x(), 239.999);
-}
-
-TEST(SpriteTest, Y)
-{
-    Sprite sprite;
-    ASSERT_EQ(sprite.y(), 0);
 
     sprite.setY(-53.25);
     ASSERT_EQ(sprite.y(), -53.25);
 
     sprite.setY(179.999);
     ASSERT_EQ(sprite.y(), 179.999);
+
+    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.addCostume(costume);
+    sprite.setCurrentCostume(1);
+
+    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);
+
+    EngineMock engine;
+    sprite.setEngine(&engine);
+    sprite.setDirection(34.45);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setX(230);
+    ASSERT_EQ(sprite.x(), 230);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setX(-230);
+    ASSERT_EQ(sprite.x(), -230);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setX(250);
+    ASSERT_EQ(sprite.x(), 241);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setX(-250);
+    ASSERT_EQ(sprite.x(), -241);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setY(170);
+    ASSERT_EQ(sprite.y(), 170);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setY(-170);
+    ASSERT_EQ(sprite.y(), -170);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setY(190);
+    ASSERT_EQ(sprite.y(), 181);
+
+    EXPECT_CALL(*imageFormat, width()).WillOnce(Return(4));
+    EXPECT_CALL(*imageFormat, height()).WillOnce(Return(3));
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    sprite.setY(-190);
+    ASSERT_EQ(sprite.y(), -180);
+
+    ScratchConfiguration::removeImageFormat("test");
+}
+
+TEST(SpriteTest, Fencing)
+{
+    Project p("sprite_fencing.sb3");
+    ASSERT_TRUE(p.load());
+    p.run();
+
+    auto engine = p.engine();
+
+    Stage *stage = engine->stage();
+    ASSERT_TRUE(stage);
+
+    ASSERT_VAR(stage, "maxX");
+    ASSERT_EQ(GET_VAR(stage, "maxX")->value().toDouble(), 240);
+
+    ASSERT_VAR(stage, "maxY");
+    ASSERT_EQ(GET_VAR(stage, "maxY")->value().toDouble(), 205);
+
+    ASSERT_VAR(stage, "minX");
+    ASSERT_EQ(GET_VAR(stage, "minX")->value().toDouble(), -362);
+
+    ASSERT_VAR(stage, "minY");
+    ASSERT_EQ(GET_VAR(stage, "minY")->value().toDouble(), -213);
 }
 
 TEST(SpriteTest, Size)

test/sprite_fencing.sb3

@@ -51,13 +51,17 @@ TEST_F(ISpriteHandlerTest, Visible)
 
 TEST_F(ISpriteHandlerTest, X)
 {
-    EXPECT_CALL(m_handler, onXChanged(300.25)).Times(1);
-    m_sprite.setX(300.25);
+    EXPECT_CALL(m_handler, onXChanged(189.46)).Times(1);
+    EXPECT_CALL(m_engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(m_engine, stageHeight()).WillOnce(Return(360));
+    m_sprite.setX(189.46);
 }
 
 TEST_F(ISpriteHandlerTest, Y)
 {
     EXPECT_CALL(m_handler, onYChanged(-153.7)).Times(1);
+    EXPECT_CALL(m_engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(m_engine, stageHeight()).WillOnce(Return(360));
     m_sprite.setY(-153.7);
 }