From 702a66b17c6e199654dbad857d7f0df667c85cdf Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 29 Aug 2023 20:54:01 +0200
Subject: [PATCH 01/14] Add engine property to Target

---
 include/scratchcpp/target.h          |  4 ++++
 src/scratch/target.cpp               | 12 ++++++++++++
 src/scratch/target_p.h               |  2 ++
 test/scratch_classes/CMakeLists.txt  |  2 ++
 test/scratch_classes/target_test.cpp | 11 +++++++++++
 5 files changed, 31 insertions(+)

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 3a9b01a7..7262394b 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -10,6 +10,7 @@
 namespace libscratchcpp
 {
 
+class IEngine;
 class Variable;
 class List;
 class Block;
@@ -67,6 +68,9 @@ class LIBSCRATCHCPP_EXPORT Target
         int volume() const;
         void setVolume(int newVolume);
 
+        IEngine *engine() const;
+        void setEngine(IEngine *engine);
+
     private:
         spimpl::unique_impl_ptr<TargetPrivate> impl;
 };
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index e0413a1b..5555b403 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -289,3 +289,15 @@ void Target::setVolume(int newVolume)
 {
     impl->volume = newVolume;
 }
+
+/*! Returns the engine. */
+IEngine *Target::engine() const
+{
+    return impl->engine;
+}
+
+/*! Sets the engine. */
+void Target::setEngine(IEngine *engine)
+{
+    impl->engine = engine;
+}
diff --git a/src/scratch/target_p.h b/src/scratch/target_p.h
index 1a990b23..4ea13e05 100644
--- a/src/scratch/target_p.h
+++ b/src/scratch/target_p.h
@@ -11,6 +11,7 @@
 namespace libscratchcpp
 {
 
+class IEngine;
 class Variable;
 class List;
 class Block;
@@ -20,6 +21,7 @@ struct TargetPrivate
         TargetPrivate();
         TargetPrivate(const TargetPrivate &) = delete;
 
+        IEngine *engine = nullptr;
         std::string name;
         std::vector<std::shared_ptr<Variable>> variables;
         std::vector<std::shared_ptr<List>> lists;
diff --git a/test/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt
index 787496d7..49bb075b 100644
--- a/test/scratch_classes/CMakeLists.txt
+++ b/test/scratch_classes/CMakeLists.txt
@@ -63,7 +63,9 @@ add_executable(
 target_link_libraries(
   target_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(target_test)
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 4112f12d..ce623368 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -4,6 +4,7 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/sound.h>
+#include <enginemock.h>
 
 #include "../common.h"
 
@@ -194,3 +195,13 @@ TEST(TargetTest, Volume)
     target.setVolume(50);
     ASSERT_EQ(target.volume(), 50);
 }
+
+TEST(TargetTest, Engine)
+{
+    Target target;
+    ASSERT_EQ(target.engine(), nullptr);
+
+    EngineMock engine;
+    target.setEngine(&engine);
+    ASSERT_EQ(target.engine(), &engine);
+}

From aab0942dcc705ed9cfa36c5dd32b17dee3905adc Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 29 Aug 2023 21:07:21 +0200
Subject: [PATCH 02/14] Make targets aware of engine

---
 src/engine/internal/engine.cpp |  3 ++-
 test/engine/engine_test.cpp    | 11 +++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 2eefcca0..4ed65248 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -461,8 +461,9 @@ void Engine::setTargets(const std::vector<std::shared_ptr<Target>> &newTargets)
 {
     m_targets = newTargets;
 
-    // Set engine and target in all blocks
+    // Set engine in targets and engine and target in all blocks
     for (auto target : m_targets) {
+        target->setEngine(this);
         auto blocks = target->blocks();
         for (auto block : blocks) {
             block->setEngine(this);
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index f9fed87b..2b4ee447 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -255,7 +255,11 @@ TEST(EngineTest, Targets)
     auto t1 = std::make_shared<Target>();
     t1->setName("Sprite1");
     auto t2 = std::make_shared<Target>();
+    auto block1 = std::make_shared<Block>("", "");
+    auto block2 = std::make_shared<Block>("", "");
     t2->setName("Sprite2");
+    t2->addBlock(block1);
+    t2->addBlock(block2);
     auto t3 = std::make_shared<Target>();
     t3->setName("Stage");
     engine.setTargets({ t1, t2, t3 });
@@ -271,4 +275,11 @@ TEST(EngineTest, Targets)
     ASSERT_EQ(engine.findTarget("Sprite1"), 0);
     ASSERT_EQ(engine.findTarget("Sprite2"), 1);
     ASSERT_EQ(engine.findTarget("Stage"), 2);
+
+    ASSERT_EQ(t1->engine(), &engine);
+    ASSERT_EQ(t2->engine(), &engine);
+    ASSERT_EQ(t3->engine(), &engine);
+
+    ASSERT_EQ(block1->engine(), &engine);
+    ASSERT_EQ(block2->engine(), &engine);
 }

From f3e0aab4e55567ba384dd36dc2884b94472b6894 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 31 Aug 2023 18:15:47 +0200
Subject: [PATCH 03/14] Add a way to use a custom target in Script::start()

---
 include/scratchcpp/script.h |  1 +
 src/engine/script.cpp       |  8 +++++++-
 test/script/script_test.cpp | 11 +++++++++++
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index 8090d603..0e01a80c 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -36,6 +36,7 @@ class LIBSCRATCHCPP_EXPORT Script
         void setLists(const std::vector<List *> &lists);
 
         std::shared_ptr<VirtualMachine> start();
+        std::shared_ptr<VirtualMachine> start(Target *target);
 
     private:
         spimpl::unique_impl_ptr<ScriptPrivate> impl;
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index a6739fe9..729b363f 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -35,7 +35,13 @@ void Script::setBytecode(const std::vector<unsigned int> &code)
 /*! Starts the script (creates a virtual machine). */
 std::shared_ptr<VirtualMachine> Script::start()
 {
-    auto vm = std::make_shared<VirtualMachine>(impl->target, impl->engine, this);
+    return start(impl->target);
+}
+
+/*! Starts the script (creates a virtual machine). */
+std::shared_ptr<VirtualMachine> Script::start(Target *target)
+{
+    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
     vm->setBytecode(impl->bytecode);
     vm->setProcedures(impl->procedures);
     vm->setFunctions(impl->functions);
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 36ac6cc1..d0d9ad6a 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -81,4 +81,15 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
     ASSERT_EQ(vm->variables()[0], variables[0]);
     ASSERT_EQ(vm->lists()[0], lists[0]);
+
+    Target target;
+    vm = script3.start(&target);
+    ASSERT_TRUE(vm);
+    ASSERT_EQ(vm->target(), &target);
+    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(vm->procedures()[0], procedures[0]);
+    ASSERT_EQ(vm->functions()[0], functions[0]);
+    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(vm->variables()[0], variables[0]);
+    ASSERT_EQ(vm->lists()[0], lists[0]);
 }

From 76ab1172fad20692a024e2392f14442dbf62663b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 31 Aug 2023 18:42:19 +0200
Subject: [PATCH 04/14] Sprite: Add clone info methods

---
 include/scratchcpp/sprite.h |  6 ++++++
 src/scratch/sprite.cpp      | 27 +++++++++++++++++++++++++++
 src/scratch/sprite_p.cpp    | 13 +++++++++++++
 src/scratch/sprite_p.h      |  5 +++++
 4 files changed, 51 insertions(+)

diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index d9ede3d5..952040d2 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -22,9 +22,15 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
         };
 
         Sprite();
+        ~Sprite();
 
         void setInterface(ISpriteHandler *newInterface);
 
+        bool isClone() const;
+
+        Sprite *cloneRoot() const;
+        Sprite *cloneParent() const;
+
         bool visible() const;
         void setVisible(bool newVisible);
 
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 206db9c6..7ae1b2db 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -16,6 +16,15 @@ Sprite::Sprite() :
 {
 }
 
+/*! Destroys the Sprite object. */
+Sprite::~Sprite()
+{
+    if (isClone()) {
+        assert(impl->cloneParent);
+        impl->cloneParent->impl->removeClone(this);
+    }
+}
+
 /*! Sets the sprite interface. */
 void Sprite::setInterface(ISpriteHandler *newInterface)
 {
@@ -24,6 +33,24 @@ void Sprite::setInterface(ISpriteHandler *newInterface)
     impl->iface->onSpriteChanged(this);
 }
 
+/*! Returns true if this is a clone. */
+bool Sprite::isClone() const
+{
+    return (impl->cloneParent != nullptr);
+}
+
+/*! Returns the sprite this clone was created from, or nullptr if this isn't a clone. */
+Sprite *Sprite::cloneRoot() const
+{
+    return impl->cloneRoot;
+}
+
+/*! Returns the sprite or clone this clone was created from, or nullptr if this isn't a clone. */
+Sprite *Sprite::cloneParent() const
+{
+    return impl->cloneParent;
+}
+
 /*! Returns true if the sprite is visible. */
 bool Sprite::visible() const
 {
diff --git a/src/scratch/sprite_p.cpp b/src/scratch/sprite_p.cpp
index 81333fbc..22267c42 100644
--- a/src/scratch/sprite_p.cpp
+++ b/src/scratch/sprite_p.cpp
@@ -10,6 +10,19 @@ SpritePrivate::SpritePrivate()
 {
 }
 
+void SpritePrivate::removeClone(Sprite *clone)
+{
+    int index = 0;
+    for (const auto &child : childClones) {
+        if (child.get() == clone) {
+            childClones.erase(childClones.begin() + index);
+            return;
+        }
+
+        index++;
+    }
+}
+
 void SpritePrivate::setCostumeData(const char *data)
 {
     if (iface)
diff --git a/src/scratch/sprite_p.h b/src/scratch/sprite_p.h
index 2656f228..84ca01ea 100644
--- a/src/scratch/sprite_p.h
+++ b/src/scratch/sprite_p.h
@@ -12,9 +12,14 @@ struct SpritePrivate
         SpritePrivate();
         SpritePrivate(const SpritePrivate &) = delete;
 
+        void removeClone(Sprite *clone);
+
         void setCostumeData(const char *data);
 
         ISpriteHandler *iface = nullptr;
+        Sprite *cloneRoot = nullptr;
+        Sprite *cloneParent = nullptr;
+        std::vector<std::shared_ptr<Sprite>> childClones;
         bool visible = true;
         double x = 0;
         double y = 0;

From af49e8be4f2ccb2697651cf78b4873b6b1caf1e5 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 31 Aug 2023 18:45:31 +0200
Subject: [PATCH 05/14] Engine: Add clone API

---
 include/scratchcpp/iengine.h   |  7 +++++
 src/engine/internal/engine.cpp | 49 ++++++++++++++++++++++++++++++++++
 src/engine/internal/engine.h   |  4 +++
 test/mocks/enginemock.h        |  3 +++
 4 files changed, 63 insertions(+)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 0d9d8fca..94d6648a 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -15,6 +15,7 @@ class IBlockSection;
 class Broadcast;
 class Block;
 class Target;
+class Sprite;
 class Script;
 
 /*!
@@ -70,6 +71,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
          */
         virtual void stopTarget(Target *target, VirtualMachine *exceptScript) = 0;
 
+        /*! Calls the "when I start as a clone" blocks of the given sprite. */
+        virtual void initClone(Sprite *clone) = 0;
+
         /*!
          * Runs the event loop and calls "when green flag clicked" blocks.
          * \note This function returns when all scripts finish.\n
@@ -157,6 +161,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Registers the broadcast script. */
         virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::shared_ptr<Broadcast> broadcast) = 0;
 
+        /* Registers the given "when I start as clone" script. */
+        virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 4ed65248..6257c5a9 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/scratchconfiguration.h>
 #include <scratchcpp/iblocksection.h>
 #include <scratchcpp/script.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/input.h>
@@ -258,6 +259,37 @@ void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
         stopScript(script);
 }
 
+void Engine::initClone(Sprite *clone)
+{
+    if (!clone)
+        return;
+
+    Sprite *source = clone->cloneParent();
+    Target *root = clone->cloneRoot();
+    assert(source);
+    assert(root);
+
+    if (!source || !root)
+        return;
+
+    auto it = m_cloneInitScriptsMap.find(root);
+
+    if (it != m_cloneInitScriptsMap.cend()) {
+        const auto &scripts = it->second;
+
+#ifndef NDEBUG
+        // Since we're initializing the clone, it shouldn't have any running scripts
+        for (const auto script : m_runningScripts)
+            assert(script->target() != clone);
+#endif
+
+        for (auto script : scripts) {
+            auto vm = script->start(clone);
+            m_runningScripts.push_back(vm);
+        }
+    }
+}
+
 void Engine::run()
 {
     auto frameDuration = std::chrono::milliseconds(33);
@@ -442,6 +474,7 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::s
     auto id = findBroadcast(broadcast->name());
     if (m_broadcastMap.count(id) == 1) {
         std::vector<Script *> &scripts = m_broadcastMap[id];
+        // TODO: Do not allow adding existing scripts
         scripts.push_back(m_scripts[whenReceivedBlock].get());
     } else {
         m_broadcastMap[id] = { m_scripts[whenReceivedBlock].get() };
@@ -452,6 +485,22 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::s
     }
 }
 
+void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
+{
+    Target *target = hatBlock->target();
+    Script *script = m_scripts[hatBlock].get();
+    auto it = m_cloneInitScriptsMap.find(target);
+
+    if (it == m_cloneInitScriptsMap.cend())
+        m_cloneInitScriptsMap[target] = { m_scripts[hatBlock].get() };
+    else {
+        auto &scripts = it->second;
+
+        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
+            scripts.push_back(script);
+    }
+}
+
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 {
     return m_targets;
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 6dd5f316..b0e1640c 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -32,6 +32,7 @@ class Engine : public IEngine
         void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) override;
         void stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
+        void initClone(libscratchcpp::Sprite *clone) override;
         void run() override;
 
         bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) override;
@@ -60,6 +61,8 @@ class Engine : public IEngine
 
         void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::shared_ptr<Broadcast> broadcast) override;
 
+        void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
+
         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;
@@ -86,6 +89,7 @@ class Engine : public IEngine
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<unsigned int, std::vector<Script *>> m_broadcastMap;
         std::unordered_map<unsigned int, std::vector<std::pair<VirtualMachine *, VirtualMachine *>>> m_runningBroadcastMap; // source script, "when received" script
+        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;                                          // target (no clones), "when I start as a clone" scripts
         std::vector<std::string> m_extensions;
         std::vector<std::shared_ptr<VirtualMachine>> m_runningScripts;
         std::vector<VirtualMachine *> m_scriptsToRemove;
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 7d479689..0632cd8d 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -21,6 +21,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
+        MOCK_METHOD(void, initClone, (Sprite *), (override));
         MOCK_METHOD(void, run, (), (override));
 
         MOCK_METHOD(bool, broadcastRunning, (unsigned int, VirtualMachine *), (override));
@@ -48,6 +49,8 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, std::shared_ptr<Broadcast>), (override));
 
