Merge pull request #525 from scratchcpp/touching_object_block

Implement the touching object block

Author: adazem009

include/scratchcpp/ispritehandler.h

@@ -77,6 +77,12 @@ class LIBSCRATCHCPP_EXPORT ISpriteHandler
          * \note The rectangle must be relative to the stage, so make sure to use the sprite's coordinates.
          */
         virtual Rect fastBoundingRect() const = 0;
+
+        /*! Used to check whether the sprite touches any of the given sprite clones. */
+        virtual bool touchingClones(const std::vector<Sprite *> &clones) const = 0;
+
+        /*! Used to check whether the sprite touches the given point (in Scratch coordinates). */
+        virtual bool touchingPoint(double x, double y) const = 0;
 };
 
 } // namespace libscratchcpp

include/scratchcpp/istagehandler.h

@@ -8,6 +8,8 @@
 namespace libscratchcpp
 {
 
+class Sprite;
+
 /*! \brief The IStageHandler class provides a stage interface for Scratch project players. */
 class LIBSCRATCHCPP_EXPORT IStageHandler
 {
@@ -43,6 +45,21 @@ class LIBSCRATCHCPP_EXPORT IStageHandler
 
         /*! Called when the bubble text changes. */
         virtual void onBubbleTextChanged(const std::string &text) = 0;
+
+        /*! Used to get the bounding rectangle of the stage. */
+        virtual Rect boundingRect() const = 0;
+
+        /*!
+         * Used to get a less accurate bounding rectangle of the stage
+         * which is calculated by transforming the costume rectangle.
+         */
+        virtual Rect fastBoundingRect() const = 0;
+
+        /*! Used to check whether the stage touches any of the given sprite clones. */
+        virtual bool touchingClones(const std::vector<Sprite *> &clones) const = 0;
+
+        /*! Used to check whether the stage touches the given point (in Scratch coordinates). */
+        virtual bool touchingPoint(double x, double y) const = 0;
 };
 
 } // namespace libscratchcpp

include/scratchcpp/sprite.h

@@ -8,7 +8,6 @@ namespace libscratchcpp
 {
 
 class ISpriteHandler;
-class Rect;
 class IGraphicsEffect;
 class SpritePrivate;
 
@@ -69,10 +68,12 @@ class LIBSCRATCHCPP_EXPORT Sprite
 
         void setLayerOrder(int newLayerOrder) override;
 
-        Rect boundingRect() const;
-        Rect fastBoundingRect() const;
+        Rect boundingRect() const override;
+        Rect fastBoundingRect() const override;
         void keepInFence(double newX, double newY, double *fencedX, double *fencedY) const;
 
+        bool touchingPoint(double x, double y) const override;
+
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value) override;
 
         void clearGraphicsEffects() override;
@@ -82,6 +83,7 @@ class LIBSCRATCHCPP_EXPORT Sprite
 
     private:
         Target *dataSource() const override;
+        bool touchingClones(const std::vector<Sprite *> &clones) const override;
         void setXY(double x, double y);
 
         spimpl::unique_impl_ptr<SpritePrivate> impl;

include/scratchcpp/stage.h

@@ -48,6 +48,11 @@ class LIBSCRATCHCPP_EXPORT Stage : public Target
         const std::string &textToSpeechLanguage() const;
         void setTextToSpeechLanguage(const std::string &newTextToSpeechLanguage);
 
+        Rect boundingRect() const override;
+        Rect fastBoundingRect() const override;
+
+        bool touchingPoint(double x, double y) const override;
+
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value) override;
 
         void clearGraphicsEffects() override;
@@ -56,6 +61,8 @@ class LIBSCRATCHCPP_EXPORT Stage : public Target
         virtual void setBubbleText(const std::string &text) override;
 
     private:
+        bool touchingClones(const std::vector<Sprite *> &clones) const override;
+
         spimpl::unique_impl_ptr<StagePrivate> impl;
 };
 

include/scratchcpp/target.h

@@ -6,6 +6,7 @@
 
 #include "global.h"
 #include "spimpl.h"
