Implement control_wait_until

Author: adazem009

src/dev/blocks/controlblocks.cpp

@@ -32,6 +32,7 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "control_if_else", &compileIfElse);
     engine->addCompileFunction(this, "control_stop", &compileStop);
     engine->addCompileFunction(this, "control_wait", &compileWait);
+    engine->addCompileFunction(this, "control_wait_until", &compileWaitUntil);
 }
 
 CompilerValue *ControlBlocks::compileForever(Compiler *compiler)
@@ -96,6 +97,14 @@ CompilerValue *ControlBlocks::compileWait(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *ControlBlocks::compileWaitUntil(Compiler *compiler)
+{
+    compiler->beginLoopCondition();
+    compiler->beginRepeatUntilLoop(compiler->addInput("CONDITION"));
+    compiler->endLoop();
+    return nullptr;
+}
+
 extern "C" void control_stop_all(ExecutionContext *ctx)
 {
     ctx->engine()->stop();

src/dev/blocks/controlblocks.h

@@ -22,6 +22,7 @@ class ControlBlocks : public IExtension
         static CompilerValue *compileIfElse(Compiler *compiler);
         static CompilerValue *compileStop(Compiler *compiler);
         static CompilerValue *compileWait(Compiler *compiler);
+        static CompilerValue *compileWaitUntil(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/control_blocks_test.cpp

@@ -410,3 +410,65 @@ TEST_F(ControlBlocksTest, Wait)
         ASSERT_TRUE(code->isFinished(ctx.get()));
     }
 }
+
+TEST_F(ControlBlocksTest, WaitUntil)
+{
+    auto target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_wait_until");
+        builder.addValueInput("CONDITION", false);
+        builder.build();
+        m_engine->start();
+
+        m_engine->step();
+        ASSERT_TRUE(m_engine->isRunning());
+
+        m_engine->step();
+        ASSERT_TRUE(m_engine->isRunning());
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_wait_until");
+        builder.addValueInput("CONDITION", true);
+        builder.build();
+        m_engine->start();
+
+        m_engine->step();
+        m_engine->step();
+        ASSERT_FALSE(m_engine->isRunning());
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_wait_until");
+        auto block = std::make_shared<Block>("", "test_condition");
+        builder.addObscuredInput("CONDITION", block);
+        builder.build();
+
+        conditionReturnValue = false;
+        m_engine->start();
+
+        m_engine->step();
+        ASSERT_TRUE(m_engine->isRunning());
+
+        m_engine->step();
+        ASSERT_TRUE(m_engine->isRunning());
+
+        conditionReturnValue = true;
+        m_engine->step();
+        m_engine->step();
+        ASSERT_FALSE(m_engine->isRunning());
+    }
+}

test/dev/blocks/util.cpp

@@ -28,11 +28,18 @@ void registerBlocks(IEngine *engine, IExtension *extension)
         compiler->addFunctionCall("test_print", Compiler::StaticType::Void, { Compiler::StaticType::String }, { input });
         return nullptr;
     });
+
+    engine->addCompileFunction(extension, "test_condition", [](Compiler *compiler) -> CompilerValue * { return compiler->addFunctionCall("test_condition", Compiler::StaticType::Bool); });
 }
 
 extern "C" void test_print(const char *str)
 {
     std::cout << str << std::endl;
 }
 
+extern "C" bool test_condition()
+{
+    return conditionReturnValue;
+}
+
 } // namespace libscratchcpp

test/dev/blocks/util.h

@@ -6,6 +6,8 @@ namespace libscratchcpp
 class IEngine;
 class IExtension;
 
+bool conditionReturnValue = false;
+
 void registerBlocks(IEngine *engine, IExtension *extension);
 
 } // namespace libscratchcpp