Add getVisibleTargets() method to IEngine

Resolves: #533

Author: adazem009

include/scratchcpp/iengine.h

@@ -331,6 +331,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the target at index. */
         virtual Target *targetAt(int index) const = 0;
 
+        /*! Gets visible targets sorted by layer order and stores them in the given vector. */
+        virtual void getVisibleTargets(std::vector<Target *> &dst) const = 0;
+
         /*!
          * Returns the index of the target with the given name.
          * \note Using "Stage" will return the index of the sprite with this name, or nullptr if it doesn't exist.

src/engine/internal/engine.cpp

@@ -1227,6 +1227,33 @@ Target *Engine::targetAt(int index) const
     return m_targets[index].get();
 }
 
+void Engine::getVisibleTargets(std::vector<Target *> &dst) const
+{
+    dst.clear();
+
+    for (auto target : m_targets) {
+        assert(target);
+
+        if (target->isStage())
+            dst.push_back(target.get());
+        else {
+            Sprite *sprite = static_cast<Sprite *>(target.get());
+
+            if (sprite->visible())
+                dst.push_back(target.get());
+
+            const auto &clones = sprite->clones();
+
+            for (auto clone : clones) {
+                if (clone->visible())
+                    dst.push_back(clone.get());
+            }
+        }
+    }
+
+    std::sort(dst.begin(), dst.end(), [](Target *t1, Target *t2) { return t1->layerOrder() > t2->layerOrder(); });
+}
+
 int Engine::findTarget(const std::string &targetName) const
 {
     auto it = std::find_if(m_targets.begin(), m_targets.end(), [targetName](std::shared_ptr<Target> target) {

src/engine/internal/engine.h

@@ -138,6 +138,7 @@ class Engine : public IEngine
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
         Target *targetAt(int index) const override;
+        void getVisibleTargets(std::vector<Target *> &dst) const override;
         int findTarget(const std::string &targetName) const override;
 
         void moveSpriteToFront(Sprite *sprite) override;

test/engine/engine_test.cpp

@@ -1411,16 +1411,21 @@ TEST(EngineTest, Targets)
     Engine engine;
     ASSERT_TRUE(engine.targets().empty());
 
-    auto t1 = std::make_shared<Target>();
+    auto t1 = std::make_shared<Sprite>();
     t1->setName("Sprite1");
-    auto t2 = std::make_shared<Target>();
+    t1->setVisible(true);
+    t1->setLayerOrder(3);
+    auto t2 = std::make_shared<Sprite>();
     auto block1 = std::make_shared<Block>("", "");
     auto block2 = std::make_shared<Block>("", "");
     t2->setName("Sprite2");
+    t2->setVisible(false);
+    t2->setLayerOrder(1);
     t2->addBlock(block1);
     t2->addBlock(block2);
     auto t3 = std::make_shared<Stage>();
     t3->setName("Stage");
+    t3->setLayerOrder(0);
     engine.setTargets({ t1, t2, t3 });
 
     ASSERT_EQ(engine.targets(), std::vector<std::shared_ptr<Target>>({ t1, t2, t3 }));
@@ -1436,16 +1441,25 @@ TEST(EngineTest, Targets)
     ASSERT_EQ(engine.findTarget("Stage"), -1);
     ASSERT_EQ(engine.findTarget("_stage_"), 2);
 
-    auto t4 = std::make_shared<Target>();
+    auto t4 = std::make_shared<Sprite>();
     t4->setName("Stage");
+    t4->setVisible(true);
+    t4->setLayerOrder(2);
     engine.setTargets({ t1, t2, t4 });
     ASSERT_EQ(engine.findTarget("Stage"), 2);
     ASSERT_EQ(engine.findTarget("_stage_"), -1);
 
+    std::vector<Target *> visibleTargets;
+    engine.getVisibleTargets(visibleTargets);
+    ASSERT_EQ(visibleTargets, std::vector<Target *>({ t1.get(), t4.get() }));
+
     engine.setTargets({ t1, t2, t3, t4 });
     ASSERT_EQ(engine.findTarget("Stage"), 3);
     ASSERT_EQ(engine.findTarget("_stage_"), 2);
 
+    engine.getVisibleTargets(visibleTargets);
+    ASSERT_EQ(visibleTargets, std::vector<Target *>({ t1.get(), t4.get(), t3.get() }));
+
     ASSERT_EQ(t1->engine(), &engine);
     ASSERT_EQ(t2->engine(), &engine);
     ASSERT_EQ(t3->engine(), &engine);

test/mocks/enginemock.h

@@ -118,6 +118,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));
         MOCK_METHOD(Target *, targetAt, (int), (const, override));
+        MOCK_METHOD(void, getVisibleTargets, (std::vector<Target *> &), (const, override));
         MOCK_METHOD(int, findTarget, (const std::string &), (const, override));
 
         MOCK_METHOD(void, moveSpriteToFront, (Sprite * sprite), (override));