+        MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
+
         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));

From d7645d53e26b610cd23addd250305be4f5d2706f Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 1 Sep 2023 10:15:44 +0200
Subject: [PATCH 06/14] Add clone method to Sprite

---
 include/scratchcpp/sprite.h          |   2 +
 src/scratch/sprite.cpp               |  60 +++++++++++++-
 test/scratch_classes/CMakeLists.txt  |   2 +
 test/scratch_classes/sprite_test.cpp | 113 +++++++++++++++++++++++++++
 4 files changed, 176 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index 952040d2..356e0799 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -26,6 +26,8 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
 
         void setInterface(ISpriteHandler *newInterface);
 
+        std::shared_ptr<Sprite> clone();
+
         bool isClone() const;
 
         Sprite *cloneRoot() const;
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 7ae1b2db..5ffaa657 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -2,7 +2,9 @@
 
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/ispritehandler.h>
-#include <string>
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 #include <cassert>
 
 #include "sprite_p.h"
@@ -33,6 +35,62 @@ void Sprite::setInterface(ISpriteHandler *newInterface)
     impl->iface->onSpriteChanged(this);
 }
 
+/*! Creates a clone of the sprite. */
+std::shared_ptr<Sprite> Sprite::clone()
+{
+    IEngine *eng = engine();
+
+    if (eng) {
+        std::shared_ptr<Sprite> clone = std::make_shared<Sprite>();
+
+        if (impl->cloneRoot == nullptr)
+            clone->impl->cloneRoot = this;
+        else
+            clone->impl->cloneRoot = impl->cloneRoot;
+
+        clone->impl->cloneParent = this;
+        impl->childClones.push_back(clone);
+
+        // Copy data
+        clone->setName(name());
+
+        const auto &vars = variables();
+
+        for (auto var : vars)
+            clone->addVariable(std::make_shared<Variable>(var->id(), var->name(), var->value()));
+
+        const auto &l = lists();
+
+        for (auto list : l) {
+            auto newList = std::make_shared<List>(list->id(), list->name());
+            clone->addList(newList);
+
+            for (const Value &item : *list)
+                newList->push_back(item);
+        }
+
+        clone->setCurrentCostume(currentCostume());
+        clone->setLayerOrder(layerOrder());
+        clone->setVolume(volume());
+        clone->setEngine(engine());
+
+        clone->impl->visible = impl->visible;
+        clone->impl->x = impl->x;
+        clone->impl->y = impl->y;
+        clone->impl->size = impl->size;
+        clone->impl->direction = impl->direction;
+        clone->impl->draggable = impl->draggable;
+        clone->impl->rotationStyle = impl->rotationStyle;
+
+        // Call "when I start as clone" scripts
+        eng->initClone(clone.get());
+
+        return clone;
+    }
+
+    return nullptr;
+}
+
 /*! Returns true if this is a clone. */
 bool Sprite::isClone() const
 {
diff --git a/test/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt
index 49bb075b..dfdd4c21 100644
--- a/test/scratch_classes/CMakeLists.txt
+++ b/test/scratch_classes/CMakeLists.txt
@@ -35,7 +35,9 @@ add_executable(
 target_link_libraries(
   sprite_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(sprite_test)
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index 3c130052..5580a73d 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -1,9 +1,15 @@
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
+#include <enginemock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
+using ::testing::_;
+using ::testing::SaveArg;
+
 TEST(SpriteTest, IsStage)
 {
     Sprite sprite;
@@ -18,6 +24,113 @@ TEST(SpriteTest, Visible)
     ASSERT_FALSE(sprite.visible());
 }
 
+TEST(SpriteTest, Clone)
+{
+    Sprite sprite;
+    sprite.setName("Sprite1");
+    auto var1 = std::make_shared<Variable>("a", "var1", "hello");
+    auto var2 = std::make_shared<Variable>("b", "var2", "world");
+    sprite.addVariable(var1);
+    sprite.addVariable(var2);
+
+    auto list1 = std::make_shared<List>("c", "list1");
+    list1->push_back("item1");
+    list1->push_back("item2");
+    auto list2 = std::make_shared<List>("d", "list2");
+    list2->push_back("test");
+    sprite.addList(list1);
+    sprite.addList(list2);
+
+    sprite.setCurrentCostume(2);
+    sprite.setLayerOrder(5);
+    sprite.setVolume(50);
+
+    sprite.setVisible(false);
+    sprite.setX(100.25);
+    sprite.setY(-45.43);
+    sprite.setSize(54.121);
+    sprite.setDirection(179.4);
+    sprite.setDraggable(true);
+    sprite.setRotationStyle(Sprite::RotationStyle::DoNotRotate);
+
+    auto checkCloneData = [](Sprite *clone) {
+        ASSERT_TRUE(clone);
+        Sprite *root = clone->cloneRoot();
+
+        ASSERT_EQ(clone->name(), "Sprite1");
+        ASSERT_EQ(clone->variables().size(), 2);
+        ASSERT_NE(clone->variables(), root->variables());
+        ASSERT_EQ(clone->variableAt(0)->id(), "a");
+        ASSERT_EQ(clone->variableAt(0)->name(), "var1");
+        ASSERT_EQ(clone->variableAt(0)->value().toString(), "hello");
+        ASSERT_EQ(clone->variableAt(1)->id(), "b");
+        ASSERT_EQ(clone->variableAt(1)->name(), "var2");
+        ASSERT_EQ(clone->variableAt(1)->value().toString(), "world");
+
+        ASSERT_EQ(clone->lists().size(), 2);
+        ASSERT_NE(clone->lists(), root->lists());
+        ASSERT_EQ(clone->listAt(0)->id(), "c");
+        ASSERT_EQ(clone->listAt(0)->name(), "list1");
+        ASSERT_EQ(*clone->listAt(0), std::deque<Value>({ "item1", "item2" }));
+        ASSERT_EQ(clone->listAt(1)->id(), "d");
+        ASSERT_EQ(clone->listAt(1)->name(), "list2");
+        ASSERT_EQ(*clone->listAt(1), std::deque<Value>({ "test" }));
+
+        ASSERT_EQ(clone->currentCostume(), 2);
+        ASSERT_EQ(clone->layerOrder(), 5);
+        ASSERT_EQ(clone->volume(), 50);
+        ASSERT_EQ(clone->engine(), root->engine());
+
+        ASSERT_EQ(clone->visible(), false);
+        ASSERT_EQ(clone->x(), 100.25);
+        ASSERT_EQ(clone->y(), -45.43);
+        ASSERT_EQ(clone->size(), 54.121);
+        ASSERT_EQ(clone->direction(), 179.4);
+        ASSERT_EQ(clone->draggable(), true);
+        ASSERT_EQ(clone->rotationStyle(), Sprite::RotationStyle::DoNotRotate);
+    };
+
+    ASSERT_FALSE(sprite.isClone());
+    ASSERT_EQ(sprite.cloneRoot(), nullptr);
+    ASSERT_EQ(sprite.cloneParent(), nullptr);
+
+    ASSERT_EQ(sprite.clone(), nullptr);
+    ASSERT_FALSE(sprite.isClone());
+    ASSERT_EQ(sprite.cloneRoot(), nullptr);
+    ASSERT_EQ(sprite.cloneParent(), nullptr);
+
+    EngineMock engine;
+    sprite.setEngine(&engine);
+
+    Sprite *clone1;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone1));
+    ASSERT_EQ(sprite.clone().get(), clone1);
+    ASSERT_FALSE(sprite.isClone());
+    ASSERT_EQ(sprite.cloneRoot(), nullptr);
+    ASSERT_EQ(sprite.cloneParent(), nullptr);
+
+    ASSERT_TRUE(clone1->isClone());
+    ASSERT_EQ(clone1->cloneRoot(), &sprite);
+    ASSERT_EQ(clone1->cloneParent(), &sprite);
+
+    checkCloneData(clone1);
+
+    // Modify root sprite data to make sure parent is used
+    sprite.setLayerOrder(3);
+
+    Sprite *clone2;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone2));
+    ASSERT_EQ(clone1->clone().get(), clone2);
+    ASSERT_TRUE(clone1->isClone());
+    ASSERT_EQ(clone1->cloneRoot(), &sprite);
+    ASSERT_EQ(clone1->cloneParent(), &sprite);
+    ASSERT_TRUE(clone2->isClone());
+    ASSERT_EQ(clone2->cloneRoot(), &sprite);
+    ASSERT_EQ(clone2->cloneParent(), clone1);
+
+    checkCloneData(clone2);
+}
+
 TEST(SpriteTest, X)
 {
     Sprite sprite;

From b7035b75d12e23dc5e25ed732e58a9e6bdb28669 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 12:01:57 +0200
Subject: [PATCH 07/14] Add target getter to Script

---
 include/scratchcpp/script.h | 2 ++
 src/engine/script.cpp       | 6 ++++++
 test/script/script_test.cpp | 6 ++++++
 3 files changed, 14 insertions(+)

diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index 0e01a80c..33a703a4 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -25,6 +25,8 @@ class LIBSCRATCHCPP_EXPORT Script
         Script(Target *target, IEngine *engine);
         Script(const Script &) = delete;
 
+        Target *target() const;
+
         unsigned int *bytecode() const;
         const std::vector<unsigned int> &bytecodeVector() const;
         void setBytecode(const std::vector<unsigned int> &code);
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index 729b363f..fca77219 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -13,6 +13,12 @@ Script::Script(Target *target, IEngine *engine) :
 {
 }
 
+/*! Returns the Target. */
+Target *Script::target() const
+{
+    return impl->target;
+}
+
 /*! Returns the bytecode array. */
 unsigned int *Script::bytecode() const
 {
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index d0d9ad6a..8dafccc8 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -15,6 +15,12 @@ class ScriptTest : public testing::Test
         EngineMock m_engine;
 };
 
+TEST_F(ScriptTest, Constructors)
+{
+    Script script(&m_target, &m_engine);
+    ASSERT_EQ(script.target(), &m_target);
+}
+
 TEST_F(ScriptTest, Bytecode)
 {
     Script script(nullptr, nullptr);

From 1db403e6dd4a69192a49b8fe9faeb7a292e92ee9 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 12:11:12 +0200
Subject: [PATCH 08/14] Add variable and list vector setters to VirtualMachine

---
 include/scratchcpp/virtualmachine.h           |  2 ++
 src/engine/virtualmachine.cpp                 | 20 +++++++++++++++++++
 src/engine/virtualmachine_p.h                 |  2 ++
 test/virtual_machine/virtual_machine_test.cpp | 19 ++++++++++++++----
 4 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/include/scratchcpp/virtualmachine.h b/include/scratchcpp/virtualmachine.h
index 0e262cff..41dd40ea 100644
--- a/include/scratchcpp/virtualmachine.h
+++ b/include/scratchcpp/virtualmachine.h
@@ -102,6 +102,8 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         void setConstValues(const Value *values);
         void setVariables(Value **variables);
         void setLists(List **lists);
+        void setVariablesVector(const std::vector<Value *> &variables);
+        void setListsVector(const std::vector<List *> &lists);
 
         void setBytecode(unsigned int *code);
 
diff --git a/src/engine/virtualmachine.cpp b/src/engine/virtualmachine.cpp
index dc9b3c58..c700c728 100644
--- a/src/engine/virtualmachine.cpp
+++ b/src/engine/virtualmachine.cpp
@@ -50,6 +50,26 @@ void VirtualMachine::setLists(List **lists)
     impl->lists = lists;
 }
 
+/*!
+ * Sets the vector of variables.
+ * Use this instead of setVariables() if you can't store the array (data pointer) anywhere.
+ */
+void VirtualMachine::setVariablesVector(const std::vector<Value *> &variables)
+{
+    impl->variablesVector = variables;
+    impl->variables = impl->variablesVector.data();
+}
+
+/*!
+ * Sets the vector of lists.
+ * Use this instead of setLists() if you can't store the array (data pointer) anywhere.
+ */
+void VirtualMachine::setListsVector(const std::vector<List *> &lists)
+{
+    impl->listsVector = lists;
+    impl->lists = impl->listsVector.data();
+}
+
 /*! Sets the bytecode of the script. */
 void VirtualMachine::setBytecode(unsigned int *code)
 {
diff --git a/src/engine/virtualmachine_p.h b/src/engine/virtualmachine_p.h
index af00076b..262926b7 100644
--- a/src/engine/virtualmachine_p.h
+++ b/src/engine/virtualmachine_p.h
@@ -59,7 +59,9 @@ struct VirtualMachinePrivate
         BlockFunc *functions = nullptr;
         const Value *constValues = nullptr;
         Value **variables = nullptr;
+        std::vector<Value *> variablesVector;
         List **lists = nullptr;
+        std::vector<List *> listsVector;
 
         Value **regs = nullptr;
         size_t regCount = 0;
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index aa34ec1a..bb692b03 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -48,24 +48,35 @@ TEST(VirtualMachineTest, ConstValues)
 
 TEST(VirtualMachineTest, Variables)
 {
-    Value var;
-    Value *variables[] = { &var };
+    Value var1, var2;
+    Value *variables[] = { &var1, &var2 };
 
     VirtualMachine vm;
     ASSERT_EQ(vm.variables(), nullptr);
+
     vm.setVariables(variables);
     ASSERT_EQ(vm.variables(), variables);
+
+    vm.setVariablesVector({ &var1, &var2 });
+    ASSERT_EQ(vm.variables()[0], &var1);
+    ASSERT_EQ(vm.variables()[1], &var2);
 }
 
 TEST(VirtualMachineTest, Lists)
 {
-    List list("", "");
-    List *lists[] = { &list };
+    List list1("", "");
+    List list2("", "");
+    List *lists[] = { &list1, &list2 };
 
     VirtualMachine vm;
     ASSERT_EQ(vm.lists(), nullptr);
+
     vm.setLists(lists);
     ASSERT_EQ(vm.lists(), lists);
+
+    vm.setListsVector({ &list1, &list2 });
+    ASSERT_EQ(vm.lists()[0], &list1);
+    ASSERT_EQ(vm.lists()[1], &list2);
 }
 
 TEST(VirtualMachineTest, Bytecode)

From 8792b255f930cc56cd3ddd01b3e43d3511de6e4c Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 13:40:04 +0200
Subject: [PATCH 09/14] Add a way to get variable and list owner target

---
 include/scratchcpp/iengine.h   |  8 ++++++
 src/engine/internal/engine.cpp | 38 ++++++++++++++++++++++++++-
 src/engine/internal/engine.h   |  5 ++++
 test/engine/engine_test.cpp    | 48 ++++++++++++++++++++++++++++++++++
 test/mocks/enginemock.h        |  3 +++
 5 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 94d6648a..c6d2312a 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -16,6 +16,8 @@ class Broadcast;
 class Block;
 class Target;
 class Sprite;
+class Variable;
+class List;
 class Script;
 
 /*!
@@ -176,6 +178,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the index of the target with the given name. */
         virtual int findTarget(const std::string &targetName) const = 0;
 
+        /*! Returns the target which owns the given variable. If it is the stage, the variable is global. */
+        virtual Target *variableOwner(Variable *variable) const = 0;
+
+        /*! Returns the target which owns the given list. If it is the stage, the list is global. */
+        virtual Target *listOwner(List *list) const = 0;
+
         /*! Returns the list of extension names. */
         virtual const std::vector<std::string> &extensions() const = 0;
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 6257c5a9..63c19097 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -509,15 +509,31 @@ const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 void Engine::setTargets(const std::vector<std::shared_ptr<Target>> &newTargets)
 {
     m_targets = newTargets;
+    m_variableOwners.clear();
+    m_listOwners.clear();
 
-    // Set engine in targets and engine and target in all blocks
     for (auto target : m_targets) {
+        // Set engine in the target
         target->setEngine(this);
         auto blocks = target->blocks();
+
         for (auto block : blocks) {
+            // Set engine and target in the block
             block->setEngine(this);
             block->setTarget(target.get());
         }
+
+        // Add variables to owner map
+        const auto &variables = target->variables();
+
+        for (auto variable : variables)
+            m_variableOwners[variable.get()] = target.get();
+
+        // Add lists to owner map
+        const auto &lists = target->lists();
+
+        for (auto list : lists)
+            m_listOwners[list.get()] = target.get();
     }
 }
 
@@ -540,6 +556,26 @@ int Engine::findTarget(const std::string &targetName) const
     return -1;
 }
 
+Target *Engine::variableOwner(Variable *variable) const
+{
+    auto it = m_variableOwners.find(variable);
+
+    if (it == m_variableOwners.cend())
+        return nullptr;
+
+    return it->second;
+}
+
+Target *Engine::listOwner(List *list) const
+{
+    auto it = m_listOwners.find(list);
+
+    if (it == m_listOwners.cend())
+        return nullptr;
+
+    return it->second;
+}
+
 const std::vector<std::string> &Engine::extensions() const
 {
     return m_extensions;
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index b0e1640c..06980bbc 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -68,6 +68,9 @@ class Engine : public IEngine
         Target *targetAt(int index) const override;
         int findTarget(const std::string &targetName) const override;
 
+        Target *variableOwner(Variable *variable) const override;
+        Target *listOwner(List *list) const override;
+
         const std::vector<std::string> &extensions() const override;
         void setExtensions(const std::vector<std::string> &newExtensions) override;
 
@@ -95,6 +98,8 @@ class Engine : public IEngine
         std::vector<VirtualMachine *> m_scriptsToRemove;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
+        std::unordered_map<Variable *, Target *> m_variableOwners;
+        std::unordered_map<List *, Target *> m_listOwners;
 
         bool m_breakFrame = false;
         bool m_skipFrame = false;
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 2b4ee447..f15364c9 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -1,5 +1,7 @@
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/block.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 
 #include "../common.h"
 #include "testsection.h"
@@ -283,3 +285,49 @@ TEST(EngineTest, Targets)
     ASSERT_EQ(block1->engine(), &engine);
     ASSERT_EQ(block2->engine(), &engine);
 }
+
+TEST(EngineTest, VariableOwner)
+{
+    Engine engine;
+    auto t1 = std::make_shared<Target>();
+    auto t2 = std::make_shared<Target>();
+    auto t3 = std::make_shared<Target>();
+
+    auto var1 = std::make_shared<Variable>("", "", Value());
+    auto var2 = std::make_shared<Variable>("", "", Value());
+    auto var3 = std::make_shared<Variable>("", "", Value());
+    auto var4 = std::make_shared<Variable>("", "", Value());
+    t1->addVariable(var1);
+    t1->addVariable(var4);
+    t3->addVariable(var3);
+
+    engine.setTargets({ t1, t2, t3 });
+
+    ASSERT_EQ(engine.variableOwner(var1.get()), t1.get());
+    ASSERT_EQ(engine.variableOwner(var2.get()), nullptr);
+    ASSERT_EQ(engine.variableOwner(var3.get()), t3.get());
+    ASSERT_EQ(engine.variableOwner(var4.get()), t1.get());
+}
+
+TEST(EngineTest, ListOwner)
+{
+    Engine engine;
+    auto t1 = std::make_shared<Target>();
+    auto t2 = std::make_shared<Target>();
+    auto t3 = std::make_shared<Target>();
+
+    auto list1 = std::make_shared<List>("", "");
+    auto list2 = std::make_shared<List>("", "");
+    auto list3 = std::make_shared<List>("", "");
+    auto list4 = std::make_shared<List>("", "");
+    t1->addList(list1);
+    t1->addList(list4);
+    t3->addList(list3);
+
+    engine.setTargets({ t1, t2, t3 });
+
+    ASSERT_EQ(engine.listOwner(list1.get()), t1.get());
+    ASSERT_EQ(engine.listOwner(list2.get()), nullptr);
+    ASSERT_EQ(engine.listOwner(list3.get()), t3.get());
+    ASSERT_EQ(engine.listOwner(list4.get()), t1.get());
+}
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 0632cd8d..99c20c4d 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -56,6 +56,9 @@ class EngineMock : public IEngine
         MOCK_METHOD(Target *, targetAt, (int), (const, override));
         MOCK_METHOD(int, findTarget, (const std::string &), (const, override));
 
+        MOCK_METHOD(Target *, variableOwner, (Variable *), (const, override));
+        MOCK_METHOD(Target *, listOwner, (List *), (const, override));
+
         MOCK_METHOD(std::vector<std::string> &, extensions, (), (const, override));
         MOCK_METHOD(void, setExtensions, (const std::vector<std::string> &), (override));
 

From 294c238873fec86c9b366118790e79b06ae33288 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 17:27:19 +0200
Subject: [PATCH 10/14] Use variables and lists from clones in Script

---
 include/scratchcpp/script.h    |  3 +-
 src/engine/internal/engine.cpp |  2 +-
 src/engine/script.cpp          | 73 ++++++++++++++++++++++++++++++----
 src/engine/script_p.h          |  8 ++--
 test/script/script_test.cpp    | 51 +++++++++++++++++++++---
 5 files changed, 117 insertions(+), 20 deletions(-)

diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index 33a703a4..78afd2d4 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -15,6 +15,7 @@ class Target;
 class IEngine;
 class Value;
 class VirtualMachine;
+class Variable;
 class List;
 class ScriptPrivate;
 
@@ -34,7 +35,7 @@ class LIBSCRATCHCPP_EXPORT Script
         void setProcedures(const std::vector<unsigned int *> &procedures);
         void setFunctions(const std::vector<BlockFunc> &functions);
         void setConstValues(const std::vector<Value> &values);
-        void setVariables(const std::vector<Value *> &variables);
+        void setVariables(const std::vector<Variable *> &variables);
         void setLists(const std::vector<List *> &lists);
 
         std::shared_ptr<VirtualMachine> start();
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 63c19097..92fcafc3 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -112,7 +112,7 @@ void Engine::compile()
             if (m_scripts.count(block) == 1) {
                 m_scripts[block]->setProcedures(procedureBytecodes);
                 m_scripts[block]->setConstValues(compiler.constValues());
-                m_scripts[block]->setVariables(compiler.variablePtrs());
+                m_scripts[block]->setVariables(compiler.variables());
                 m_scripts[block]->setLists(compiler.lists());
             }
         }
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index fca77219..14e2c9e1 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -2,6 +2,11 @@
 
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/iengine.h>
+#include <iostream>
 
 #include "script_p.h"
 
