Add edge-activated hat API to IEngine

Author: adazem009

include/scratchcpp/iengine.h

@@ -223,6 +223,13 @@ class LIBSCRATCHCPP_EXPORT IEngine
          */
         virtual void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) = 0;
 
+        /*!
+         * Call this from IBlockSection#registerBlocks() to add a hat block predicate compile function to a block section.
+         * \note This only works with edge-activated hats.
+         * \see <a href="blockSections.html">Block sections</a>
+         */
+        virtual void addHatPredicateCompileFunction(IBlockSection *section, const std::string &opcode, HatPredicateCompileFunc f) = 0;
+
         /*!
          * Call this from IBlockSection#registerBlocks() to add a monitor name function to a block section.
          * \see <a href="blockSections.html">Block sections</a>

src/engine/internal/blocksectioncontainer.cpp

@@ -11,6 +11,11 @@ void BlockSectionContainer::addCompileFunction(const std::string &opcode, BlockC
     m_compileFunctions[opcode] = f;
 }
 
+void BlockSectionContainer::addHatPredicateCompileFunction(const std::string &opcode, HatPredicateCompileFunc f)
+{
+    m_hatPredicateCompileFunctions[opcode] = f;
+}
+
 void BlockSectionContainer::addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f)
 {
     m_monitorNameFunctions[opcode] = f;
@@ -48,6 +53,13 @@ BlockComp BlockSectionContainer::resolveBlockCompileFunc(const std::string &opco
     return nullptr;
 }
 
+HatPredicateCompileFunc BlockSectionContainer::resolveHatPredicateCompileFunc(const std::string &opcode) const
+{
+    if (m_hatPredicateCompileFunctions.count(opcode) == 1)
+        return m_hatPredicateCompileFunctions.at(opcode);
+    return nullptr;
+}
+
 MonitorNameFunc BlockSectionContainer::resolveMonitorNameFunc(const std::string &opcode) const
 {
     if (m_monitorNameFunctions.count(opcode) == 1)

src/engine/internal/blocksectioncontainer.h

@@ -16,6 +16,7 @@ class BlockSectionContainer
         BlockSectionContainer(const BlockSectionContainer &) = delete;
 
         void addCompileFunction(const std::string &opcode, BlockComp f);
+        void addHatPredicateCompileFunction(const std::string &opcode, HatPredicateCompileFunc f);
         void addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f);
         void addMonitorChangeFunction(const std::string &opcode, MonitorChangeFunc f);
         void addHatBlock(const std::string &opcode);
@@ -24,6 +25,7 @@ class BlockSectionContainer
         void addFieldValue(const std::string &value, int id);
 
         BlockComp resolveBlockCompileFunc(const std::string &opcode) const;
+        HatPredicateCompileFunc resolveHatPredicateCompileFunc(const std::string &opcode) const;
         MonitorNameFunc resolveMonitorNameFunc(const std::string &opcode) const;
         MonitorChangeFunc resolveMonitorChangeFunc(const std::string &opcode) const;
         int resolveInput(const std::string &name) const;
@@ -32,6 +34,7 @@ class BlockSectionContainer
 
     private:
         std::unordered_map<std::string, BlockComp> m_compileFunctions;
+        std::unordered_map<std::string, HatPredicateCompileFunc> m_hatPredicateCompileFunctions;
         std::unordered_map<std::string, MonitorNameFunc> m_monitorNameFunctions;
         std::unordered_map<std::string, MonitorChangeFunc> m_monitorChangeFunctions;
         std::unordered_map<std::string, int> m_inputs;

src/engine/internal/engine.cpp

@@ -38,6 +38,11 @@ const std::unordered_map<Engine::HatType, bool> Engine::m_hatRestartExistingThre
     { HatType::CloneInit, false }, { HatType::KeyPressed, false },       { HatType::TargetClicked, true }
 };
 
+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 }
+};
+
 Engine::Engine() :
     m_defaultTimer(std::make_unique<Timer>()),
     m_timer(m_defaultTimer.get()),
@@ -79,6 +84,7 @@ void Engine::clear()
     m_whenKeyPressedHats.clear();
 
     m_scriptHatFields.clear();
+    m_edgeActivatedHatValues.clear();
 
     m_running = false;
 }
@@ -93,8 +99,11 @@ void Engine::resolveIds()
             auto container = blockSectionContainer(block->opcode());
             block->setNext(getBlock(block->nextId()));
             block->setParent(getBlock(block->parentId()));
-            if (container)
+
+            if (container) {
                 block->setCompileFunction(container->resolveBlockCompileFunc(block->opcode()));
+                block->setHatPredicateCompileFunction(container->resolveHatPredicateCompileFunc(block->opcode()));
+            }
 
             const auto &inputs = block->inputs();
             for (const auto &input : inputs) {
@@ -215,6 +224,8 @@ void Engine::compile()
                     compiler.compile(block);
 
                     script->setBytecode(compiler.bytecode());
+                    script->setHatPredicateBytecode(compiler.hatPredicateBytecode());
+
                     if (block->opcode() == "procedures_definition") {
                         auto b = block->inputAt(block->findInput("custom_block"))->valueBlock();
                         procedureBytecodeMap[b->mutationPrototype()->procCode()] = script->bytecode();
@@ -295,6 +306,7 @@ void Engine::start()
 
     m_eventLoopMutex.lock();
     m_timer->reset();
+    m_edgeActivatedHatValues.clear();
     m_running = true;
 
     // Start "when green flag clicked" scripts
@@ -432,6 +444,30 @@ void Engine::step()
     // Clean up threads that were told to stop during or since the last step
     m_threads.erase(std::remove_if(m_threads.begin(), m_threads.end(), [](std::shared_ptr<VirtualMachine> thread) { return thread->atEnd(); }), m_threads.end());
 
+    // Find all edge-activated hats, and add them to threads to be evaluated
+    for (auto const &[hatType, edgeActivated] : m_hatEdgeActivated) {
+        if (edgeActivated) {
+            auto newThreads = startHats(hatType, {}, nullptr);
+
+            // Process edge-triggered hats (must happen here because of Scratch 2 compatibility)
+            // Processing the hats means running their predicates (if they didn't change their return value from false to true, remove the threads)
+            for (auto thread : newThreads) {
+                bool oldValue = false;
+                auto it = m_edgeActivatedHatValues.find(hatType);
+
+                if (it != m_edgeActivatedHatValues.cend())
+                    oldValue = it->second;
+
+                bool newValue = thread->script()->runHatPredicate();
+                bool edgeWasActivated = !oldValue && newValue; // changed from false true
+                m_edgeActivatedHatValues[hatType] = newValue;
+
+                if (!edgeWasActivated)
+                    stopThread(thread.get());
+            }
+        }
+    }
+
     m_redrawRequested = false;
 
     // Step threads
@@ -856,6 +892,14 @@ void Engine::addCompileFunction(IBlockSection *section, const std::string &opcod
         container->addCompileFunction(opcode, f);
 }
 
+void Engine::addHatPredicateCompileFunction(IBlockSection *section, const std::string &opcode, HatPredicateCompileFunc f)
+{
+    auto container = blockSectionContainer(section);
+
+    if (container)
+        container->addHatPredicateCompileFunction(opcode, f);
+}
+
 void Engine::addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f)
 {
     auto container = blockSectionContainer(section);
@@ -1718,11 +1762,5 @@ Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::varia
         },
         optTarget);
 
-    // Run edge-triggered hats (for compatibility with Scratch 2)
-    // TODO: Find out what "edge-triggered" hats are and execute them
-    // Uncommenting this would cause infinite recursion in some cases, so let's keep it commented
-    /*for (auto thread : newThreads)
-        thread->run();*/
-
     return newThreads;
 }

