ScriptBuilder: Add support for building multiple scripts

Author: adazem009

include/scratchcpp/dev/test/scriptbuilder.h

@@ -25,11 +25,12 @@ class ScriptBuilderPrivate;
 class LIBSCRATCHCPP_EXPORT ScriptBuilder
 {
     public:
-        ScriptBuilder(IExtension *extension, IEngine *engine, std::shared_ptr<Target> target);
+        ScriptBuilder(IExtension *extension, IEngine *engine, std::shared_ptr<Target> target, bool createHatBlock = true);
         ScriptBuilder(const ScriptBuilder &) = delete;
 
         ~ScriptBuilder();
 
+        void addBlock(std::shared_ptr<Block> block);
         void addBlock(const std::string &opcode);
         void captureBlockReturnValue();
 
@@ -53,9 +54,15 @@ class LIBSCRATCHCPP_EXPORT ScriptBuilder
 
         List *capturedValues() const;
 
+        static void buildMultiple(const std::vector<ScriptBuilder *> &builders);
+
     private:
-        void addBlock(std::shared_ptr<Block> block);
+        void addBlockToList(std::shared_ptr<Block> block);
         void build(std::shared_ptr<Target> target);
+        std::string nextId();
+
+        static void addBlocksToTarget(Target *target, const std::vector<std::shared_ptr<Block>> &blocks);
+        static void addTargetToEngine(IEngine *engine, std::shared_ptr<Target> target);
 
         spimpl::unique_impl_ptr<ScriptBuilderPrivate> impl;
 };

src/dev/test/scriptbuilder.cpp

@@ -16,47 +16,53 @@
 using namespace libscratchcpp;
 using namespace libscratchcpp::test;
 
-static std::unordered_map<IEngine *, std::shared_ptr<List>> captureLists;
+// TODO: Add support for return values captures when building multiple scripts
+static std::unordered_map<const ScriptBuilder *, std::shared_ptr<List>> captureLists;
+static ScriptBuilder *currentScriptBuilder = nullptr;
 
 /*! Constructs ScriptBuilder. */
-ScriptBuilder::ScriptBuilder(IExtension *extension, IEngine *engine, std::shared_ptr<Target> target) :
+ScriptBuilder::ScriptBuilder(IExtension *extension, IEngine *engine, std::shared_ptr<Target> target, bool createHatBlock) :
     impl(spimpl::make_unique_impl<ScriptBuilderPrivate>(engine, target))
 {
     // Create capture list
-    if (captureLists.find(engine) != captureLists.cend()) {
-        std::cerr << "error: only one ScriptBuilder can be created for each engine" << std::endl;
-        return;
-    }
-
-    captureLists[engine] = std::make_shared<List>("", "");
+    captureLists[this] = std::make_shared<List>("", "");
 
     // Add start hat block
-    auto block = std::make_shared<Block>(std::to_string(impl->blockId++), "script_builder_init");
-    engine->addCompileFunction(extension, block->opcode(), [](Compiler *compiler) -> CompilerValue * {
-        compiler->engine()->addGreenFlagScript(compiler->block());
-        return nullptr;
-    });
-    addBlock(block);
+    if (createHatBlock) {
+        auto block = std::make_shared<Block>(nextId(), "script_builder_init");
+        engine->addCompileFunction(extension, block->opcode(), [](Compiler *compiler) -> CompilerValue * {
+            compiler->engine()->addGreenFlagScript(compiler->block());
+            return nullptr;
+        });
+        addBlockToList(block);
+    }
 
     // Add compile function for return value capture block
     engine->addCompileFunction(extension, "script_builder_capture", [](Compiler *compiler) -> CompilerValue * {
         CompilerValue *input = compiler->addInput("VALUE");
-        compiler->createListAppend(captureLists[compiler->engine()].get(), input);
+        compiler->createListAppend(captureLists[currentScriptBuilder].get(), input);
         return nullptr;
     });
 }
 
 /*! Destroys ScriptBuilder. */
 ScriptBuilder::~ScriptBuilder()
 {
-    captureLists.erase(impl->engine);
+    captureLists.erase(this);
+}
+
+/*! Adds the given block to the script. */
+void ScriptBuilder::addBlock(std::shared_ptr<Block> block)
+{
+    block->setId(nextId());
+    impl->lastBlock = block;
+    addBlockToList(block);
 }
 
 /*! Adds a block with the given opcode to the script. */
 void ScriptBuilder::addBlock(const std::string &opcode)
 {
-    impl->lastBlock = std::make_shared<Block>(std::to_string(impl->blockId++), opcode);
-    addBlock(impl->lastBlock);
+    addBlock(std::make_shared<Block>("", opcode));
 }
 
 /*! Captures the return value of the created reporter block. It can be retrieved using capturedValues() later. */
