Merge pull request #529 from scratchcpp/touching_color_block

adazem009 · web-flow · commit 072a37b073d2 · 2024-04-01T13:56:33.000+02:00
Implement the touching color block
diff --git a/include/scratchcpp/ispritehandler.h b/include/scratchcpp/ispritehandler.h
@@ -83,6 +83,9 @@ class LIBSCRATCHCPP_EXPORT ISpriteHandler
 
         /*! Used to check whether the sprite touches the given point (in Scratch coordinates). */
         virtual bool touchingPoint(double x, double y) const = 0;
+
+        /*! Used to check whether the sprite touches the given color. */
+        virtual bool touchingColor(const Value &color) const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/istagehandler.h b/include/scratchcpp/istagehandler.h
@@ -60,6 +60,9 @@ class LIBSCRATCHCPP_EXPORT IStageHandler
 
         /*! Used to check whether the stage touches the given point (in Scratch coordinates). */
         virtual bool touchingPoint(double x, double y) const = 0;
+
+        /*! Used to check whether the stage touches the given color. */
+        virtual bool touchingColor(const Value &color) const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
@@ -73,6 +73,7 @@ class LIBSCRATCHCPP_EXPORT Sprite
         void keepInFence(double newX, double newY, double *fencedX, double *fencedY) const;
 
         bool touchingPoint(double x, double y) const override;
+        bool touchingColor(const Value &color) const override;
 
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value) override;
 
diff --git a/include/scratchcpp/stage.h b/include/scratchcpp/stage.h
@@ -52,6 +52,7 @@ class LIBSCRATCHCPP_EXPORT Stage : public Target
         Rect fastBoundingRect() const override;
 
         bool touchingPoint(double x, double y) const override;
+        bool touchingColor(const Value &color) const override;
 
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value) override;
 
diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
@@ -92,6 +92,7 @@ class LIBSCRATCHCPP_EXPORT Target
         bool touchingSprite(Sprite *sprite) const;
         virtual bool touchingPoint(double x, double y) const;
         bool touchingEdge() const;
+        virtual bool touchingColor(const Value &color) const;
 
         double graphicsEffectValue(IGraphicsEffect *effect) const;
         virtual void setGraphicsEffectValue(IGraphicsEffect *effect, double value);
diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
@@ -31,6 +31,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
     engine->addCompileFunction(this, "sensing_touchingobject", &compileTouchingObject);
+    engine->addCompileFunction(this, "sensing_touchingcolor", &compileTouchingColor);
     engine->addCompileFunction(this, "sensing_distanceto", &compileDistanceTo);
     engine->addCompileFunction(this, "sensing_askandwait", &compileAskAndWait);
     engine->addCompileFunction(this, "sensing_answer", &compileAnswer);
@@ -58,6 +59,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
 
     // Inputs
     engine->addInput(this, "TOUCHINGOBJECTMENU", TOUCHINGOBJECTMENU);
+    engine->addInput(this, "COLOR", COLOR);
     engine->addInput(this, "DISTANCETOMENU", DISTANCETOMENU);
     engine->addInput(this, "QUESTION", QUESTION);
     engine->addInput(this, "KEY_OPTION", KEY_OPTION);
@@ -116,6 +118,12 @@ void SensingBlocks::compileTouchingObject(Compiler *compiler)
     }
 }
 
+void SensingBlocks::compileTouchingColor(Compiler *compiler)
+{
+    compiler->addInput(COLOR);
+    compiler->addFunctionCall(&touchingColor);
+}
+
 void SensingBlocks::compileDistanceTo(Compiler *compiler)
 {
     Input *input = compiler->input(DISTANCETOMENU);
@@ -495,6 +503,12 @@ unsigned int SensingBlocks::touchingEdge(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int SensingBlocks::touchingColor(VirtualMachine *vm)
+{
+    vm->replaceReturnValue(vm->target()->touchingColor(*vm->getInput(0, 1)), 1);
+    return 0;
+}
+
 unsigned int SensingBlocks::keyPressed(VirtualMachine *vm)
 {
     vm->replaceReturnValue(vm->engine()->keyPressed(vm->getInput(0, 1)->toString()), 1);
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
@@ -21,6 +21,7 @@ class SensingBlocks : public IBlockSection
         enum Inputs
         {
             TOUCHINGOBJECTMENU,
+            COLOR,
             DISTANCETOMENU,
             QUESTION,
             KEY_OPTION,
@@ -61,6 +62,7 @@ class SensingBlocks : public IBlockSection
         void registerBlocks(IEngine *engine) override;
 
         static void compileTouchingObject(Compiler *compiler);
+        static void compileTouchingColor(Compiler *compiler);
         static void compileDistanceTo(Compiler *compiler);
         static void compileAskAndWait(Compiler *compiler);
         static void compileAnswer(Compiler *compiler);
@@ -90,6 +92,8 @@ class SensingBlocks : public IBlockSection
         static unsigned int touchingMousePointer(VirtualMachine *vm);
         static unsigned int touchingEdge(VirtualMachine *vm);
 
+        static unsigned int touchingColor(VirtualMachine *vm);
+
         static unsigned int keyPressed(VirtualMachine *vm);
         static unsigned int mouseDown(VirtualMachine *vm);
         static unsigned int mouseX(VirtualMachine *vm);
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
@@ -415,6 +415,15 @@ bool Sprite::touchingPoint(double x, double y) const
     return impl->iface->touchingPoint(x, y);
 }
 
+/*! Overrides Target#touchingColor(). */
+bool Sprite::touchingColor(const Value &color) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingColor(color);
+}
+
 /*! Overrides Target#setGraphicsEffectValue(). */
 void Sprite::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
diff --git a/src/scratch/stage.cpp b/src/scratch/stage.cpp
@@ -158,6 +158,15 @@ bool Stage::touchingPoint(double x, double y) const
     return impl->iface->touchingPoint(x, y);
 }
 
+/*! Overrides Target#touchingColor(). */
+bool Stage::touchingColor(const Value &color) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingColor(color);
+}
+
 /*! Overrides Target#setGraphicsEffectValue(). */
 void Stage::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