src/engine/internal/engine.h

@@ -105,6 +105,7 @@ class Engine : public IEngine
         unsigned int functionIndex(BlockFunc f) override;
 
         void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) override;
+        void addHatPredicateCompileFunction(IBlockSection *section, const std::string &opcode, HatPredicateCompileFunc f) override;
         void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) override;
         void addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f) override;
         void addHatBlock(IBlockSection *section, const std::string &opcode) override;
@@ -216,6 +217,7 @@ class Engine : public IEngine
         startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget);
 
         static const std::unordered_map<HatType, bool> m_hatRestartExistingThreads; // used to check whether a hat should restart existing threads
+        static const std::unordered_map<HatType, bool> m_hatEdgeActivated;          // used to check whether a hat is edge-activated (runs when a predicate becomes true)
 
         std::unordered_map<std::shared_ptr<IBlockSection>, std::unique_ptr<BlockSectionContainer>> m_sections;
         std::vector<std::shared_ptr<Target>> m_targets;
@@ -241,6 +243,8 @@ class Engine : public IEngine
 
         std::unordered_map<Script *, std::unordered_map<HatField, int>> m_scriptHatFields; // HatField, field ID from the block implementation
 
+        std::unordered_map<HatType, bool> m_edgeActivatedHatValues; // edge-activated hats only run after the value changes from false to true
+
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;
         double m_fps = 30;                         // default FPS

test/mocks/enginemock.h

@@ -86,6 +86,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(unsigned int, functionIndex, (BlockFunc), (override));
 
         MOCK_METHOD(void, addCompileFunction, (IBlockSection *, const std::string &, BlockComp), (override));
+        MOCK_METHOD(void, addHatPredicateCompileFunction, (IBlockSection *, const std::string &, HatPredicateCompileFunc), (override));
         MOCK_METHOD(void, addMonitorNameFunction, (IBlockSection *, const std::string &, MonitorNameFunc), (override));
         MOCK_METHOD(void, addMonitorChangeFunction, (IBlockSection *, const std::string &, MonitorChangeFunc), (override));
         MOCK_METHOD(void, addHatBlock, (IBlockSection *, const std::string &), (override));