Implement sensing_askandwait and sensing_answer blocks

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -3,11 +3,16 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/thread.h>
+#include <scratchcpp/promise.h>
+#include <scratchcpp/executioncontext.h>
 #include <scratchcpp/value.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/stringptr.h>
 #include <scratchcpp/string_functions.h>
+#include <scratchcpp/string_pool.h>
 #include <utf8.h>
 
 #include "sensingblocks.h"
@@ -35,6 +40,41 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sensing_touchingcolor", &compileTouchingColor);
     engine->addCompileFunction(this, "sensing_coloristouchingcolor", &compileColorIsTouchingColor);
     engine->addCompileFunction(this, "sensing_distanceto", &compileDistanceTo);
+    engine->addCompileFunction(this, "sensing_askandwait", &compileAskAndWait);
+    engine->addCompileFunction(this, "sensing_answer", &compileAnswer);
+}
+
+void SensingBlocks::onInit(IEngine *engine)
+{
+    engine->questionAnswered().connect(&onAnswer);
+
+    engine->threadAboutToStop().connect([engine](Thread *thread) {
+        if (!m_questions.empty()) {
+            // Abort the question of this thread if it's currently being displayed
+            if (m_questions.front()->thread == thread) {
+                thread->target()->bubble()->setText("");
+                engine->questionAborted()();
+            }
+
+            m_questions.erase(std::remove_if(m_questions.begin(), m_questions.end(), [thread](const std::unique_ptr<Question> &question) { return question->thread == thread; }), m_questions.end());
+        }
+    });
+}
+
+void SensingBlocks::clearQuestions()
+{
+    m_questions.clear();
+}
+
+void SensingBlocks::askQuestion(ExecutionContext *ctx, const StringPtr *question)
+{
+    const bool isQuestionAsked = !m_questions.empty();
+    // TODO: Use UTF-16 in engine (and TextBubble?)
+    std::string u8str = utf8::utf16to8(std::u16string(question->data));
+    enqueueAsk(u8str, ctx->thread());
+
+    if (!isQuestionAsked)
+        askNextQuestion();
 }
 
 CompilerValue *SensingBlocks::compileTouchingObject(Compiler *compiler)
@@ -107,6 +147,76 @@ CompilerValue *SensingBlocks::compileDistanceTo(Compiler *compiler)
     return compiler->addConstValue(10000.0);
 }
 
+CompilerValue *SensingBlocks::compileAskAndWait(Compiler *compiler)
+{
+    CompilerValue *question = compiler->addInput("QUESTION");
+    compiler->addFunctionCallWithCtx("sensing_askandwait", Compiler::StaticType::Void, { Compiler::StaticType::String }, { question });
+    compiler->createYield();
+    return nullptr;
+}
+
+CompilerValue *SensingBlocks::compileAnswer(Compiler *compiler)
+{
+    return compiler->addFunctionCallWithCtx("sensing_answer", Compiler::StaticType::String);
+}
+
+void SensingBlocks::onAnswer(const std::string &answer)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/6055823f203a696165084b873e661713806583ec/src/blocks/scratch3_sensing.js#L99-L115
+    if (!m_questions.empty()) {
+        Question *question = m_questions.front().get();
+        Thread *thread = question->thread;
+        assert(thread);
+        assert(thread->target());
+
+        // If the target was visible when asked, hide the say bubble unless the target was the stage
+        if (question->wasVisible && !question->wasStage)
+            thread->target()->bubble()->setText("");
+
+        m_questions.erase(m_questions.begin());
+        thread->promise()->resolve();
+        askNextQuestion();
+    }
+}
+
+void SensingBlocks::enqueueAsk(const std::string &question, Thread *thread)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/6055823f203a696165084b873e661713806583ec/src/blocks/scratch3_sensing.js#L117-L119
+    assert(thread);
+    Target *target = thread->target();
+    assert(target);
+    bool visible = true;
+    bool isStage = target->isStage();
+
+    if (!isStage) {
+        Sprite *sprite = static_cast<Sprite *>(target);
+        visible = sprite->visible();
+    }
+
+    m_questions.push_back(std::make_unique<Question>(question, thread, visible, isStage));
+}
+
+void SensingBlocks::askNextQuestion()
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/6055823f203a696165084b873e661713806583ec/src/blocks/scratch3_sensing.js#L121-L133
+    if (m_questions.empty())
+        return;
+
+    Question *question = m_questions.front().get();
+    Target *target = question->thread->target();
+    IEngine *engine = question->thread->engine();
+
+    // If the target is visible, emit a blank question and show
+    // a bubble unless the target was the stage
+    if (question->wasVisible && !question->wasStage) {
+        target->bubble()->setType(TextBubble::Type::Say);
+        target->bubble()->setText(question->question);
+
+        engine->questionAsked()("");
+    } else
+        engine->questionAsked()(question->question);
+}
+
 extern "C" bool sensing_touching_mouse(Target *target)
 {
     IEngine *engine = target->engine();
@@ -191,3 +301,16 @@ extern "C" double sensing_distanceto(Sprite *sprite, const StringPtr *object)
 
     return 10000.0;
 }
+
+extern "C" void sensing_askandwait(ExecutionContext *ctx, const StringPtr *question)
+{
+    SensingBlocks::askQuestion(ctx, question);
+    ctx->thread()->setPromise(std::make_shared<Promise>());
+}
+
+extern "C" StringPtr *sensing_answer(ExecutionContext *ctx)
+{
+    StringPtr *ret = string_pool_new();
+    string_assign(ret, ctx->engine()->answer());
+    return ret;
+}

src/blocks/sensingblocks.h

@@ -3,10 +3,15 @@
 #pragma once
 
 #include <scratchcpp/iextension.h>
+#include <vector>
+#include <memory>
 
 namespace libscratchcpp
 {
 
+class ExecutionContext;
+class Thread;
+
 class SensingBlocks : public IExtension
 {
     public:
@@ -15,12 +20,40 @@ class SensingBlocks : public IExtension
         Rgb color() const override;
 
         void registerBlocks(IEngine *engine) override;
+        void onInit(IEngine *engine) override;
+
+        static void clearQuestions();
+        static void askQuestion(ExecutionContext *ctx, const StringPtr *question);
 
     private:
+        struct Question
+        {
+                Question(const std::string &question, Thread *thread, bool wasVisible, bool wasStage) :
+                    question(question),
+                    thread(thread),
+                    wasVisible(wasVisible),
+                    wasStage(wasStage)
+                {
+                }
+
+                std::string question;
+                Thread *thread = nullptr;
+                bool wasVisible = false;
+                bool wasStage = false;
+        };
+
         static CompilerValue *compileTouchingObject(Compiler *compiler);
         static CompilerValue *compileTouchingColor(Compiler *compiler);
         static CompilerValue *compileColorIsTouchingColor(Compiler *compiler);
         static CompilerValue *compileDistanceTo(Compiler *compiler);
+        static CompilerValue *compileAskAndWait(Compiler *compiler);
+        static CompilerValue *compileAnswer(Compiler *compiler);
+
+        static void onAnswer(const std::string &answer);
+        static void enqueueAsk(const std::string &question, Thread *thread);
+        static void askNextQuestion();
+
+        static inline std::vector<std::unique_ptr<Question>> m_questions;
 };
 
 } // namespace libscratchcpp