Implement clone blocks

include/scratchcpp/target.h

@@ -24,6 +24,7 @@ class LIBSCRATCHCPP_EXPORT Target
     public:
         Target();
         Target(const Target &) = delete;
+        virtual ~Target() { }
 
         /*! Returns true if this Target is the stage. */
         virtual bool isStage() const { return false; }

src/blocks/controlblocks.cpp

@@ -2,7 +2,10 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/block.h>
 #include <cassert>
 
 #include "controlblocks.h"
@@ -27,6 +30,9 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "control_stop", &compileStop);
     engine->addCompileFunction(this, "control_wait", &compileWait);
     engine->addCompileFunction(this, "control_wait_until", &compileWaitUntil);
+    engine->addCompileFunction(this, "control_start_as_clone", &compileStartAsClone);
+    engine->addCompileFunction(this, "control_create_clone_of", &compileCreateClone);
+    engine->addCompileFunction(this, "control_delete_this_clone", &compileDeleteThisClone);
 
     // Inputs
     engine->addInput(this, "SUBSTACK", SUBSTACK);
@@ -35,6 +41,7 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addInput(this, "CONDITION", CONDITION);
     engine->addInput(this, "DURATION", DURATION);
     engine->addInput(this, "VALUE", VALUE);
+    engine->addInput(this, "CLONE_OPTION", CLONE_OPTION);
 
     // Fields
     engine->addField(this, "STOP_OPTION", STOP_OPTION);
@@ -155,6 +162,37 @@ void ControlBlocks::compileWaitUntil(Compiler *compiler)
     compiler->addFunctionCall(&waitUntil);
 }
 
+void ControlBlocks::compileStartAsClone(Compiler *compiler)
+{
+    compiler->engine()->addCloneInitScript(compiler->block());
+}
+
+void ControlBlocks::compileCreateClone(Compiler *compiler)
+{
+    Input *input = compiler->input(CLONE_OPTION);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string spriteName = input->selectedMenuItem();
+
+        if (spriteName == "_myself_")
+            compiler->addFunctionCall(&createCloneOfMyself);
+        else {
+            int index = compiler->engine()->findTarget(spriteName);
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&createCloneByIndex);
+        }
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&createClone);
+    }
+}
+
+void ControlBlocks::compileDeleteThisClone(Compiler *compiler)
+{
+    compiler->addFunctionCall(&deleteThisClone);
+}
+
 unsigned int ControlBlocks::stopAll(VirtualMachine *vm)
 {
     vm->engine()->stop();
@@ -196,3 +234,54 @@ unsigned int ControlBlocks::waitUntil(VirtualMachine *vm)
     }
     return 1;
 }
+
+unsigned int ControlBlocks::createClone(VirtualMachine *vm)
+{
+    std::string spriteName = vm->getInput(0, 1)->toString();
+    Target *target;
+
+    if (spriteName == "_myself_")
+        target = vm->target();
+    else
+        target = vm->engine()->targetAt(vm->engine()->findTarget(spriteName));
+
+    Sprite *sprite = dynamic_cast<Sprite *>(target);
+
+    if (sprite)
+        sprite->clone();
+
+    return 1;
+}
+
+unsigned int ControlBlocks::createCloneByIndex(VirtualMachine *vm)
+{
+    Target *target = vm->engine()->targetAt(vm->getInput(0, 1)->toInt());
+    Sprite *sprite = dynamic_cast<Sprite *>(target);
+
+    if (sprite)
+        sprite->clone();
+
+    return 1;
+}
+
+unsigned int ControlBlocks::createCloneOfMyself(VirtualMachine *vm)
+{
+    Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
+
+    if (sprite)
+        sprite->clone();
+
+    return 0;
+}
+
+unsigned int ControlBlocks::deleteThisClone(VirtualMachine *vm)
+{
+    Target *target = vm->target();
+
+    if (target) {
+        vm->engine()->stopTarget(target, nullptr);
+        target->~Target();
+    }
+
+    return 0;
+}

src/blocks/controlblocks.h

@@ -23,7 +23,8 @@ class ControlBlocks : public IBlockSection
             TIMES,
             CONDITION,
             DURATION,
-            VALUE
+            VALUE,
+            CLONE_OPTION
         };
 
         enum Fields
@@ -53,12 +54,19 @@ class ControlBlocks : public IBlockSection
         static void compileStop(Compiler *compiler);
         static void compileWait(Compiler *compiler);
         static void compileWaitUntil(Compiler *compiler);
+        static void compileStartAsClone(Compiler *compiler);
+        static void compileCreateClone(Compiler *compiler);
+        static void compileDeleteThisClone(Compiler *compiler);
 
         static unsigned int stopAll(VirtualMachine *vm);
         static unsigned int stopOtherScriptsInSprite(VirtualMachine *vm);
         static unsigned int startWait(VirtualMachine *vm);
         static unsigned int wait(VirtualMachine *vm);
         static unsigned int waitUntil(VirtualMachine *vm);
+        static unsigned int createClone(VirtualMachine *vm);
+        static unsigned int createCloneByIndex(VirtualMachine *vm);
+        static unsigned int createCloneOfMyself(VirtualMachine *vm);
+        static unsigned int deleteThisClone(VirtualMachine *vm);
 
         static inline std::unordered_map<VirtualMachine *, std::pair<std::chrono::steady_clock::time_point, int>> m_timeMap;
 };

src/engine/internal/engine.cpp

@@ -143,7 +143,8 @@ void Engine::frame()
                     }
                 }
 
-                m_scriptsToRemove.push_back(script.get());
+                if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) == m_scriptsToRemove.end())
+                    m_scriptsToRemove.push_back(script.get());
             }
         } while (!script->atEnd() && !m_breakFrame);
     }
@@ -262,7 +263,8 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
 void Engine::stopScript(VirtualMachine *vm)
 {
     assert(vm);
-    m_scriptsToRemove.push_back(vm);
+    if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end())
+        m_scriptsToRemove.push_back(vm);
 }
 
 void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
@@ -298,7 +300,7 @@ void Engine::initClone(Sprite *clone)
 #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);
+            assert((script->target() != clone) || (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) != m_scriptsToRemove.end()));
 #endif
 
         for (auto script : scripts) {