@@ -101,7 +107,7 @@ void ScriptBuilder::addObscuredInput(const std::string &name, std::shared_ptr<Bl
     block->setParent(impl->lastBlock);
 
     while (block) {
-        block->setId(std::to_string(impl->blockId++));
+        block->setId(nextId());
         impl->inputBlocks.push_back(block);
 
         auto parent = block->parent();
@@ -128,7 +134,7 @@ void ScriptBuilder::addNullObscuredInput(const std::string &name)
         return;
 
     auto input = std::make_shared<Input>(name, Input::Type::ObscuredShadow);
-    auto block = std::make_shared<Block>(std::to_string(impl->blockId++), "");
+    auto block = std::make_shared<Block>(nextId(), "");
     block->setCompileFunction([](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue(Value()); });
     input->setValueBlock(block);
     impl->inputBlocks.push_back(block);
@@ -144,7 +150,7 @@ void ScriptBuilder::addDropdownInput(const std::string &name, const std::string
     auto input = std::make_shared<Input>(name, Input::Type::Shadow);
     impl->lastBlock->addInput(input);
 
-    auto menu = std::make_shared<Block>(std::to_string(impl->blockId++), impl->lastBlock->opcode() + "_menu");
+    auto menu = std::make_shared<Block>(nextId(), impl->lastBlock->opcode() + "_menu");
     menu->setShadow(true);
     impl->inputBlocks.push_back(menu);
     input->setValueBlock(menu);
@@ -170,7 +176,7 @@ void ScriptBuilder::addEntityInput(const std::string &name, const std::string &e
         return;
 
     if (std::find(impl->entities.begin(), impl->entities.end(), entity) == impl->entities.end()) {
-        entity->setId(std::to_string(impl->blockId++));
+        entity->setId(nextId());
         impl->entities.push_back(entity);
     }
 
@@ -188,7 +194,7 @@ void ScriptBuilder::addEntityField(const std::string &name, std::shared_ptr<Enti
         return;
 
     if (std::find(impl->entities.begin(), impl->entities.end(), entity) == impl->entities.end()) {
-        entity->setId(std::to_string(impl->blockId++));
+        entity->setId(nextId());
         impl->entities.push_back(entity);
     }
 
@@ -218,6 +224,10 @@ std::shared_ptr<Block> ScriptBuilder::currentBlock()
             target->addList(list);
 
         build(target);
+
+        std::vector<std::shared_ptr<Target>> targets = impl->engine->targets();
+        targets.erase(std::remove(targets.begin(), targets.end(), target), targets.end());
+        impl->engine->setTargets(targets);
     }
 
     return impl->lastBlock;
@@ -256,10 +266,31 @@ void ScriptBuilder::run()
 /*! Returns the list of captured block return values. */
 List *ScriptBuilder::capturedValues() const
 {
-    return captureLists[impl->engine].get();
+    return captureLists[this].get();
 }
 
-void ScriptBuilder::addBlock(std::shared_ptr<Block> block)
+/*!
+ * Builds multiple scripts using the given script builders.
+ * \note Using run() on any of the script builders will result in all scripts without a custom hat block being called. Use this only with a single when flag clicked block.
+ * \note Return value capturing is not supported when building multiple scripts.
+ */
+void ScriptBuilder::buildMultiple(const std::vector<ScriptBuilder *> &builders)
+{
+    std::unordered_set<IEngine *> engines;
+
+    for (ScriptBuilder *builder : builders) {
+        auto target = builder->impl->target;
+        addBlocksToTarget(target.get(), builder->impl->blocks);
+        addBlocksToTarget(target.get(), builder->impl->inputBlocks);
+        addTargetToEngine(builder->impl->engine, target);
+        engines.insert(builder->impl->engine);
+    }
+
+    for (IEngine *engine : engines)
+        engine->compile();
+}
+
+void ScriptBuilder::addBlockToList(std::shared_ptr<Block> block)
 {
     if (!impl->blocks.empty()) {
         auto lastBlock = impl->blocks.back();
@@ -272,20 +303,37 @@ void ScriptBuilder::addBlock(std::shared_ptr<Block> block)
 
 void ScriptBuilder::build(std::shared_ptr<Target> target)
 {
-    if (target->blocks().empty()) {
-        for (auto block : impl->blocks)
-            target->addBlock(block);
+    currentScriptBuilder = this;
+
+    addBlocksToTarget(target.get(), impl->blocks);
+    addBlocksToTarget(target.get(), impl->inputBlocks);
+    addTargetToEngine(impl->engine, target);
+
+    impl->engine->compile();
+    currentScriptBuilder = nullptr;
+}
+
+std::string ScriptBuilder::nextId()
+{
+    return std::to_string((uintptr_t)this) + '.' + std::to_string(impl->blockId++);
+}
+
+void ScriptBuilder::addBlocksToTarget(Target *target, const std::vector<std::shared_ptr<Block>> &blocks)
+{
+    auto targetBlocks = target->blocks();
 
-        for (auto block : impl->inputBlocks)
+    for (auto block : blocks) {
+        if (std::find(targetBlocks.begin(), targetBlocks.end(), block) == targetBlocks.end())
             target->addBlock(block);
     }
+}
 
-    std::vector<std::shared_ptr<Target>> targets = impl->engine->targets();
+void ScriptBuilder::addTargetToEngine(IEngine *engine, std::shared_ptr<Target> target)
+{
+    std::vector<std::shared_ptr<Target>> targets = engine->targets();
 
     if (std::find(targets.begin(), targets.end(), target) == targets.end()) {
         targets.push_back(target);
-        impl->engine->setTargets({ target });
+        engine->setTargets(targets);
     }
-
-    impl->engine->compile();
 }

test/dev/test_api/scriptbuilder_test.cpp

@@ -1,6 +1,7 @@
 #include <scratchcpp/dev/test/scriptbuilder.h>
 #include <scratchcpp/project.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/stage.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/value.h>
 #include <scratchcpp/block.h>
@@ -43,11 +44,18 @@ TEST_F(ScriptBuilderTest, AddBlock)
     ASSERT_EQ(block->opcode(), "test_simple");
     ASSERT_TRUE(block->compileFunction());
 
+    block = std::make_shared<Block>("", "test_simple");
+    m_builder->addBlock(block);
+    block = m_builder->currentBlock();
+    ASSERT_TRUE(block);
+    ASSERT_EQ(block->opcode(), "test_simple");
+    ASSERT_TRUE(block->compileFunction());
+
     m_builder->build();
 
     testing::internal::CaptureStdout();
     m_builder->run();
-    ASSERT_EQ(testing::internal::GetCapturedStdout(), "test\n");
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), "test\ntest\n");
 }
 
 TEST_F(ScriptBuilderTest, AddValueInput)
@@ -271,3 +279,31 @@ TEST_F(ScriptBuilderTest, CaptureBlockReturnValue)
     ASSERT_EQ(str, "test");
     ASSERT_EQ(value_toDouble(&values->operator[](1)), -93.4);
 }
+
+TEST_F(ScriptBuilderTest, MultipleScripts)
+{
+    ScriptBuilder builder1(&m_extension, m_engine, m_target, false);
+    builder1.addBlock("test_click_hat");
+    builder1.addBlock("test_simple");
+
+    ScriptBuilder builder2(&m_extension, m_engine, m_target);
+    builder2.addBlock("test_print");
+    builder2.addValueInput("STRING", "Hello world");
+
+    Project project;
+    IEngine *engine = project.engine().get();
+    m_extension.registerBlocks(engine);
+    auto target = std::make_shared<Stage>();
+    ScriptBuilder builder3(&m_extension, engine, target);
+    builder3.addBlock("test_simple");
+
+    ScriptBuilder::buildMultiple({ &builder1, &builder2, &builder3 });
+
+    testing::internal::CaptureStdout();
+    builder2.run();
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), "Hello world\n");
+
+    testing::internal::CaptureStdout();
+    builder3.run();
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), "test\n");
+}

test/dev/test_api/testextension.cpp

@@ -30,6 +30,7 @@ void TestExtension::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "test_teststr", &compileTestStr);
     engine->addCompileFunction(this, "test_input", &compileInput);
     engine->addCompileFunction(this, "test_substack", &compileSubstack);
+    engine->addCompileFunction(this, "test_click_hat", &compileClickHat);
 }
 
 CompilerValue *TestExtension::compileSimple(Compiler *compiler)
@@ -77,6 +78,12 @@ CompilerValue *TestExtension::compileSubstack(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *TestExtension::compileClickHat(Compiler *compiler)
+{
+    compiler->engine()->addTargetClickScript(compiler->block());
+    return nullptr;
+}
+
 extern "C" void test_simple()
 {
     std::cout << "test" << std::endl;

test/dev/test_api/testextension.h

@@ -21,6 +21,7 @@ class TestExtension : public IExtension
         static CompilerValue *compileTestStr(Compiler *compiler);
         static CompilerValue *compileInput(Compiler *compiler);
         static CompilerValue *compileSubstack(Compiler *compiler);
+        static CompilerValue *compileClickHat(Compiler *compiler);
 };
 
 } // namespace libscratchcpp