@@ -476,6 +476,12 @@ bool Target::touchingEdge() const
     return false;
 }
 
+/*! Returns true if the Target is touching the given color (RGB triplet). */
+bool Target::touchingColor(const Value &color) const
+{
+    return false;
+}
+
 /*! Returns the value of the given graphics effect. */
 double Target::graphicsEffectValue(IGraphicsEffect *effect) const
 {
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
@@ -54,6 +54,14 @@ class SensingBlocksTest : public testing::Test
             return block;
         }
 
+        void addValueInput(std::shared_ptr<Block> block, const std::string &name, SensingBlocks::Inputs id, const Value &value) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::Shadow);
+            input->setPrimaryValue(value);
+            input->setInputId(id);
+            block->addInput(input);
+        }
+
         void addObscuredInput(std::shared_ptr<Block> block, const std::string &name, SensingBlocks::Inputs id, std::shared_ptr<Block> valueBlock) const
         {
             auto input = std::make_shared<Input>(name, Input::Type::ObscuredShadow);
@@ -117,6 +125,7 @@ TEST_F(SensingBlocksTest, RegisterBlocks)
 {
     // Blocks
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_touchingobject", &SensingBlocks::compileTouchingObject));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_touchingcolor", &SensingBlocks::compileTouchingColor));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_distanceto", &SensingBlocks::compileDistanceTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_askandwait", &SensingBlocks::compileAskAndWait));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_answer", &SensingBlocks::compileAnswer));
@@ -144,6 +153,7 @@ TEST_F(SensingBlocksTest, RegisterBlocks)
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TOUCHINGOBJECTMENU", SensingBlocks::TOUCHINGOBJECTMENU));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "COLOR", SensingBlocks::COLOR));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DISTANCETOMENU", SensingBlocks::DISTANCETOMENU));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "QUESTION", SensingBlocks::QUESTION));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "KEY_OPTION", SensingBlocks::KEY_OPTION));
@@ -371,6 +381,78 @@ TEST_F(SensingBlocksTest, TouchingObjectImpl)
     ASSERT_FALSE(vm.getInput(0, 1)->toBool());
 }
 
+TEST_F(SensingBlocksTest, TouchingColor)
+{
+    Compiler compiler(&m_engineMock);
+
+    // touching color (#FFFF00)
+    auto block1 = std::make_shared<Block>("a", "sensing_touchingcolor");
+    addValueInput(block1, "COLOR", SensingBlocks::COLOR, "#FFFF00");
+
+    // touching color (null block)
+    auto block2 = std::make_shared<Block>("b", "sensing_touchingcolor");
+    addDropdownInput(block2, "COLOR", SensingBlocks::COLOR, "", createNullBlock("c"));
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::touchingColor)).WillOnce(Return(1));
+    compiler.setBlock(block1);
+    SensingBlocks::compileTouchingColor(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::touchingColor)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    SensingBlocks::compileTouchingColor(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 1, vm::OP_NULL, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0].toString(), "#FFFF00");
+}
+
+TEST_F(SensingBlocksTest, TouchingColorImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::touchingColor };
+    static Value constValues[] = { "#FFFF00", 1946195606 };
+
+    TargetMock target;
+    Sprite sprite;
+    VirtualMachine vm(&target, nullptr, nullptr);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    EXPECT_CALL(target, touchingColor(constValues[0])).WillOnce(Return(false));
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(target, touchingColor(constValues[0])).WillOnce(Return(true));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(target, touchingColor(constValues[1])).WillOnce(Return(false));
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(target, touchingColor(constValues[1])).WillOnce(Return(true));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+}
+
 TEST_F(SensingBlocksTest, DistanceTo)
 {
     Compiler compiler(&m_engineMock);
diff --git a/test/mocks/spritehandlermock.h b/test/mocks/spritehandlermock.h
@@ -34,4 +34,5 @@ class SpriteHandlerMock : public ISpriteHandler
 
         MOCK_METHOD(bool, touchingClones, (const std::vector<Sprite *> &), (const, override));
         MOCK_METHOD(bool, touchingPoint, (double, double), (const, override));
+        MOCK_METHOD(bool, touchingColor, (const Value &), (const, override));
 };
