Use variables and lists from clones in Script

Author: adazem009

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();

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());
             }
         }

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,16 +49,66 @@ 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);
     vm->setBytecode(impl->bytecode);
     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;
 }

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

test/script/script_test.cpp

@@ -1,13 +1,17 @@
 #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>
 
 #include "../common.h"
 
 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());
 }