@@ -44,7 +49,7 @@ std::shared_ptr<VirtualMachine> Script::start()
     return start(impl->target);
 }
 
-/*! Starts the script (creates a virtual machine). */
+/*! Starts the script (creates a virtual machine) as the given target (might be a clone). */
 std::shared_ptr<VirtualMachine> Script::start(Target *target)
 {
     auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
@@ -52,8 +57,58 @@ std::shared_ptr<VirtualMachine> Script::start(Target *target)
     vm->setProcedures(impl->procedures);
     vm->setFunctions(impl->functions);
     vm->setConstValues(impl->constValues);
-    vm->setVariables(impl->variables);
-    vm->setLists(impl->lists);
+
+    Sprite *sprite = nullptr;
+    if (target && !target->isStage())
+        sprite = dynamic_cast<Sprite *>(target);
+
+    if (impl->target && sprite && sprite->isClone() && impl->engine) {
+        Target *root = sprite->cloneRoot();
+
+        if (root != impl->target) {
+            std::cout << "warning: a clone tried to start a script of another target (this is a bug in libscratchcpp or in your code!)" << std::endl;
+            vm->setVariables(impl->variableValues.data());
+            vm->setLists(impl->lists.data());
+            return vm;
+        }
+
+        // Use internal variables and lists from the clone
+        std::vector<Value *> variables;
+        std::vector<List *> lists;
+
+        for (const auto &var : impl->variables) {
+            Target *owner = impl->engine->variableOwner(var);
+
+            if (owner && (owner == root)) {
+                auto cloneVar = sprite->variableAt(sprite->findVariableById(var->id()));
+                assert(cloneVar);
+
+                if (cloneVar)
+                    variables.push_back(cloneVar->valuePtr());
+            } else
+                variables.push_back(var->valuePtr());
+        }
+
+        for (const auto &list : impl->lists) {
+            Target *owner = impl->engine->listOwner(list);
+
+            if (owner && (owner == root)) {
+                auto cloneList = sprite->listAt(sprite->findListById(list->id()));
+                assert(cloneList);
+
+                if (cloneList)
+                    lists.push_back(cloneList.get());
+            } else
+                lists.push_back(list);
+        }
+
+        vm->setVariablesVector(variables);
+        vm->setListsVector(lists);
+    } else {
+        vm->setVariables(impl->variableValues.data());
+        vm->setLists(impl->lists.data());
+    }
+
     return vm;
 }
 