+#include "rect.h"
 
 namespace libscratchcpp
 {
@@ -17,6 +18,7 @@ class Block;
 class Comment;
 class Costume;
 class Sound;
+class Sprite;
 class IGraphicsEffect;
 class TargetPrivate;
 
@@ -84,6 +86,13 @@ class LIBSCRATCHCPP_EXPORT Target
         double volume() const;
         void setVolume(double newVolume);
 
+        virtual Rect boundingRect() const;
+        virtual Rect fastBoundingRect() const;
+
+        bool touchingSprite(Sprite *sprite) const;
+        virtual bool touchingPoint(double x, double y) const;
+        bool touchingEdge() const;
+
         double graphicsEffectValue(IGraphicsEffect *effect) const;
         virtual void setGraphicsEffectValue(IGraphicsEffect *effect, double value);
 
@@ -102,6 +111,9 @@ class LIBSCRATCHCPP_EXPORT Target
         /*! Override this method to set a custom data source for blocks, assets, comments, etc. */
         virtual Target *dataSource() const { return nullptr; }
 
+        /*! Override this method to check whether the target touches the given sprite clones. */
+        virtual bool touchingClones(const std::vector<Sprite *> &clones) const { return false; }
+
     private:
         spimpl::unique_impl_ptr<TargetPrivate> impl;
 };

src/blocks/sensingblocks.cpp

@@ -30,6 +30,7 @@ std::string SensingBlocks::name() const
 void SensingBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
+    engine->addCompileFunction(this, "sensing_touchingobject", &compileTouchingObject);
     engine->addCompileFunction(this, "sensing_distanceto", &compileDistanceTo);
     engine->addCompileFunction(this, "sensing_askandwait", &compileAskAndWait);
     engine->addCompileFunction(this, "sensing_answer", &compileAnswer);
@@ -56,6 +57,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->addMonitorNameFunction(this, "sensing_dayssince2000", &daysSince2000MonitorName);
 
     // Inputs
+    engine->addInput(this, "TOUCHINGOBJECTMENU", TOUCHINGOBJECTMENU);
     engine->addInput(this, "DISTANCETOMENU", DISTANCETOMENU);
     engine->addInput(this, "QUESTION", QUESTION);
     engine->addInput(this, "KEY_OPTION", KEY_OPTION);
@@ -91,6 +93,29 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->questionAnswered().connect(&onAnswer);
 }
 
+void SensingBlocks::compileTouchingObject(Compiler *compiler)
+{
+    Input *input = compiler->input(TOUCHINGOBJECTMENU);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string value = input->selectedMenuItem();
+
+        if (value == "_mouse_")
+            compiler->addFunctionCall(&touchingMousePointer);
+        else if (value == "_edge_")
+            compiler->addFunctionCall(&touchingEdge);
+        else {
+            int index = compiler->engine()->findTarget(value);
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&touchingObjectByIndex);
+        }
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&touchingObject);
+    }
+}
+
 void SensingBlocks::compileDistanceTo(Compiler *compiler)
 {
     Input *input = compiler->input(DISTANCETOMENU);
@@ -435,6 +460,41 @@ const std::string &SensingBlocks::daysSince2000MonitorName(Block *block)
     return name;
 }
 
+unsigned int SensingBlocks::touchingObject(VirtualMachine *vm)
+{
+    std::string value = vm->getInput(0, 1)->toString();
+
+    if (value == "_mouse_")
+        vm->replaceReturnValue(vm->target()->touchingPoint(vm->engine()->mouseX(), vm->engine()->mouseY()), 1);
+    else if (value == "_edge_")
+        vm->replaceReturnValue(vm->target()->touchingEdge(), 1);
+    else {
+        Target *target = vm->engine()->targetAt(vm->engine()->findTarget(value));
+        vm->replaceReturnValue(touchingObjectCommon(vm->target(), target), 1);
+    }
+
+    return 0;
+}
+
+unsigned int SensingBlocks::touchingObjectByIndex(VirtualMachine *vm)
+{
+    Target *target = vm->engine()->targetAt(vm->getInput(0, 1)->toInt());
+    vm->replaceReturnValue(touchingObjectCommon(vm->target(), target), 1);
+    return 0;
+}
+
+unsigned int SensingBlocks::touchingMousePointer(VirtualMachine *vm)
+{
+    vm->addReturnValue(vm->target()->touchingPoint(vm->engine()->mouseX(), vm->engine()->mouseY()));
+    return 0;
+}
+
+unsigned int SensingBlocks::touchingEdge(VirtualMachine *vm)
+{
+    vm->addReturnValue(vm->target()->touchingEdge());
+    return 0;
+}
+
 unsigned int SensingBlocks::keyPressed(VirtualMachine *vm)
 {
     vm->replaceReturnValue(vm->engine()->keyPressed(vm->getInput(0, 1)->toString()), 1);
@@ -921,6 +981,14 @@ unsigned int SensingBlocks::daysSince2000(VirtualMachine *vm)
     return 0;
 }
 
