Add target parameter to Script::runHatPredicate()

Author: adazem009

include/scratchcpp/script.h

@@ -35,7 +35,7 @@ class LIBSCRATCHCPP_EXPORT Script
         void setBytecode(const std::vector<unsigned int> &code);
 
         void setHatPredicateBytecode(const std::vector<unsigned int> &code);
-        bool runHatPredicate();
+        bool runHatPredicate(Target *target);
 
         void setProcedures(const std::vector<unsigned int *> &procedures);
         void setConstValues(const std::vector<Value> &values);

src/engine/internal/engine.cpp

@@ -531,7 +531,7 @@ void Engine::step()
                         oldValue = fieldIt->second;
                 }
 
-                bool newValue = thread->script()->runHatPredicate();
+                bool newValue = thread->script()->runHatPredicate(hatBlock->target());
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
                 m_edgeActivatedHatValues[hatType][fieldValueId] = newValue;
 

src/engine/script.cpp

@@ -53,29 +53,26 @@ void Script::setBytecode(const std::vector<unsigned int> &code)
 void Script::setHatPredicateBytecode(const std::vector<unsigned int> &code)
 {
     impl->hatPredicateBytecodeVector = code;
-
-    if (impl->engine && !code.empty()) {
-        impl->hatPredicateVm = std::make_shared<VirtualMachine>(impl->engine->stage(), impl->engine, this);
-        impl->hatPredicateVm->setBytecode(impl->hatPredicateBytecodeVector.data());
-        impl->hatPredicateVm->setConstValues(impl->constValues);
-    }
 }
 
 /*!
- * Runs the edge-activated hat predicate and returns the reported value.
+ * Runs the edge-activated hat predicate as the given target and returns the reported value.
  * \note If there isn't any predicate, nothing will happen and the returned value will be false.
  */
-bool Script::runHatPredicate()
+bool Script::runHatPredicate(Target *target)
 {
-    if (impl->hatPredicateVm && impl->hatPredicateVm->bytecode()) {
-        impl->hatPredicateVm->reset();
-        impl->hatPredicateVm->setFunctions(getFunctions());
-        impl->hatPredicateVm->run();
-        assert(impl->hatPredicateVm->registerCount() == 1);
-
-        if (impl->hatPredicateVm->registerCount() == 1)
-            return impl->hatPredicateVm->getInput(0, 1)->toBool();
-    }
+    if (!target || !impl->engine || impl->hatPredicateBytecodeVector.empty())
+        return false;
+
+    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
+    vm->setBytecode(impl->hatPredicateBytecodeVector.data());
+    vm->setConstValues(impl->constValues);
+    vm->setFunctions(getFunctions());
+    vm->run();
+    assert(vm->registerCount() == 1);
+
+    if (vm->registerCount() == 1)
+        return vm->getInput(0, 1)->toBool();
 
     return false;
 }
@@ -161,9 +158,6 @@ void Script::setConstValues(const std::vector<Value> &values)
 {
     impl->constValuesVector = values;
     impl->constValues = impl->constValuesVector.data();
-
-    if (impl->hatPredicateVm)
-        impl->hatPredicateVm->setConstValues(impl->constValues);
 }
 
 /*! Sets the list of variables. */

src/engine/script_p.h

@@ -22,9 +22,7 @@ struct ScriptPrivate
 
         unsigned int *bytecode = nullptr;
         std::vector<unsigned int> bytecodeVector;
-
         std::vector<unsigned int> hatPredicateBytecodeVector;
-        std::shared_ptr<VirtualMachine> hatPredicateVm;
 
         Target *target = nullptr;
         std::shared_ptr<Block> topBlock;

test/script/script_test.cpp

@@ -42,22 +42,20 @@ TEST_F(ScriptTest, Bytecode)
     ASSERT_EQ(script.bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
 }
 
-static Target *stageTest = nullptr;
+static Target *targetTest = nullptr;
 static IEngine *engineTest = nullptr;
 static Script *scriptTest = nullptr;
 
 TEST_F(ScriptTest, HatPredicate)
 {
     Script script(&m_target, nullptr, &m_engine);
-    ASSERT_FALSE(script.runHatPredicate());
-
-    Stage stage;
-    EXPECT_CALL(m_engine, stage()).Times(3).WillRepeatedly(Return(&stage));
+    Target target;
+    ASSERT_FALSE(script.runHatPredicate(&target));
 
     BlockFunc f1 = [](VirtualMachine *vm) -> unsigned int {
         vm->addReturnValue(true);
         vm->stop(false, false, false);
-        stageTest = vm->target();
+        targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
         return 0;
@@ -68,7 +66,7 @@ TEST_F(ScriptTest, HatPredicate)
     BlockFunc f3 = [](VirtualMachine *vm) -> unsigned int {
         vm->addReturnValue(false);
         vm->stop(false, false, false);
-        stageTest = vm->target();
+        targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
         return 0;
@@ -78,38 +76,38 @@ TEST_F(ScriptTest, HatPredicate)
     std::vector<BlockFunc> functions2 = { f1, f2, f3 };
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions1));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setConstValues({ "test" });
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 0, vm::OP_HALT });
     testing::internal::CaptureStdout();
-    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_TRUE(script.runHatPredicate(&target));
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "test\n");
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 1, vm::OP_HALT });
     script.setConstValues({ 5 });
     testing::internal::CaptureStdout();
-    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_TRUE(script.runHatPredicate(&m_target));
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "5\n");
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(targetTest, &m_target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT });
-    ASSERT_FALSE(script.runHatPredicate());
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_FALSE(script.runHatPredicate(&target));
+    ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 }