@@ -79,15 +134,17 @@ void Script::setConstValues(const std::vector<Value> &values)
 }
 
 /*! Sets the list of variables. */
-void Script::setVariables(const std::vector<Value *> &variables)
+void Script::setVariables(const std::vector<Variable *> &variables)
 {
-    impl->variablesVector = variables;
-    impl->variables = impl->variablesVector.data();
+    impl->variables = variables;
+    impl->variableValues.clear();
+
+    for (const auto &var : variables)
+        impl->variableValues.push_back(var->valuePtr());
 }
 
 /*! Sets the list of lists. */
 void Script::setLists(const std::vector<List *> &lists)
 {
-    impl->listsVector = lists;
-    impl->lists = impl->listsVector.data();
+    impl->lists = lists;
 }
diff --git a/src/engine/script_p.h b/src/engine/script_p.h
index a67e4f39..7b643429 100644
--- a/src/engine/script_p.h
+++ b/src/engine/script_p.h
@@ -12,6 +12,7 @@ namespace libscratchcpp
 
 class Target;
 class IEngine;
+class Variable;
 class List;
 
 struct ScriptPrivate
@@ -34,11 +35,10 @@ struct ScriptPrivate
         const Value *constValues = nullptr;
         std::vector<Value> constValuesVector;
 