+bool SensingBlocks::touchingObjectCommon(Target *source, Target *target)
+{
+    if (source && target && !target->isStage())
+        return source->touchingSprite(static_cast<Sprite *>(target));
+
+    return false;
+}
+
 void SensingBlocks::enqueueAsk(const std::string &question, VirtualMachine *vm)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/6055823f203a696165084b873e661713806583ec/src/blocks/scratch3_sensing.js#L117-L119

src/blocks/sensingblocks.h

@@ -20,6 +20,7 @@ class SensingBlocks : public IBlockSection
     public:
         enum Inputs
         {
+            TOUCHINGOBJECTMENU,
             DISTANCETOMENU,
             QUESTION,
             KEY_OPTION,
@@ -59,6 +60,7 @@ class SensingBlocks : public IBlockSection
 
         void registerBlocks(IEngine *engine) override;
 
+        static void compileTouchingObject(Compiler *compiler);
         static void compileDistanceTo(Compiler *compiler);
         static void compileAskAndWait(Compiler *compiler);
         static void compileAnswer(Compiler *compiler);
@@ -83,6 +85,11 @@ class SensingBlocks : public IBlockSection
         static const std::string &currentMonitorName(Block *block);
         static const std::string &daysSince2000MonitorName(Block *block);
 
+        static unsigned int touchingObject(VirtualMachine *vm);
+        static unsigned int touchingObjectByIndex(VirtualMachine *vm);
+        static unsigned int touchingMousePointer(VirtualMachine *vm);
+        static unsigned int touchingEdge(VirtualMachine *vm);
+
         static unsigned int keyPressed(VirtualMachine *vm);
         static unsigned int mouseDown(VirtualMachine *vm);
         static unsigned int mouseX(VirtualMachine *vm);
@@ -154,6 +161,8 @@ class SensingBlocks : public IBlockSection
                 bool wasStage = false;
         };
 
+        static bool touchingObjectCommon(Target *source, Target *target);
+
         static void enqueueAsk(const std::string &question, VirtualMachine *vm);
         static void askNextQuestion();
 

src/scratch/sprite.cpp

@@ -341,7 +341,7 @@ void Sprite::setLayerOrder(int newLayerOrder)
         impl->iface->onLayerOrderChanged(newLayerOrder);
 }
 
-/*! Returns the bounding rectangle of the sprite. */
+/*! Overrides Target#boundingRect(). */
 Rect Sprite::boundingRect() const
 {
     if (!impl->iface)
@@ -350,10 +350,7 @@ Rect Sprite::boundingRect() const
     return impl->iface->boundingRect();
 }
 
-/*!
- * Returns the less accurate bounding rectangle of the sprite
- * which is calculated by transforming the costume rectangle.
- */
+/*! Overrides Target#fastBoundingRect(). */
 Rect Sprite::fastBoundingRect() const
 {
     if (!impl->iface)
@@ -409,6 +406,15 @@ void Sprite::keepInFence(double newX, double newY, double *fencedX, double *fenc
     *fencedY = newY + dy;
 }
 
+/*! Overrides Target#touchingPoint(). */
+bool Sprite::touchingPoint(double x, double y) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingPoint(x, y);
+}
+
 /*! Overrides Target#setGraphicsEffectValue(). */
 void Sprite::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
@@ -471,6 +477,14 @@ Target *Sprite::dataSource() const
     return impl->cloneSprite;
 }
 
+bool Sprite::touchingClones(const std::vector<Sprite *> &clones) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingClones(clones);
+}
+
 void Sprite::setXY(double x, double y)
 {
     IEngine *eng = engine();

src/scratch/stage.cpp

@@ -131,6 +131,33 @@ void Stage::setTextToSpeechLanguage(const std::string &newTextToSpeechLanguage)
     impl->textToSpeechLanguage = newTextToSpeechLanguage;
 }
 
+/*! Overrides Target#boundingRect(). */
+Rect Stage::boundingRect() const
+{
+    if (!impl->iface)
+        return Rect();
+
+    return impl->iface->boundingRect();
+}
+
+/*! Overrides Target#boundingRect(). */
+Rect Stage::fastBoundingRect() const
+{
+    if (!impl->iface)
+        return Rect();
+
+    return impl->iface->fastBoundingRect();
+}
+
+/*! Overrides Target#touchingPoint(). */
+bool Stage::touchingPoint(double x, double y) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingPoint(x, y);
+}
+
 /*! Overrides Target#setGraphicsEffectValue(). */
 void Stage::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
@@ -181,3 +208,11 @@ void Stage::setBubbleText(const std::string &text)
     if (impl->iface)
         impl->iface->onBubbleTextChanged(text);
 }
+
+bool Stage::touchingClones(const std::vector<Sprite *> &clones) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingClones(clones);
+}