diff --git a/test/mocks/stagehandlermock.h b/test/mocks/stagehandlermock.h
@@ -25,4 +25,5 @@ class StageHandlerMock : public IStageHandler
 
         MOCK_METHOD(bool, touchingClones, (const std::vector<Sprite *> &), (const, override));
         MOCK_METHOD(bool, touchingPoint, (double, double), (const, override));
+        MOCK_METHOD(bool, touchingColor, (const Value &), (const, override));
 };
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
@@ -18,6 +18,8 @@ class TargetMock : public Target
 
         MOCK_METHOD(bool, touchingPoint, (double, double), (const, override));
 
+        MOCK_METHOD(bool, touchingColor, (const Value &), (const, override));
+
         MOCK_METHOD(void, setGraphicsEffectValue, (IGraphicsEffect *, double), (override));
         MOCK_METHOD(void, clearGraphicsEffects, (), (override));
 
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
@@ -703,6 +703,23 @@ TEST(SpriteTest, TouchingPoint)
     ASSERT_TRUE(sprite.touchingPoint(-12.46, 120.72));
 }
 
+TEST(SpriteTest, TouchingColor)
+{
+    Sprite sprite;
+    ASSERT_FALSE(sprite.touchingColor(0));
+
+    SpriteHandlerMock iface;
+    EXPECT_CALL(iface, init);
+    sprite.setInterface(&iface);
+
+    Value v1 = 4278228630, v2 = "#FF00FA";
+    EXPECT_CALL(iface, touchingColor(v1)).WillOnce(Return(false));
+    ASSERT_FALSE(sprite.touchingColor(v1));
+
+    EXPECT_CALL(iface, touchingColor(v2)).WillOnce(Return(true));
+    ASSERT_TRUE(sprite.touchingColor(v2));
+}
+
 TEST(SpriteTest, GraphicsEffects)
 {
     Sprite sprite;
diff --git a/test/scratch_classes/stage_test.cpp b/test/scratch_classes/stage_test.cpp
@@ -1,6 +1,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/value.h>
 #include <enginemock.h>
 #include <graphicseffectmock.h>
 #include <stagehandlermock.h>
@@ -195,6 +196,23 @@ TEST(StageTest, TouchingPoint)
     ASSERT_TRUE(stage.touchingPoint(-12.46, 120.72));
 }
 
+TEST(SpriteTest, TouchingColor)
+{
+    Stage stage;
+    ASSERT_FALSE(stage.touchingColor(0));
+
+    StageHandlerMock iface;
+    EXPECT_CALL(iface, init);
+    stage.setInterface(&iface);
+
+    Value v1 = 4278228630, v2 = "#FF00FA";
+    EXPECT_CALL(iface, touchingColor(v1)).WillOnce(Return(false));
+    ASSERT_FALSE(stage.touchingColor(v1));
+
+    EXPECT_CALL(iface, touchingColor(v2)).WillOnce(Return(true));
+    ASSERT_TRUE(stage.touchingColor(v2));
+}
+
 TEST(StageTest, GraphicsEffects)
 {
     Stage stage;
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
@@ -702,6 +702,13 @@ TEST(TargetTest, TouchingEdge)
     ASSERT_TRUE(sprite.touchingEdge());
 }
 
+TEST(TargetTest, TouchingColor)
+{
+    Target target;
+    Value v;
+    ASSERT_FALSE(target.touchingColor(v));
+}
+
 TEST(TargetTest, GraphicsEffects)
 {
     Target target;

Original file line number	Diff line number	Diff line change
`@@ -476,6 +476,12 @@ bool Target::touchingEdge() const`
`476`	`476`	`return false;`
`477`	`477`	`}`
`478`	`478`
	`479`	`+/! Returns true if the Target is touching the given color (RGB triplet). /`
	`480`	`+bool Target::touchingColor(const Value &color) const`
	`481`	`+{`
	`482`	`+ return false;`
	`483`	`+}`
	`484`	`+`
`479`	`485`	`/! Returns the value of the given graphics effect. /`
`480`	`486`	`double Target::graphicsEffectValue(IGraphicsEffect *effect) const`
`481`	`487`	`{`