-        Value **variables = nullptr;
-        std::vector<Value *> variablesVector;
+        std::vector<Value *> variableValues;
+        std::vector<Variable *> variables;
 
-        List **lists = nullptr;
-        std::vector<List *> listsVector;
+        std::vector<List *> lists;
 };
 
 } // namespace libscratchcpp
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 8dafccc8..caca86a3 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -1,6 +1,8 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
 #include <scratchcpp/target.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <enginemock.h>
 
@@ -8,6 +10,8 @@
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 class ScriptTest : public testing::Test
 {
     public:
@@ -45,11 +49,13 @@ TEST_F(ScriptTest, Start)
     static std::vector<BlockFunc> functions = { &testFunction };
     static std::vector<Value> constValues = { "test" };
 
-    std::unique_ptr<Value> var = std::make_unique<Value>();
-    static std::vector<Value *> variables = { var.get() };
+    std::unique_ptr<Variable> var1 = std::make_unique<Variable>("a", "", Value());
+    std::unique_ptr<Variable> var2 = std::make_unique<Variable>("b", "", Value());
+    static std::vector<Variable *> variables = { var1.get(), var2.get() };
 
-    std::unique_ptr<List> list = std::make_unique<List>("", "");
-    static std::vector<List *> lists = { list.get() };
+    std::unique_ptr<List> list1 = std::make_unique<List>("c", "");
+    std::unique_ptr<List> list2 = std::make_unique<List>("d", "");
+    static std::vector<List *> lists = { list1.get(), list2.get() };
 
     Script script1(nullptr, nullptr);
 
@@ -85,7 +91,7 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->procedures()[0], procedures[0]);
     ASSERT_EQ(vm->functions()[0], functions[0]);
     ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
-    ASSERT_EQ(vm->variables()[0], variables[0]);
+    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
     ASSERT_EQ(vm->lists()[0], lists[0]);
 
     Target target;
@@ -96,6 +102,39 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->procedures()[0], procedures[0]);
     ASSERT_EQ(vm->functions()[0], functions[0]);
     ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
-    ASSERT_EQ(vm->variables()[0], variables[0]);
+    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(vm->lists()[0], lists[0]);
+
+    Sprite root;
+    root.setEngine(&m_engine);
+    root.addVariable(std::make_shared<Variable>("b", "", Value()));
+    root.addList(std::make_shared<List>("d", ""));
+
+    EXPECT_CALL(m_engine, initClone).Times(1);
+    auto clone = root.clone();
+
+    Script script4(&root, &m_engine);
+    script4.setBytecode(bytecode);
+    script4.setProcedures(procedures);
+    script4.setFunctions(functions);
+    script4.setConstValues(constValues);
+    script4.setVariables(variables);
+    script4.setLists(lists);
+
+    EXPECT_CALL(m_engine, variableOwner(var1.get())).WillOnce(Return(&target));
+    EXPECT_CALL(m_engine, variableOwner(var2.get())).WillOnce(Return(&root));
+    EXPECT_CALL(m_engine, listOwner(list1.get())).WillOnce(Return(&target));
+    EXPECT_CALL(m_engine, listOwner(list2.get())).WillOnce(Return(&root));
+    vm = script4.start(clone.get());
+
+    ASSERT_TRUE(vm);
+    ASSERT_EQ(vm->target(), clone.get());
+    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(vm->procedures()[0], procedures[0]);
+    ASSERT_EQ(vm->functions()[0], functions[0]);
+    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(vm->variables()[1], clone->variableAt(clone->findVariableById("b"))->valuePtr());
     ASSERT_EQ(vm->lists()[0], lists[0]);
