Implement event_whengreaterthan block

Author: adazem009

include/scratchcpp/iengine.h

@@ -299,6 +299,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /* Registers the given "when this sprite/stage clicked" script. */
         virtual void addTargetClickScript(std::shared_ptr<Block> hatBlock) = 0;
 
+        /* Registers the given "when greater than" script. */
+        virtual void addWhenGreaterThanScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
 

src/blocks/eventblocks.cpp

@@ -8,11 +8,17 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/itimer.h>
 
 #include "eventblocks.h"
+#include "audio/audioinput.h"
+#include "audio/iaudioloudness.h"
 
 using namespace libscratchcpp;
 
+IAudioInput *EventBlocks::audioInput = nullptr;
+
 std::string EventBlocks::name() const
 {
     return "Events";
@@ -28,15 +34,25 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
     engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
     engine->addCompileFunction(this, "event_whenbackdropswitchesto", &compileWhenBackdropSwitchesTo);
+    engine->addCompileFunction(this, "event_whengreaterthan", &compileWhenGreaterThan);
     engine->addCompileFunction(this, "event_whenkeypressed", &compileWhenKeyPressed);
 
+    // Hat predicates
+    engine->addHatPredicateCompileFunction(this, "event_whengreaterthan", &compileWhenGreaterThanPredicate);
+
     // Inputs
     engine->addInput(this, "BROADCAST_INPUT", BROADCAST_INPUT);
+    engine->addInput(this, "VALUE", VALUE);
 
     // Fields
     engine->addField(this, "BROADCAST_OPTION", BROADCAST_OPTION);
     engine->addField(this, "BACKDROP", BACKDROP);
+    engine->addField(this, "WHENGREATERTHANMENU", WHENGREATERTHANMENU);
     engine->addField(this, "KEY_OPTION", KEY_OPTION);
+
+    // Fields values
+    engine->addFieldValue(this, "LOUDNESS", Loudness);
+    engine->addFieldValue(this, "TIMER", Timer);
 }
 
 void EventBlocks::compileWhenFlagClicked(Compiler *compiler)
@@ -97,6 +113,38 @@ void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
     compiler->engine()->addBackdropChangeScript(compiler->block(), BACKDROP);
 }
 
+void EventBlocks::compileWhenGreaterThanPredicate(Compiler *compiler)
+{
+    Field *field = compiler->field(WHENGREATERTHANMENU);
+    BlockFunc predicate = nullptr;
+
+    if (field) {
+        switch (field->specialValueId()) {
+            case Loudness:
+                predicate = &whenLoudnessGreaterThanPredicate;
+                break;
+
+            case Timer:
+                predicate = &whenTimerGreaterThanPredicate;
+                break;
+
+            default:
+                compiler->addInstruction(vm::OP_NULL);
+                return;
+        }
+    }
+
+    if (predicate) {
+        compiler->addInput(VALUE);
+        compiler->addFunctionCall(predicate);
+    }
+}
+
+void EventBlocks::compileWhenGreaterThan(Compiler *compiler)
+{
+    compiler->engine()->addWhenGreaterThanScript(compiler->block());
+}
+
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
 {
     // NOTE: Field values don't have to be registered because keys are referenced by their names
@@ -140,3 +188,21 @@ unsigned int EventBlocks::checkBroadcastByIndex(VirtualMachine *vm)
         vm->stop(true, true, true);
     return 1;
 }
+
+unsigned int EventBlocks::whenLoudnessGreaterThanPredicate(VirtualMachine *vm)
+{
+    if (!audioInput)
+        audioInput = AudioInput::instance().get();
+
+    auto audioLoudness = audioInput->audioLoudness();
+    const Value &operand = *vm->getInput(0, 1);
+    vm->replaceReturnValue(Value(audioLoudness->getLoudness()) > operand, 1);
+    return 0;
+}
+
+unsigned int EventBlocks::whenTimerGreaterThanPredicate(VirtualMachine *vm)
+{
+    const Value &operand = *vm->getInput(0, 1);
+    vm->replaceReturnValue(Value(vm->engine()->timer()->value()) > operand, 1);
+    return 0;
+}

src/blocks/eventblocks.h

@@ -9,23 +9,32 @@ namespace libscratchcpp
 
 class Compiler;
 class VirtualMachine;
