Store values of edge-activated hats with multiple field values correctly

Author: adazem009

src/engine/internal/engine.cpp

@@ -453,14 +453,26 @@ void Engine::step()
             // 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 hatBlock = thread->script()->topBlock();
+                assert(hatBlock);
+                assert(hatBlock->fieldAt(0)); // TODO: Edge-activated hats currently support only one field
+                int fieldValueId = hatBlock->fieldAt(0)->specialValueId();
+                assert(fieldValueId != -1);
                 auto it = m_edgeActivatedHatValues.find(hatType);
 
-                if (it != m_edgeActivatedHatValues.cend())
-                    oldValue = it->second;
+                if (it == m_edgeActivatedHatValues.cend()) {
+                    m_edgeActivatedHatValues[hatType] = {};
+                } else {
+                    const std::unordered_map<int, bool> &values = it->second;
+                    auto fieldIt = values.find(fieldValueId);
+
+                    if (fieldIt != values.cend())
+                        oldValue = fieldIt->second;
+                }
 
                 bool newValue = thread->script()->runHatPredicate();
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
-                m_edgeActivatedHatValues[hatType] = newValue;
+                m_edgeActivatedHatValues[hatType][fieldValueId] = newValue;
 
                 if (!edgeWasActivated)
                     stopThread(thread.get());

src/engine/internal/engine.h

@@ -248,7 +248,7 @@ 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::unordered_map<HatType, std::unordered_map<int, bool>> m_edgeActivatedHatValues; // (field value, last value) edge-activated hats only run after the value changes from false to true
 
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;

test/engine/engine_test.cpp

@@ -14,8 +14,10 @@
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
+#include <audioinputmock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <audioloudnessmock.h>
 #include <monitorhandlermock.h>
 #include <blocksectionmock.h>
 #include <thread>
@@ -27,6 +29,7 @@
 // TODO: Remove this
 #include "blocks/variableblocks.h"
 #include "blocks/listblocks.h"
+#include "blocks/eventblocks.h"
 
 using namespace libscratchcpp;
 
@@ -1936,24 +1939,64 @@ TEST(EngineTest, EdgeActivatedHats)
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
-    ASSERT_VAR(stage, "test");
-    auto var = GET_VAR(stage, "test");
-    ASSERT_EQ(var->value().toInt(), 0);
+    ASSERT_VAR(stage, "test1");
+    auto var1 = GET_VAR(stage, "test1");
+    ASSERT_VAR(stage, "test2");
+    auto var2 = GET_VAR(stage, "test2");
+
+    ASSERT_EQ(var1->value().toInt(), 0);
+    ASSERT_EQ(var2->value().toInt(), 0);
 
     TimerMock timer;
+    AudioInputMock audioInput;
     engine->setTimer(&timer);
+    EventBlocks::audioInput = &audioInput;
+    auto audioLoudness = std::make_shared<AudioLoudnessMock>();
+    EXPECT_CALL(audioInput, audioLoudness()).WillRepeatedly(Return(audioLoudness));
 
     EXPECT_CALL(timer, value()).WillOnce(Return(5));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(1));
     engine->step();
-    ASSERT_EQ(var->value().toInt(), 0);
+    ASSERT_EQ(var1->value().toInt(), 0);
+    ASSERT_EQ(var2->value().toInt(), 0);
 
     EXPECT_CALL(timer, value()).WillOnce(Return(10));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(9));
     engine->step();
-    ASSERT_EQ(var->value().toInt(), 0);
+    ASSERT_EQ(var1->value().toInt(), 0);
+    ASSERT_EQ(var2->value().toInt(), 1);
 
     EXPECT_CALL(timer, value()).WillOnce(Return(10.2));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(10));
+    engine->step();
+    ASSERT_EQ(var1->value().toInt(), 1);
+    ASSERT_EQ(var2->value().toInt(), 1);
+
+    EXPECT_CALL(timer, value()).WillOnce(Return(15));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(2));
     engine->step();
-    ASSERT_EQ(var->value().toInt(), 1);
+    ASSERT_EQ(var1->value().toInt(), 1);
+    ASSERT_EQ(var2->value().toInt(), 1);
+
+    EXPECT_CALL(timer, value()).WillOnce(Return(12));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(8));
+    engine->step();
+    ASSERT_EQ(var1->value().toInt(), 1);
+    ASSERT_EQ(var2->value().toInt(), 2);
+
+    EXPECT_CALL(timer, value()).WillOnce(Return(8));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(3));
+    engine->step();
+    ASSERT_EQ(var1->value().toInt(), 1);
+    ASSERT_EQ(var2->value().toInt(), 2);
+
+    EXPECT_CALL(timer, value()).WillOnce(Return(11));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(15));
+    engine->step();
+    ASSERT_EQ(var1->value().toInt(), 2);
+    ASSERT_EQ(var2->value().toInt(), 3);
+
+    EventBlocks::audioInput = nullptr;
 }
 
 TEST(EngineTest, UserAgent)