+    ASSERT_EQ(vm->lists()[1], clone->listAt(clone->findListById("d")).get());
 }

From c4538e0d9961bb8b0d294227d76e98b7ae821c5a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 17:53:28 +0200
Subject: [PATCH 11/14] Add Sprite children getters

---
 include/scratchcpp/sprite.h          |  2 ++
 src/scratch/sprite.cpp               | 20 +++++++++++++
 test/scratch_classes/sprite_test.cpp | 44 ++++++++++++++++++++++++++++
 3 files changed, 66 insertions(+)

diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index 356e0799..9597bf90 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -32,6 +32,8 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
 
         Sprite *cloneRoot() const;
         Sprite *cloneParent() const;
+        const std::vector<std::shared_ptr<Sprite>> &children() const;
+        std::vector<std::shared_ptr<Sprite>> allChildren() const;
 
         bool visible() const;
         void setVisible(bool newVisible);
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 5ffaa657..83437c8f 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -109,6 +109,26 @@ Sprite *Sprite::cloneParent() const
     return impl->cloneParent;
 }
 
+/*! Returns list of child clones. */
+const std::vector<std::shared_ptr<Sprite>> &Sprite::children() const
+{
+    return impl->childClones;
+}
+
+/*! Returns list of child clones and their children (recursive). */
+std::vector<std::shared_ptr<Sprite>> Sprite::allChildren() const
+{
+    std::vector<std::shared_ptr<Sprite>> ret;
+
+    for (auto clone : impl->childClones) {
+        ret.push_back(clone);
+        auto children = clone->allChildren();
+        ret.insert(ret.end(), children.begin(), children.end());
+    }
+
+    return ret;
+}
+
 /*! Returns true if the sprite is visible. */
 bool Sprite::visible() const
 {
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index 5580a73d..1097fc7f 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -129,6 +129,50 @@ TEST(SpriteTest, Clone)
     ASSERT_EQ(clone2->cloneParent(), clone1);
 
     checkCloneData(clone2);
+
+    Sprite *clone3;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone3));
+    ASSERT_EQ(clone1->clone().get(), clone3);
+
+    Sprite *clone4;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone4));
+    ASSERT_EQ(sprite.clone().get(), clone4);
+
+    // children
+    const auto &children1 = sprite.children();
+    ASSERT_EQ(children1.size(), 2);
+    ASSERT_EQ(children1[0].get(), clone1);
+    ASSERT_EQ(children1[1].get(), clone4);
+
+    const auto &children2 = clone1->children();
+    ASSERT_EQ(children2.size(), 2);
+    ASSERT_EQ(children2[0].get(), clone2);
+    ASSERT_EQ(children2[1].get(), clone3);
+
+    ASSERT_TRUE(clone2->children().empty());
+
+    ASSERT_TRUE(clone3->children().empty());
+
+    ASSERT_TRUE(clone4->children().empty());
+
+    // allChildren
+    auto allChildren = sprite.allChildren();
+    ASSERT_EQ(allChildren.size(), 4);
+    ASSERT_EQ(allChildren[0].get(), clone1);
+    ASSERT_EQ(allChildren[1].get(), clone2);
+    ASSERT_EQ(allChildren[2].get(), clone3);
+    ASSERT_EQ(allChildren[3].get(), clone4);
+
+    allChildren = clone1->allChildren();
+    ASSERT_EQ(allChildren.size(), 2);
+    ASSERT_EQ(allChildren[0].get(), clone2);
+    ASSERT_EQ(allChildren[1].get(), clone3);
+
+    ASSERT_TRUE(clone2->allChildren().empty());
+
+    ASSERT_TRUE(clone3->allChildren().empty());
+
+    ASSERT_TRUE(clone4->allChildren().empty());
 }
 
 TEST(SpriteTest, X)

From 763c2c96468e434af97c575f8ac1b163f3f17bf8 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 17:56:49 +0200
Subject: [PATCH 12/14] Engine: Make clones receive broadcasts

---
 src/engine/internal/engine.cpp | 46 +++++++++++++++++++++++-----------
 1 file changed, 32 insertions(+), 14 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 92fcafc3..3572e4fa 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -202,22 +202,21 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
     const std::vector<Script *> &scripts = m_broadcastMap[index];
 
     for (auto script : scripts) {
-        long scriptIndex = -1;
-        for (long i = 0; i < m_runningScripts.size(); i++) {
-            if (m_runningScripts[i]->script() == script) {
-                scriptIndex = i;
-                break;
+        std::vector<VirtualMachine *> runningBroadcastScripts;
+
+        for (auto vm : m_runningScripts) {
+            if (vm->script() == script) {
+                runningBroadcastScripts.push_back(vm.get());
             }
         }
 
-        if (scriptIndex != -1) {
-            // Reset the script if it's already running
-            auto vm = m_runningScripts[scriptIndex];
+        // Reset running scripts
+        for (VirtualMachine *vm : runningBroadcastScripts) {
             vm->reset();
 
             // Remove the script from scripts to remove because it's going to run again
-            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm.get()), m_scriptsToRemove.end());
-            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), m_runningScripts[scriptIndex].get()) == m_scriptsToRemove.end());
+            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm), m_scriptsToRemove.end());
+            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end());
 
             auto &scripts = m_runningBroadcastMap[index];
 
@@ -233,10 +232,29 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
                     m_skipFrame = false;
             } else
                 sourceScript->stop(true, true);
-        } else {
-            auto vm = script->start();
-            m_runningScripts.push_back(vm);
-            m_runningBroadcastMap[index].push_back({ sourceScript, vm.get() });
+        }
+
+        // Start scripts which are not running
+        Target *root = script->target();
+        std::vector<Target *> targets = { root };
+
+        if (!root->isStage()) {
+            Sprite *sprite = dynamic_cast<Sprite *>(root);
+            assert(sprite);
+            auto children = sprite->allChildren();
+
+            for (auto child : children)
+                targets.push_back(child.get());
+        }
+
+        for (Target *target : targets) {
+            auto it = std::find_if(runningBroadcastScripts.begin(), runningBroadcastScripts.end(), [target](VirtualMachine *vm) { return vm->target() == target; });
+
+            if (it == runningBroadcastScripts.end()) {
+                auto vm = script->start(target);
+                m_runningScripts.push_back(vm);
+                m_runningBroadcastMap[index].push_back({ sourceScript, vm.get() });
+            }
         }
     }
 }

From 41f8b4970b75c400051e4252b69c6eb518c4acbd Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 21:33:52 +0200
Subject: [PATCH 13/14] Add a way to change the data source for blocks and
 assets

---
 include/scratchcpp/target.h          |   4 +
 src/scratch/target.cpp               |  40 +++++-
 test/mocks/targetmock.h              |  14 ++
 test/scratch_classes/target_test.cpp | 185 ++++++++++++++++++++++++++-
 4 files changed, 239 insertions(+), 4 deletions(-)
 create mode 100644 test/mocks/targetmock.h

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 7262394b..fe9e7e23 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -71,6 +71,10 @@ class LIBSCRATCHCPP_EXPORT Target
         IEngine *engine() const;
         void setEngine(IEngine *engine);
 