+class IAudioInput;
 
 /*! \brief The EventBlocks class contains the implementation of event blocks. */
 class EventBlocks : public IBlockSection
 {
     public:
         enum Inputs
         {
-            BROADCAST_INPUT
+            BROADCAST_INPUT,
+            VALUE
         };
 
         enum Fields
         {
             BROADCAST_OPTION,
             BACKDROP,
+            WHENGREATERTHANMENU,
             KEY_OPTION
         };
 
+        enum FieldValues
+        {
+            Loudness,
+            Timer
+        };
+
         std::string name() const override;
 
         void registerBlocks(IEngine *engine) override;
@@ -37,6 +46,8 @@ class EventBlocks : public IBlockSection
         static void compileBroadcastAndWait(Compiler *compiler);
         static void compileWhenBroadcastReceived(Compiler *compiler);
         static void compileWhenBackdropSwitchesTo(Compiler *compiler);
+        static void compileWhenGreaterThanPredicate(Compiler *compiler);
+        static void compileWhenGreaterThan(Compiler *compiler);
         static void compileWhenKeyPressed(Compiler *compiler);
 
         static unsigned int broadcast(VirtualMachine *vm);
@@ -45,6 +56,11 @@ class EventBlocks : public IBlockSection
         static unsigned int broadcastByIndexAndWait(VirtualMachine *vm);
         static unsigned int checkBroadcast(VirtualMachine *vm);
         static unsigned int checkBroadcastByIndex(VirtualMachine *vm);
+
+        static unsigned int whenLoudnessGreaterThanPredicate(VirtualMachine *vm);
+        static unsigned int whenTimerGreaterThanPredicate(VirtualMachine *vm);
+
+        static IAudioInput *audioInput;
 };
 
 } // namespace libscratchcpp

src/engine/internal/engine.cpp

@@ -34,13 +34,13 @@
 using namespace libscratchcpp;
 
 const std::unordered_map<Engine::HatType, bool> Engine::m_hatRestartExistingThreads = {
-    { HatType::GreenFlag, true },  { HatType::BroadcastReceived, true }, { HatType::BackdropChanged, true },
-    { HatType::CloneInit, false }, { HatType::KeyPressed, false },       { HatType::TargetClicked, true }
+    { HatType::GreenFlag, true },   { HatType::BroadcastReceived, true }, { HatType::BackdropChanged, true }, { HatType::CloneInit, false },
+    { HatType::KeyPressed, false }, { HatType::TargetClicked, true },     { HatType::WhenGreaterThan, false }
 };
 
 const std::unordered_map<Engine::HatType, bool> Engine::m_hatEdgeActivated = {
-    { HatType::GreenFlag, false }, { HatType::BroadcastReceived, false }, { HatType::BackdropChanged, false },
-    { HatType::CloneInit, false }, { HatType::KeyPressed, false },        { HatType::TargetClicked, false }
+    { HatType::GreenFlag, false },  { HatType::BroadcastReceived, false }, { HatType::BackdropChanged, false }, { HatType::CloneInit, false },
+    { HatType::KeyPressed, false }, { HatType::TargetClicked, false },     { HatType::WhenGreaterThan, true }
 };
 
 Engine::Engine() :
@@ -82,6 +82,8 @@ void Engine::clear()
     m_broadcastHats.clear();
     m_cloneInitHats.clear();
     m_whenKeyPressedHats.clear();
+    m_whenTargetClickedHats.clear();
+    m_whenGreaterThanHats.clear();
 
     m_scriptHatFields.clear();
     m_edgeActivatedHatValues.clear();
@@ -1034,6 +1036,12 @@ void Engine::addTargetClickScript(std::shared_ptr<Block> hatBlock)
     addHatToMap(m_whenTargetClickedHats, m_scripts[hatBlock].get());
 }
 
+void Engine::addWhenGreaterThanScript(std::shared_ptr<Block> hatBlock)
+{
+    Script *script = m_scripts[hatBlock].get();
+    addHatToMap(m_whenGreaterThanHats, script);
+}
+
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 {
     return m_targets;
@@ -1442,6 +1450,9 @@ const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
         case HatType::TargetClicked:
             return m_whenTargetClickedHats[target];
 
+        case HatType::WhenGreaterThan:
+            return m_whenGreaterThanHats[target];
+
         default: {
             static const std::vector<Script *> empty = {};
             return empty;

src/engine/internal/engine.h

@@ -125,6 +125,7 @@ class Engine : public IEngine
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
         void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
         void addTargetClickScript(std::shared_ptr<Block> hatBlock) override;
+        void addWhenGreaterThanScript(std::shared_ptr<Block> hatBlock) override;
 
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
@@ -171,14 +172,16 @@ class Engine : public IEngine
             BackdropChanged,
             CloneInit,
             KeyPressed,
-            TargetClicked
+            TargetClicked,
+            WhenGreaterThan
         };
 
         enum class HatField
         {
             BroadcastOption,
             Backdrop,
-            KeyOption
+            KeyOption,
+            WhenGreaterThanMenu
         };
 
         std::vector<std::shared_ptr<VirtualMachine>> stepThreads();
@@ -240,6 +243,7 @@ class Engine : public IEngine
         std::unordered_map<Target *, std::vector<Script *>> m_cloneInitHats;
         std::unordered_map<Target *, std::vector<Script *>> m_whenKeyPressedHats;
         std::unordered_map<Target *, std::vector<Script *>> m_whenTargetClickedHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_whenGreaterThanHats;
 
         std::unordered_map<Script *, std::unordered_map<HatField, int>> m_scriptHatFields; // HatField, field ID from the block implementation