Implement event_whengreaterthan predicate

Author: adazem009

src/blocks/eventblocks.cpp

@@ -12,9 +12,12 @@
 #include <scratchcpp/promise.h>
 #include <scratchcpp/stringptr.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/itimer.h>
 #include <utf8.h>
 
 #include "eventblocks.h"
+#include "audio/audioinput.h"
+#include "audio/iaudioloudness.h"
 
 using namespace libscratchcpp;
 
@@ -49,6 +52,7 @@ void EventBlocks::registerBlocks(IEngine *engine)
 
     // Hat predicates
     engine->addHatPredicateCompileFunction(this, "event_whentouchingobject", &compileWhenTouchingObjectPredicate);
+    engine->addHatPredicateCompileFunction(this, "event_whengreaterthan", &compileWhenGreaterThanPredicate);
 }
 
 CompilerValue *EventBlocks::compileWhenTouchingObject(Compiler *compiler)
@@ -120,6 +124,27 @@ CompilerValue *EventBlocks::compileWhenGreaterThan(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *EventBlocks::compileWhenGreaterThanPredicate(Compiler *compiler)
+{
+    Field *field = compiler->field("WHENGREATERTHANMENU");
+    std::string predicate;
+
+    if (field) {
+        const std::string option = field->value().toString();
+
+        if (option == "LOUDNESS")
+            predicate = "event_whengreaterthan_loudness_predicate";
+        else if (option == "TIMER")
+            predicate = "event_whengreaterthan_timer_predicate";
+        else
+            return compiler->addConstValue(false);
+    } else
+        return compiler->addConstValue(false);
+
+    CompilerValue *value = compiler->addInput("VALUE");
+    return compiler->addFunctionCallWithCtx(predicate, Compiler::StaticType::Bool, { Compiler::StaticType::Number }, { value });
+}
+
 CompilerValue *EventBlocks::compileBroadcast(Compiler *compiler)
 {
     auto input = compiler->addInput("BROADCAST_INPUT");
@@ -171,6 +196,20 @@ extern "C" bool event_whentouchingobject_predicate(Target *target, const StringP
     }
 }
 
+extern "C" bool event_whengreaterthan_loudness_predicate(ExecutionContext *ctx, double value)
+{
+    if (!EventBlocks::audioInput)
+        EventBlocks::audioInput = AudioInput::instance().get();
+
+    auto audioLoudness = EventBlocks::audioInput->audioLoudness();
+    return (audioLoudness->getLoudness() > value);
+}
+
+extern "C" bool event_whengreaterthan_timer_predicate(ExecutionContext *ctx, double value)
+{
+    return ctx->engine()->timer()->value() > value;
+}
+
 extern "C" void event_broadcast(ExecutionContext *ctx, const StringPtr *name, bool wait)
 {
     Thread *thread = ctx->thread();

src/blocks/eventblocks.h

@@ -7,6 +7,8 @@
 namespace libscratchcpp
 {
 
+class IAudioInput;
+
 class EventBlocks : public IExtension
 {
     public:
@@ -16,6 +18,8 @@ class EventBlocks : public IExtension
 
         void registerBlocks(IEngine *engine) override;
 
+        static inline IAudioInput *audioInput = nullptr;
+
     private:
         static CompilerValue *compileWhenTouchingObject(Compiler *compiler);
         static CompilerValue *compileWhenTouchingObjectPredicate(Compiler *compiler);
@@ -25,6 +29,7 @@ class EventBlocks : public IExtension
         static CompilerValue *compileWhenBroadcastReceived(Compiler *compiler);
         static CompilerValue *compileWhenBackdropSwitchesTo(Compiler *compiler);
         static CompilerValue *compileWhenGreaterThan(Compiler *compiler);
+        static CompilerValue *compileWhenGreaterThanPredicate(Compiler *compiler);
         static CompilerValue *compileBroadcast(Compiler *compiler);
         static CompilerValue *compileBroadcastAndWait(Compiler *compiler);
         static CompilerValue *compileWhenKeyPressed(Compiler *compiler);

test/blocks/event_blocks_test.cpp

@@ -9,6 +9,9 @@
 #include <scratchcpp/executablecode.h>
 #include <enginemock.h>
 #include <targetmock.h>
+#include <audioinputmock.h>
+#include <audioloudnessmock.h>
+#include <timermock.h>
 
 #include "../common.h"
 #include "blocks/eventblocks.h"
@@ -126,6 +129,24 @@ TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
         ASSERT_TRUE(thread.runPredicate());
     }
 
+    // "_stage_"
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target, false);
+        builder.addBlock("event_whentouchingobject");
+        builder.addDropdownInput("TOUCHINGOBJECTMENU", "");
+        auto block = builder.currentBlock();
+
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block, true);
+        Script script(target.get(), block, &m_engineMock);
+        script.setHatPredicateCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+
+        EXPECT_CALL(m_engineMock, findTarget("")).WillOnce(Return(-1));
+        EXPECT_CALL(m_engineMock, targetAt(-1)).WillOnce(Return(nullptr));
+        ASSERT_FALSE(thread.runPredicate());
+    }
+
     // ""
     {
         ScriptBuilder builder(m_extension.get(), m_engine, target, false);
@@ -215,12 +236,10 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     compiler.compile(block);
 }
 
