Implement control_wait

Author: adazem009

src/dev/blocks/controlblocks.cpp

@@ -8,6 +8,7 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/dev/executioncontext.h>
 #include <scratchcpp/thread.h>
+#include <scratchcpp/istacktimer.h>
 
 #include "controlblocks.h"
 
@@ -30,6 +31,7 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "control_if", &compileIf);
     engine->addCompileFunction(this, "control_if_else", &compileIfElse);
     engine->addCompileFunction(this, "control_stop", &compileStop);
+    engine->addCompileFunction(this, "control_wait", &compileWait);
 }
 
 CompilerValue *ControlBlocks::compileForever(Compiler *compiler)
@@ -80,6 +82,20 @@ CompilerValue *ControlBlocks::compileStop(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *ControlBlocks::compileWait(Compiler *compiler)
+{
+    auto duration = compiler->addInput("DURATION");
+    compiler->addFunctionCallWithCtx("control_start_stack_timer", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { duration });
+    compiler->createYield();
+
+    compiler->beginLoopCondition();
+    auto elapsed = compiler->addFunctionCallWithCtx("control_stack_timer_elapsed", Compiler::StaticType::Bool);
+    compiler->beginRepeatUntilLoop(elapsed);
+    compiler->endLoop();
+
+    return nullptr;
+}
+
 extern "C" void control_stop_all(ExecutionContext *ctx)
 {
     ctx->engine()->stop();
@@ -90,3 +106,13 @@ extern "C" void control_stop_other_scripts_in_target(ExecutionContext *ctx)
     Thread *thread = ctx->thread();
     ctx->engine()->stopTarget(thread->target(), thread);
 }
+
+extern "C" void control_start_stack_timer(ExecutionContext *ctx, double seconds)
+{
+    ctx->stackTimer()->start(seconds);
+}
+
+extern "C" bool control_stack_timer_elapsed(ExecutionContext *ctx)
+{
+    return ctx->stackTimer()->elapsed();
+}

src/dev/blocks/controlblocks.h

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

test/dev/blocks/control_blocks_test.cpp

@@ -6,7 +6,11 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/thread.h>
+#include <scratchcpp/dev/executablecode.h>
+#include <scratchcpp/dev/executioncontext.h>
+
 #include <enginemock.h>
+#include <stacktimermock.h>
 
 #include "../common.h"
 #include "dev/blocks/controlblocks.h"
@@ -15,6 +19,8 @@
 using namespace libscratchcpp;
 using namespace libscratchcpp::test;
 
+using ::testing::Return;
+
 class ControlBlocksTest : public testing::Test
 {
     public:
@@ -332,3 +338,69 @@ TEST_F(ControlBlocksTest, Stop)
         thread.run();
     }
 }
+
+TEST_F(ControlBlocksTest, Wait)
+{
+    auto target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_wait");
+        builder.addValueInput("DURATION", 2.5);
+        auto block = builder.currentBlock();
+
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block);
+        Script script(target.get(), block, &m_engineMock);
+        script.setCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+        auto ctx = code->createExecutionContext(&thread);
+        StackTimerMock timer;
+        ctx->setStackTimer(&timer);
+
+        EXPECT_CALL(timer, start(2.5));
+        code->run(ctx.get());
+        ASSERT_FALSE(code->isFinished(ctx.get()));
+
+        EXPECT_CALL(timer, elapsed()).WillOnce(Return(false));
+        code->run(ctx.get());
+        ASSERT_FALSE(code->isFinished(ctx.get()));
+
+        EXPECT_CALL(timer, elapsed()).WillOnce(Return(false));
+        code->run(ctx.get());
+        ASSERT_FALSE(code->isFinished(ctx.get()));
+
+        EXPECT_CALL(timer, elapsed()).WillOnce(Return(true));
+        code->run(ctx.get());
+        ASSERT_TRUE(code->isFinished(ctx.get()));
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_wait");
+        builder.addNullObscuredInput("DURATION");
+        auto block = builder.currentBlock();
+
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block);
+        Script script(target.get(), block, &m_engineMock);
+        script.setCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+        auto ctx = code->createExecutionContext(&thread);
+        StackTimerMock timer;
+        ctx->setStackTimer(&timer);
+
+        EXPECT_CALL(timer, start(0.0));
+        code->run(ctx.get());
+        ASSERT_FALSE(code->isFinished(ctx.get()));
+
+        EXPECT_CALL(timer, elapsed()).WillOnce(Return(true));
+        code->run(ctx.get());
+        ASSERT_TRUE(code->isFinished(ctx.get()));
+    }
+}