Add hat predicate support to Script

Author: adazem009

include/scratchcpp/script.h

@@ -34,6 +34,9 @@ class LIBSCRATCHCPP_EXPORT Script
         const std::vector<unsigned int> &bytecodeVector() const;
         void setBytecode(const std::vector<unsigned int> &code);
 
+        void setHatPredicateBytecode(const std::vector<unsigned int> &code);
+        bool runHatPredicate();
+
         void setProcedures(const std::vector<unsigned int *> &procedures);
         void setFunctions(const std::vector<BlockFunc> &functions);
         void setConstValues(const std::vector<Value> &values);

src/engine/script.cpp

@@ -6,6 +6,7 @@
 #include <scratchcpp/list.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/iengine.h>
+#include <scratchcpp/stage.h>
 #include <iostream>
 
 #include "script_p.h"
@@ -48,6 +49,37 @@ void Script::setBytecode(const std::vector<unsigned int> &code)
     impl->bytecode = impl->bytecodeVector.data();
 }
 
+/*! Sets the edge-activated hat predicate bytecode. */
+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->setFunctions(impl->functions);
+        impl->hatPredicateVm->setConstValues(impl->constValues);
+    }
+}
+
+/*!
+ * Runs the edge-activated hat predicate 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()
+{
+    if (impl->hatPredicateVm && impl->hatPredicateVm->bytecode()) {
+        impl->hatPredicateVm->reset();
+        impl->hatPredicateVm->run();
+        assert(impl->hatPredicateVm->registerCount() == 1);
+
+        if (impl->hatPredicateVm->registerCount() == 1)
+            return impl->hatPredicateVm->getInput(0, 1)->toBool();
+    }
+
+    return false;
+}
+
 /*! Starts the script (creates a virtual machine). */
 std::shared_ptr<VirtualMachine> Script::start()
 {
@@ -129,13 +161,19 @@ void Script::setFunctions(const std::vector<BlockFunc> &functions)
 {
     impl->functionsVector = functions;
     impl->functions = impl->functionsVector.data();
+
+    if (impl->hatPredicateVm)
+        impl->hatPredicateVm->setFunctions(impl->functions);
 }
 
 /*! Sets the list of constant values. */
 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

@@ -23,6 +23,9 @@ 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;
         IEngine *engine = nullptr;

test/script/script_test.cpp

@@ -1,8 +1,8 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/virtualmachine.h>
-#include <scratchcpp/target.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/stage.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <enginemock.h>
@@ -41,6 +41,74 @@ TEST_F(ScriptTest, Bytecode)
     ASSERT_EQ(script.bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
 }
 
+static Target *stageTest = 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));
+
+    BlockFunc f1 = [](VirtualMachine *vm) -> unsigned int {
+        vm->addReturnValue(true);
+        vm->stop(false, false, false);
+        stageTest = vm->target();
+        engineTest = vm->engine();
+        scriptTest = vm->script();
+        return 0;
+    };
+
+    BlockFunc f2 = f1;
+
+    BlockFunc f3 = [](VirtualMachine *vm) -> unsigned int {
+        vm->addReturnValue(false);
+        vm->stop(false, false, false);
+        stageTest = vm->target();
+        engineTest = vm->engine();
+        scriptTest = vm->script();
+        return 0;
+    };
+
+    stageTest = nullptr;
+    engineTest = nullptr;
+    scriptTest = nullptr;
+    script.setFunctions({ f1 });
+    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_EQ(testing::internal::GetCapturedStdout(), "test\n");
+    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(engineTest, &m_engine);
+    ASSERT_EQ(scriptTest, &script);
+
+    stageTest = 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.setFunctions({ f1, f2, f3 });
+    script.setConstValues({ 5 });
+    testing::internal::CaptureStdout();
+    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), "5\n");
+    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(engineTest, &m_engine);
+    ASSERT_EQ(scriptTest, &script);
+
+    stageTest = 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_EQ(engineTest, &m_engine);
+    ASSERT_EQ(scriptTest, &script);
+}
+
 unsigned int testFunction(VirtualMachine *)
 {
     return 0;