Implement control_while

Author: adazem009

src/dev/blocks/controlblocks.cpp

@@ -34,6 +34,7 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "control_wait", &compileWait);
     engine->addCompileFunction(this, "control_wait_until", &compileWaitUntil);
     engine->addCompileFunction(this, "control_repeat_until", &compileRepeatUntil);
+    engine->addCompileFunction(this, "control_while", &compileWhile);
 }
 
 CompilerValue *ControlBlocks::compileForever(Compiler *compiler)
@@ -114,6 +115,14 @@ CompilerValue *ControlBlocks::compileRepeatUntil(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *ControlBlocks::compileWhile(Compiler *compiler)
+{
+    auto substack = compiler->input("SUBSTACK");
+    compiler->beginLoopCondition();
+    compiler->moveToWhileLoop(compiler->addInput("CONDITION"), substack ? substack->valueBlock() : nullptr);
+    return nullptr;
+}
+
 extern "C" void control_stop_all(ExecutionContext *ctx)
 {
     ctx->engine()->stop();

src/dev/blocks/controlblocks.h

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

test/dev/blocks/control_blocks_test.cpp

@@ -559,3 +559,90 @@ TEST_F(ControlBlocksTest, RepeatUntil)
         }
     }
 }
+
+TEST_F(ControlBlocksTest, While)
+{
+    auto target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_while");
+        auto substack = std::make_shared<Block>("", "test_print_test");
+        builder.addObscuredInput("SUBSTACK", substack);
+        builder.addValueInput("CONDITION", true);
+        builder.build();
+        m_engine->start();
+
+        for (int i = 0; i < 2; i++) {
+            testing::internal::CaptureStdout();
+            m_engine->step();
+            ASSERT_EQ(testing::internal::GetCapturedStdout().substr(0, 10), "test\ntest\n");
+            ASSERT_TRUE(m_engine->isRunning());
+        }
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_while");
+        auto substack = std::make_shared<Block>("", "test_print_test");
+        builder.addObscuredInput("SUBSTACK", substack);
+        builder.addValueInput("CONDITION", false);
+        builder.build();
+        m_engine->start();
+
+        testing::internal::CaptureStdout();
+        m_engine->step();
+        m_engine->step();
+        ASSERT_TRUE(testing::internal::GetCapturedStdout().empty());
+        ASSERT_FALSE(m_engine->isRunning());
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_while");
+        auto substack = std::make_shared<Block>("", "test_print_test");
+        builder.addObscuredInput("SUBSTACK", substack);
+        auto block = std::make_shared<Block>("", "test_condition");
+        builder.addObscuredInput("CONDITION", block);
+        builder.build();
+
+        conditionReturnValue = true;
+        m_engine->start();
+
+        testing::internal::CaptureStdout();
+        m_engine->step();
+        ASSERT_EQ(testing::internal::GetCapturedStdout().substr(0, 10), "test\ntest\n");
+        ASSERT_TRUE(m_engine->isRunning());
+
+        conditionReturnValue = false;
+        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_while");
+        builder.addValueInput("CONDITION", true);
+
+        builder.build();
+        m_engine->start();
+
+        for (int i = 0; i < 2; i++) {
+            m_engine->step();
+            ASSERT_TRUE(m_engine->isRunning());
+        }
+    }
+}