-// TODO: Add test for when greater than hat predicate
-
 TEST_F(EventBlocksTest, WhenGreaterThan)
 {
     auto target = std::make_shared<Sprite>();
-    ScriptBuilder builder(m_extension.get(), m_engine, target);
+    ScriptBuilder builder(m_extension.get(), m_engine, target, false);
 
     builder.addBlock("event_whengreaterthan");
     builder.addDropdownField("WHENGREATERTHANMENU", "LOUDNESS");
@@ -232,6 +251,61 @@ TEST_F(EventBlocksTest, WhenGreaterThan)
     compiler.compile(block);
 }
 
+TEST_F(EventBlocksTest, WhenGreaterThanPredicate)
+{
+    auto target = std::make_shared<Sprite>();
+    ScriptBuilder builder(m_extension.get(), m_engine, target, false);
+
+    const std::vector<Value> values = { 22.7, 23, 23.5 };
+    const std::vector<bool> retValues = { true, false, false };
+
+    AudioInputMock audioInput;
+    auto audioLoudness = std::make_shared<AudioLoudnessMock>();
+    EventBlocks::audioInput = &audioInput;
+    EXPECT_CALL(audioInput, audioLoudness()).Times(3).WillRepeatedly(Return(audioLoudness));
+    EXPECT_CALL(*audioLoudness, getLoudness()).Times(3).WillRepeatedly(Return(23));
+
+    // when [loudness] > x
+    for (int i = 0; i < values.size(); i++) {
+        ScriptBuilder builder(m_extension.get(), m_engine, target, false);
+        builder.addBlock("event_whengreaterthan");
+        builder.addDropdownField("WHENGREATERTHANMENU", "LOUDNESS");
+        builder.addValueInput("VALUE", values[i]);
+        auto block = builder.currentBlock();
+
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block, true);
+        Script script(target.get(), block, &m_engineMock);
+        script.setHatPredicateCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+
+        ASSERT_EQ(thread.runPredicate(), retValues[i]);
+    }
+
+    EventBlocks::audioInput = nullptr;
+
+    TimerMock timer;
+    EXPECT_CALL(m_engineMock, timer()).Times(3).WillRepeatedly(Return(&timer));
+    EXPECT_CALL(timer, value()).Times(3).WillRepeatedly(Return(23));
+
+    // when [timer] > x
+    for (int i = 0; i < values.size(); i++) {
+        ScriptBuilder builder(m_extension.get(), m_engine, target, false);
+        builder.addBlock("event_whengreaterthan");
+        builder.addDropdownField("WHENGREATERTHANMENU", "TIMER");
+        builder.addValueInput("VALUE", values[i]);
+        auto block = builder.currentBlock();
+
+        Compiler compiler(&m_engineMock, target.get());
+        auto code = compiler.compile(block, true);
+        Script script(target.get(), block, &m_engineMock);
+        script.setHatPredicateCode(code);
+        Thread thread(target.get(), &m_engineMock, &script);
+
+        ASSERT_EQ(thread.runPredicate(), retValues[i]);
+    }
+}
+
 TEST_F(EventBlocksTest, Broadcast)
 {
     auto broadcast = std::make_shared<Broadcast>("", "test");