+    protected:
+        /*! Override this method to set a custom data source for blocks and assets. */
+        virtual Target *dataSource() const { return nullptr; }
+
     private:
         spimpl::unique_impl_ptr<TargetPrivate> impl;
 };
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 5555b403..05743f7e 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -132,12 +132,18 @@ int Target::findListById(const std::string &id) const
 /*! Returns the list of blocks. */
 const std::vector<std::shared_ptr<Block>> &Target::blocks() const
 {
+    if (Target *source = dataSource())
+        return source->blocks();
+
     return impl->blocks;
 }
 
 /*! Adds a block and returns its index. */
 int Target::addBlock(std::shared_ptr<Block> block)
 {
+    if (Target *source = dataSource())
+        return source->addBlock(block);
+
     auto it = std::find(impl->blocks.begin(), impl->blocks.end(), block);
 
     if (it != impl->blocks.end())
@@ -150,6 +156,9 @@ int Target::addBlock(std::shared_ptr<Block> block)
 /*! Returns the block at index. */
 std::shared_ptr<Block> Target::blockAt(int index) const
 {
+    if (Target *source = dataSource())
+        return source->blockAt(index);
+
     if (index < 0 || index >= impl->blocks.size())
         return nullptr;
 
@@ -159,6 +168,9 @@ std::shared_ptr<Block> Target::blockAt(int index) const
 /*! Returns the index of the block with the given ID. */
 int Target::findBlock(const std::string &id) const
 {
+    if (Target *source = dataSource())
+        return source->findBlock(id);
+
     int i = 0;
     for (auto block : impl->blocks) {
         if (block->id() == id)
@@ -172,7 +184,9 @@ int Target::findBlock(const std::string &id) const
 std::vector<std::shared_ptr<Block>> Target::greenFlagBlocks() const
 {
     std::vector<std::shared_ptr<Block>> ret;
-    for (auto block : impl->blocks) {
+    const auto &blockList = blocks();
+
+    for (auto block : blockList) {
         if (block->opcode() == "event_whenflagclicked")
             ret.push_back(block);
     }
@@ -195,12 +209,18 @@ void Target::setCurrentCostume(int newCostume)
 /*! Returns the list of costumes. */
 const std::vector<std::shared_ptr<Costume>> &Target::costumes() const
 {
+    if (Target *source = dataSource())
+        return source->costumes();
+
     return impl->costumes;
 }
 
 /*! Adds a costume and returns its index. */
 int Target::addCostume(std::shared_ptr<Costume> costume)
 {
+    if (Target *source = dataSource())
+        return source->addCostume(costume);
+
     auto it = std::find(impl->costumes.begin(), impl->costumes.end(), costume);
 
     if (it != impl->costumes.end())
@@ -213,6 +233,9 @@ int Target::addCostume(std::shared_ptr<Costume> costume)
 /*! Returns the costume at index. */
 std::shared_ptr<Costume> Target::costumeAt(int index) const
 {
+    if (Target *source = dataSource())
+        return source->costumeAt(index);
+
     // TODO: Add range check
     return impl->costumes[index];
 }
@@ -220,6 +243,9 @@ std::shared_ptr<Costume> Target::costumeAt(int index) const
 /*! Returns the index of the given costume. */
 int Target::findCostume(const std::string &costumeName) const
 {
+    if (Target *source = dataSource())
+        return source->findCostume(costumeName);
+
     int i = 0;
     for (auto costume : impl->costumes) {
         if (costume->name() == costumeName)
@@ -232,12 +258,18 @@ int Target::findCostume(const std::string &costumeName) const
 /*! Returns the list of sounds. */
 const std::vector<std::shared_ptr<Sound>> &Target::sounds() const
 {
+    if (Target *source = dataSource())
+        return source->sounds();
+
     return impl->sounds;
 }
 
 /*! Adds a sound and returns its index. */
 int Target::addSound(std::shared_ptr<Sound> sound)
 {
+    if (Target *source = dataSource())
+        return source->addSound(sound);
+
     auto it = std::find(impl->sounds.begin(), impl->sounds.end(), sound);
 
     if (it != impl->sounds.end())
@@ -250,6 +282,9 @@ int Target::addSound(std::shared_ptr<Sound> sound)
 /*! Returns the sound at index. */
 std::shared_ptr<Sound> Target::soundAt(int index) const
 {
+    if (Target *source = dataSource())
+        return source->soundAt(index);
+
     // TODO: Add range check
     return impl->sounds[index];
 }
@@ -257,6 +292,9 @@ std::shared_ptr<Sound> Target::soundAt(int index) const
 /*! Returns the index of the sound with the given name. */
 int Target::findSound(const std::string &soundName) const
 {
+    if (Target *source = dataSource())
+        return source->findSound(soundName);
+
     int i = 0;
     for (auto sound : impl->sounds) {
         if (sound->name() == soundName)
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
new file mode 100644
index 00000000..d1ee5459
--- /dev/null
+++ b/test/mocks/targetmock.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <scratchcpp/target.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class TargetMock : public Target
+{
+    public:
+        MOCK_METHOD(Target *, dataSource, (), (const override));
+
+        Target *dataSourceBase() const { return Target::dataSource(); };
+};
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index ce623368..821a5ff4 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -5,11 +5,14 @@
 #include <scratchcpp/costume.h>
 #include <scratchcpp/sound.h>
 #include <enginemock.h>
+#include <targetmock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 TEST(TargetTest, IsStage)
 {
     Target target;
@@ -90,7 +93,9 @@ TEST(TargetTest, Blocks)
     auto b3 = std::make_shared<Block>("c", "motion_ifonedgebounce");
     auto b4 = std::make_shared<Block>("d", "event_whenflagclicked");
 
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, dataSource()).Times(18).WillRepeatedly(Return(nullptr));
+
     ASSERT_EQ(target.addBlock(b1), 0);
     ASSERT_EQ(target.addBlock(b2), 1);
     ASSERT_EQ(target.addBlock(b3), 2);
@@ -112,6 +117,62 @@ TEST(TargetTest, Blocks)
     ASSERT_EQ(target.findBlock("d"), 3);
 
     ASSERT_EQ(target.greenFlagBlocks(), std::vector<std::shared_ptr<Block>>({ b1, b4 }));
+
+    // Test with custom data source
+    Target source;
+
+    EXPECT_CALL(target, dataSource()).WillOnce(Return(&source));
+
+    ASSERT_TRUE(target.blocks().empty());
+
+    TargetMock target2;
+    EXPECT_CALL(target2, dataSource()).Times(18).WillRepeatedly(Return(&source));
+
+    ASSERT_EQ(target2.addBlock(b1), 0);
+    ASSERT_EQ(target2.addBlock(b2), 1);
+    ASSERT_EQ(target2.addBlock(b3), 2);
+    ASSERT_EQ(target2.addBlock(b4), 3);
+    ASSERT_EQ(target2.addBlock(b2), 1); // add existing block
+
+    ASSERT_EQ(target2.blockAt(0), b1);
+    ASSERT_EQ(target2.blockAt(1), b2);
+    ASSERT_EQ(target2.blockAt(2), b3);
+    ASSERT_EQ(target2.blockAt(3), b4);
+    ASSERT_EQ(target2.blockAt(4), nullptr);
+    ASSERT_EQ(target2.blockAt(-1), nullptr);
+
+    ASSERT_EQ(target2.findBlock("e"), -1);
+    ASSERT_EQ(target2.findBlock("a"), 0);
+    ASSERT_EQ(target2.findBlock("b"), 1);
+    ASSERT_EQ(target2.findBlock("c"), 2);
+    ASSERT_EQ(target2.findBlock("d"), 3);
+
+    ASSERT_EQ(target2.greenFlagBlocks(), std::vector<std::shared_ptr<Block>>({ b1, b4 }));
+
+    ASSERT_EQ(target2.blocks(), source.blocks());
+
+    auto b5 = std::make_shared<Block>("e", "data_setvariableto");
+    ASSERT_EQ(source.addBlock(b5), 4);
+
+    EXPECT_CALL(target2, dataSource()).WillOnce(Return(&source));
+    ASSERT_EQ(target2.blocks(), source.blocks());
+
+    ASSERT_EQ(source.blockAt(0), b1);
+    ASSERT_EQ(source.blockAt(1), b2);
+    ASSERT_EQ(source.blockAt(2), b3);
+    ASSERT_EQ(source.blockAt(3), b4);
+    ASSERT_EQ(source.blockAt(4), b5);
+    ASSERT_EQ(source.blockAt(5), nullptr);
+    ASSERT_EQ(source.blockAt(-1), nullptr);
+
+    ASSERT_EQ(source.findBlock("f"), -1);
+    ASSERT_EQ(source.findBlock("a"), 0);
+    ASSERT_EQ(source.findBlock("b"), 1);
+    ASSERT_EQ(source.findBlock("c"), 2);
+    ASSERT_EQ(source.findBlock("d"), 3);
+    ASSERT_EQ(source.findBlock("e"), 4);
+
+    ASSERT_EQ(source.greenFlagBlocks(), std::vector<std::shared_ptr<Block>>({ b1, b4 }));
 }
 
 TEST(TargetTest, CurrentCostume)
@@ -128,7 +189,9 @@ TEST(TargetTest, Costumes)
     auto c2 = std::make_shared<Costume>("costume2", "", "png");
     auto c3 = std::make_shared<Costume>("costume3", "", "svg");
 
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, dataSource()).Times(15).WillRepeatedly(Return(nullptr));
+
     ASSERT_EQ(target.addCostume(c1), 0);
     ASSERT_EQ(target.addCostume(c2), 1);
     ASSERT_EQ(target.addCostume(c3), 2);
@@ -149,6 +212,60 @@ TEST(TargetTest, Costumes)
     ASSERT_EQ(target.findCostume("costume1"), 0);
     ASSERT_EQ(target.findCostume("costume2"), 1);
     ASSERT_EQ(target.findCostume("costume3"), 2);
+
+    // Test with custom data source
+    Target source;
+
+    EXPECT_CALL(target, dataSource()).WillOnce(Return(&source));
+
+    ASSERT_TRUE(target.costumes().empty());
+
+    TargetMock target2;
+    EXPECT_CALL(target2, dataSource()).Times(16).WillRepeatedly(Return(&source));
+
+    ASSERT_EQ(target2.addCostume(c1), 0);
+    ASSERT_EQ(target2.addCostume(c2), 1);
+    ASSERT_EQ(target2.addCostume(c3), 2);
+    ASSERT_EQ(target2.addCostume(c2), 1); // add existing costume
+
+    ASSERT_EQ(target2.costumes().size(), 3);
+    ASSERT_EQ(target2.costumes()[0]->name(), c1->name());
+    ASSERT_EQ(target2.costumes()[1]->name(), c2->name());
+    ASSERT_EQ(target2.costumes()[2]->name(), c3->name());
+
+    ASSERT_EQ(target2.costumeAt(0)->name(), c1->name());
+    ASSERT_EQ(target2.costumeAt(1)->name(), c2->name());
+    ASSERT_EQ(target2.costumeAt(2)->name(), c3->name());
+
+    ASSERT_EQ(target2.findCostume("invalid"), -1);
+    ASSERT_EQ(target2.findCostume("costume1"), 0);
+    ASSERT_EQ(target2.findCostume("costume2"), 1);
+    ASSERT_EQ(target2.findCostume("costume3"), 2);
+
+    ASSERT_EQ(target2.costumes(), source.costumes());
+
+    auto c4 = std::make_shared<Costume>("costume4", "", "png");
+    ASSERT_EQ(source.addCostume(c4), 3);
+
+    EXPECT_CALL(target2, dataSource()).WillOnce(Return(&source));
+    ASSERT_EQ(target2.costumes(), source.costumes());
+
+    ASSERT_EQ(source.costumes().size(), 4);
+    ASSERT_EQ(source.costumes()[0]->name(), c1->name());
+    ASSERT_EQ(source.costumes()[1]->name(), c2->name());
+    ASSERT_EQ(source.costumes()[2]->name(), c3->name());
+    ASSERT_EQ(source.costumes()[3]->name(), c4->name());
+
+    ASSERT_EQ(source.costumeAt(0)->name(), c1->name());
+    ASSERT_EQ(source.costumeAt(1)->name(), c2->name());
+    ASSERT_EQ(source.costumeAt(2)->name(), c3->name());
+    ASSERT_EQ(source.costumeAt(3)->name(), c4->name());
+
+    ASSERT_EQ(source.findCostume("invalid"), -1);
+    ASSERT_EQ(source.findCostume("costume1"), 0);
+    ASSERT_EQ(source.findCostume("costume2"), 1);
+    ASSERT_EQ(source.findCostume("costume3"), 2);
+    ASSERT_EQ(source.findCostume("costume4"), 3);
 }
 
 TEST(TargetTest, Sounds)
@@ -157,7 +274,9 @@ TEST(TargetTest, Sounds)
     auto s2 = std::make_shared<Sound>("sound2", "", "wav");
     auto s3 = std::make_shared<Sound>("sound3", "", "mp3");
 
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, dataSource()).Times(15).WillRepeatedly(Return(nullptr));
+
     ASSERT_EQ(target.addSound(s1), 0);
     ASSERT_EQ(target.addSound(s2), 1);
     ASSERT_EQ(target.addSound(s3), 2);
@@ -178,6 +297,60 @@ TEST(TargetTest, Sounds)
     ASSERT_EQ(target.findSound("sound1"), 0);
     ASSERT_EQ(target.findSound("sound2"), 1);
     ASSERT_EQ(target.findSound("sound3"), 2);
+
+    // Test with custom data source
+    Target source;
+
+    EXPECT_CALL(target, dataSource()).WillOnce(Return(&source));
+
+    ASSERT_TRUE(target.sounds().empty());
+
+    TargetMock target2;
+    EXPECT_CALL(target2, dataSource()).Times(16).WillRepeatedly(Return(&source));
+
+    ASSERT_EQ(target2.addSound(s1), 0);
+    ASSERT_EQ(target2.addSound(s2), 1);
+    ASSERT_EQ(target2.addSound(s3), 2);
+    ASSERT_EQ(target2.addSound(s2), 1); // add existing Sound
+
+    ASSERT_EQ(target2.sounds().size(), 3);
+    ASSERT_EQ(target2.sounds()[0]->name(), s1->name());
+    ASSERT_EQ(target2.sounds()[1]->name(), s2->name());
+    ASSERT_EQ(target2.sounds()[2]->name(), s3->name());
+
+    ASSERT_EQ(target2.soundAt(0)->name(), s1->name());
+    ASSERT_EQ(target2.soundAt(1)->name(), s2->name());
+    ASSERT_EQ(target2.soundAt(2)->name(), s3->name());
+
+    ASSERT_EQ(target2.findSound("invalid"), -1);
+    ASSERT_EQ(target2.findSound("sound1"), 0);
+    ASSERT_EQ(target2.findSound("sound2"), 1);
+    ASSERT_EQ(target2.findSound("sound3"), 2);
+
+    ASSERT_EQ(target2.sounds(), source.sounds());
+
+    auto s4 = std::make_shared<Sound>("sound4", "", "wav");
+    ASSERT_EQ(source.addSound(s4), 3);
+
+    EXPECT_CALL(target2, dataSource()).WillOnce(Return(&source));
+    ASSERT_EQ(target2.sounds(), source.sounds());
+
+    ASSERT_EQ(source.sounds().size(), 4);
+    ASSERT_EQ(source.sounds()[0]->name(), s1->name());
+    ASSERT_EQ(source.sounds()[1]->name(), s2->name());
+    ASSERT_EQ(source.sounds()[2]->name(), s3->name());
+    ASSERT_EQ(source.sounds()[3]->name(), s4->name());
+
+    ASSERT_EQ(source.soundAt(0)->name(), s1->name());
+    ASSERT_EQ(source.soundAt(1)->name(), s2->name());
+    ASSERT_EQ(source.soundAt(2)->name(), s3->name());
+    ASSERT_EQ(source.soundAt(3)->name(), s4->name());
+
+    ASSERT_EQ(source.findSound("invalid"), -1);
+    ASSERT_EQ(source.findSound("sound1"), 0);
+    ASSERT_EQ(source.findSound("sound2"), 1);
+    ASSERT_EQ(source.findSound("sound3"), 2);
+    ASSERT_EQ(source.findSound("sound4"), 3);
 }
 
 TEST(TargetTest, LayerOrder)
@@ -205,3 +378,9 @@ TEST(TargetTest, Engine)
     target.setEngine(&engine);
     ASSERT_EQ(target.engine(), &engine);
 }
+
+TEST(TargetTest, DataSource)
+{
+    TargetMock target;
+    ASSERT_EQ(target.dataSourceBase(), nullptr);
+}

From 846043dce6be76b4dac9312002e70a24bdd3e66b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 2 Sep 2023 21:53:17 +0200
Subject: [PATCH 14/14] Use clone root sprite as the data source for blocks and
 assets

---
 include/scratchcpp/sprite.h          | 2 ++
 src/scratch/sprite.cpp               | 5 +++++
 test/scratch_classes/sprite_test.cpp | 8 ++++++++
 3 files changed, 15 insertions(+)

diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index 9597bf90..dd50f56e 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -60,6 +60,8 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
         void setRotationStyle(const char *newRotationStyle);
 
     private:
+        Target *dataSource() const override;
+
         spimpl::unique_impl_ptr<SpritePrivate> impl;
 };
 
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 83437c8f..b7db560c 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -255,3 +255,8 @@ void Sprite::setRotationStyle(const char *newRotationStyle)
 {
     setRotationStyle(std::string(newRotationStyle));
 }
+
+Target *Sprite::dataSource() const
+{
+    return impl->cloneRoot;
+}
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index 1097fc7f..8abe2426 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -1,6 +1,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
+#include <scratchcpp/costume.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -32,6 +33,8 @@ TEST(SpriteTest, Clone)
     auto var2 = std::make_shared<Variable>("b", "var2", "world");
     sprite.addVariable(var1);
     sprite.addVariable(var2);
+    auto c1 = std::make_shared<Costume>("costume1", "", "svg");
+    sprite.addCostume(c1);
 
     auto list1 = std::make_shared<List>("c", "list1");
     list1->push_back("item1");
@@ -173,6 +176,11 @@ TEST(SpriteTest, Clone)
     ASSERT_TRUE(clone3->allChildren().empty());
 
     ASSERT_TRUE(clone4->allChildren().empty());
+
+    ASSERT_EQ(clone2->costumes(), sprite.costumes());
+    auto c2 = std::make_shared<Costume>("costume2", "", "png");
+    clone2->addCostume(c2);
+    ASSERT_EQ(clone2->costumes(), sprite.costumes());
 }
 
 TEST(SpriteTest, X)