From 961b9580720dcb4565144553a08df4668f9347f6 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 8 Apr 2024 15:20:22 +0200
Subject: [PATCH 01/71] Set version to 0.10.0

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d9a8456..66a900c7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.14)
 
-project(libscratchcpp VERSION 0.9.0 LANGUAGES C CXX)
+project(libscratchcpp VERSION 0.10.0 LANGUAGES C CXX)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_CXX_STANDARD 17)

From cd85b4430cf5038e691be6962872d55a319e451e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 10 Apr 2024 07:56:47 +0200
Subject: [PATCH 02/71] fix #535: Do not delete audio decoder in cloned sounds

---
 src/audio/internal/audioplayer.cpp | 9 +++++++--
 src/audio/internal/audioplayer.h   | 1 +
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/audio/internal/audioplayer.cpp b/src/audio/internal/audioplayer.cpp
index 9cab04ba..e7cc03a5 100644
--- a/src/audio/internal/audioplayer.cpp
+++ b/src/audio/internal/audioplayer.cpp
@@ -18,11 +18,15 @@ AudioPlayer::~AudioPlayer()
 {
     if (m_loaded) {
         ma_sound_uninit(m_sound);
-        ma_decoder_uninit(m_decoder);
+
+        if (!m_copy)
+            ma_decoder_uninit(m_decoder);
     }
 
-    delete m_decoder;
     delete m_sound;
+
+    if (!m_copy)
+        delete m_decoder;
 }
 
 bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sampleRate)
@@ -74,6 +78,7 @@ bool AudioPlayer::loadCopy(IAudioPlayer *player)
     }
 
     m_loaded = true;
+    m_copy = true;
     ma_sound_set_volume(m_sound, m_volume);
     return true;
 }
diff --git a/src/audio/internal/audioplayer.h b/src/audio/internal/audioplayer.h
index 854691ae..8dd77b54 100644
--- a/src/audio/internal/audioplayer.h
+++ b/src/audio/internal/audioplayer.h
@@ -33,6 +33,7 @@ class AudioPlayer : public IAudioPlayer
         ma_decoder *m_decoder = nullptr;
         ma_sound *m_sound;
         bool m_loaded = false;
+        bool m_copy = false;
         bool m_started = false;
         float m_volume = 1;
 };

From cede35175efef171c42d3e8666129b9ff1fe39e9 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 11 Apr 2024 15:36:48 +0200
Subject: [PATCH 03/71] fix #524: Convert strings to lowercase in string
 contains

Closes #524
---
 src/engine/virtualmachine_p.cpp               | 10 +++++--
 test/virtual_machine/virtual_machine_test.cpp | 29 ++++++++++---------
 2 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/engine/virtualmachine_p.cpp b/src/engine/virtualmachine_p.cpp
index b9a99521..50397788 100644
--- a/src/engine/virtualmachine_p.cpp
+++ b/src/engine/virtualmachine_p.cpp
@@ -764,8 +764,14 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     DISPATCH();
 
     OP(STR_CONTAINS) :
-        REPLACE_RET_VALUE(READ_REG(0, 2)->toUtf16().find(READ_REG(1, 2)->toUtf16()) != std::u16string::npos, 2);
-    FREE_REGS(1);
+    {
+        std::u16string string1 = READ_REG(0, 2)->toUtf16();
+        std::u16string string2 = READ_REG(1, 2)->toUtf16();
+        std::transform(string1.begin(), string1.end(), string1.begin(), ::tolower);
+        std::transform(string2.begin(), string2.end(), string2.begin(), ::tolower);
+        REPLACE_RET_VALUE(string1.find(string2) != std::u16string::npos, 2);
+        FREE_REGS(1);
+    }
     DISPATCH();
 
     OP(EXEC) :
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index 30ea6dbb..3a91c12c 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -1359,25 +1359,28 @@ TEST(VirtualMachineTest, OP_STR_LENGTH)
 TEST(VirtualMachineTest, OP_STR_CONTAINS)
 {
     static unsigned int bytecode[] = {
-        OP_START,        OP_CONST, 0, OP_CONST, 1, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 2, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 3,
-        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 4, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 5, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 6,
-        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 7, OP_STR_CONTAINS, OP_CONST, 4, OP_CONST, 4, OP_STR_CONTAINS, OP_HALT
+        OP_START,        OP_CONST, 0, OP_CONST, 1, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 2, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 3,  OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 4,
+        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 5, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 6, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 7,  OP_STR_CONTAINS, OP_CONST, 4, OP_CONST, 4,
+        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 8, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 9, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 10, OP_STR_CONTAINS, OP_HALT
     };
-    static Value constValues[] = { "abcd efg  hijý abcĎĐ", "ĎĐ", "a", "test", "", " ", "  ", "k" };
+    static Value constValues[] = { "abcd efg  hijý abcĎĐ", "ĎĐ", "a", "test", "", " ", "  ", "k", "ab", "aB", "AB" };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
     vm.setConstValues(constValues);
     vm.run();
-    ASSERT_EQ(vm.registerCount(), 8);
-    ASSERT_EQ(vm.getInput(0, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(1, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(2, 8)->toBool(), false);
-    ASSERT_EQ(vm.getInput(3, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(4, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(5, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(6, 8)->toBool(), false);
-    ASSERT_EQ(vm.getInput(7, 8)->toBool(), true);
+    ASSERT_EQ(vm.registerCount(), 11);
+    ASSERT_EQ(vm.getInput(0, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(1, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(2, 11)->toBool(), false);
+    ASSERT_EQ(vm.getInput(3, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(4, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(5, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(6, 11)->toBool(), false);
+    ASSERT_EQ(vm.getInput(7, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(8, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(9, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(10, 11)->toBool(), true);
 }
 
 unsigned int testFunction1(VirtualMachine *vm)

From d41aad0491abb569c1e6fe8c859885b666bc6486 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 11 Apr 2024 18:10:55 +0200
Subject: [PATCH 04/71] fix #434: Round mouse pointer position

Closes #434
---
 src/engine/internal/engine.cpp |  4 ++--
 test/engine/engine_test.cpp    | 12 +++++++++---
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index d2923948..220d5e22 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -778,7 +778,7 @@ double Engine::mouseX() const
 
 void Engine::setMouseX(double x)
 {
-    m_mouseX = x;
+    m_mouseX = std::round(x);
 }
 
 double Engine::mouseY() const
@@ -788,7 +788,7 @@ double Engine::mouseY() const
 
 void Engine::setMouseY(double y)
 {
-    m_mouseY = y;
+    m_mouseY = std::round(y);
 }
 
 bool Engine::mousePressed() const
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 5b8b6f96..198678bc 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -827,7 +827,10 @@ TEST(EngineTest, MouseX)
     ASSERT_EQ(engine.mouseX(), 0);
 
     engine.setMouseX(-128.038);
-    ASSERT_EQ(engine.mouseX(), -128.038);
+    ASSERT_EQ(engine.mouseX(), -128);
+
+    engine.setMouseX(35.7);
+    ASSERT_EQ(engine.mouseX(), 36);
 }
 
 TEST(EngineTest, MouseY)
@@ -835,8 +838,11 @@ TEST(EngineTest, MouseY)
     Engine engine;
     ASSERT_EQ(engine.mouseY(), 0);
 
-    engine.setMouseY(179.9258);
-    ASSERT_EQ(engine.mouseY(), 179.9258);
+    engine.setMouseY(179.1258);
+    ASSERT_EQ(engine.mouseY(), 179);
+
+    engine.setMouseY(-12.98);
+    ASSERT_EQ(engine.mouseY(), -13);
 }
 
 TEST(EngineTest, MousePressed)

From 8836ab117d08181145d3f1387fd50dbf65c411aa Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 13 Apr 2024 16:17:36 +0200
Subject: [PATCH 05/71] Make sounds aware of target

---
 include/scratchcpp/sound.h           |  4 ++++
 src/scratch/sound.cpp                | 12 ++++++++++++
 src/scratch/sound_p.h                |  3 +++
 src/scratch/target.cpp               |  4 +++-
 test/assets/sound_test.cpp           | 11 +++++++++++
 test/scratch_classes/target_test.cpp |  4 ++++
 6 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/sound.h b/include/scratchcpp/sound.h
index 4185ade0..c07ee6a9 100644
--- a/include/scratchcpp/sound.h
+++ b/include/scratchcpp/sound.h
@@ -9,6 +9,7 @@
 namespace libscratchcpp
 {
 
+class Target;
 class SoundPrivate;
 
 /*! \brief The Sound class represents a Scratch sound. */
@@ -32,6 +33,9 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
 
         virtual bool isPlaying();
 
+        Target *target() const;
+        void setTarget(Target *target);
+
         std::shared_ptr<Sound> clone() const;
 
     protected:
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index 295626b2..f3a2bfa2 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -62,6 +62,18 @@ bool Sound::isPlaying()
     return impl->player->isPlaying();
 }
 
+/*! Returns the sprite or stage this variable belongs to. */
+Target *Sound::target() const
+{
+    return impl->target;
+}
+
+/*! Sets the sprite or stage this variable belongs to. */
+void Sound::setTarget(Target *target)
+{
+    impl->target = target;
+}
+
 /*! Returns an independent copy of the sound which is valid for as long as the original sound exists. */
 std::shared_ptr<Sound> Sound::clone() const
 {
diff --git a/src/scratch/sound_p.h b/src/scratch/sound_p.h
index 082b05fd..68cbe980 100644
--- a/src/scratch/sound_p.h
+++ b/src/scratch/sound_p.h
@@ -10,6 +10,8 @@
 namespace libscratchcpp
 {
 
+class Target;
+
 struct SoundPrivate
 {
         SoundPrivate();
@@ -19,6 +21,7 @@ struct SoundPrivate
         int sampleCount = 0;
         static IAudioOutput *audioOutput;
         std::shared_ptr<IAudioPlayer> player = nullptr;
+        Target *target = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 14a6f337..651d373b 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -344,8 +344,10 @@ int Target::addSound(std::shared_ptr<Sound> sound)
 
     assert(sound);
 
-    if (sound)
+    if (sound) {
+        sound->setTarget(this);
         sound->setVolume(impl->volume);
+    }
 
     impl->sounds.push_back(sound);
     return impl->sounds.size() - 1;
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index 3cd80665..e197e930 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/sound.h>
+#include <scratchcpp/target.h>
 #include <scratch/sound_p.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
@@ -106,6 +107,16 @@ TEST_F(SoundTest, IsPlaying)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST_F(SoundTest, Target)
+{
+    Sound sound("sound1", "a", "wav");
+    ASSERT_EQ(sound.target(), nullptr);
+
+    Target target;
+    sound.setTarget(&target);
+    ASSERT_EQ(sound.target(), &target);
+}
+
 TEST_F(SoundTest, Clone)
 {
     Sound sound("sound1", "a", "wav");
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 7c521da5..ca9dea89 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -442,6 +442,10 @@ TEST(TargetTest, Sounds)
     ASSERT_EQ(target.findSound("sound2"), 1);
     ASSERT_EQ(target.findSound("sound3"), 2);
 
+    ASSERT_EQ(s1->target(), &target);
+    ASSERT_EQ(s2->target(), &target);
+    ASSERT_EQ(s3->target(), &target);
+
     SoundPrivate::audioOutput = nullptr;
 }
 

From 4ec3f1faae24e5f6a3f21129c979be4869ee0125 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 13 Apr 2024 23:24:03 +0200
Subject: [PATCH 06/71] fix #538: Fix sound clones not stopping

---
 include/scratchcpp/sound.h        |  2 +
 src/engine/internal/engine.cpp    |  7 +---
 src/scratch/sound.cpp             | 32 ++++++++++++++++
 test/assets/sound_test.cpp        | 61 +++++++++++++++++++++++++------
 test/blocks/sound_blocks_test.cpp |  8 ++--
 test/engine/engine_test.cpp       |  4 +-
 6 files changed, 92 insertions(+), 22 deletions(-)

diff --git a/include/scratchcpp/sound.h b/include/scratchcpp/sound.h
index c07ee6a9..382ea007 100644
--- a/include/scratchcpp/sound.h
+++ b/include/scratchcpp/sound.h
@@ -42,6 +42,8 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
         void processData(unsigned int size, void *data) override;
 
     private:
+        void stopCloneSounds();
+
         spimpl::unique_impl_ptr<SoundPrivate> impl;
 };
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 220d5e22..e8e92db4 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -459,14 +459,11 @@ void Engine::deinitClone(std::shared_ptr<Sprite> clone)
 
 void Engine::stopSounds()
 {
-    // TODO: Loop through clones
     for (auto target : m_targets) {
         const auto &sounds = target->sounds();
 
-        for (auto sound : sounds) {
-            if (sound->isPlaying())
-                sound->stop();
-        }
+        for (auto sound : sounds)
+            sound->stop();
     }
 }
 
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index f3a2bfa2..53772e90 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/sound.h>
+#include <scratchcpp/sprite.h>
 #include <iostream>
 
 #include "sound_p.h"
@@ -47,12 +48,16 @@ void Sound::setVolume(double volume)
 /*! Starts the playback of the sound. */
 void Sound::start()
 {
+    // Stop sounds in clones (#538)
+    stopCloneSounds();
     impl->player->start();
 }
 
 /*! Stops the playback of the sound. */
 void Sound::stop()
 {
+    // Stop sounds in clones (#538)
+    stopCloneSounds();
     impl->player->stop();
 }
 
@@ -95,3 +100,30 @@ void Sound::processData(unsigned int size, void *data)
     if (!impl->player->load(size, data, impl->rate))
         std::cerr << "Failed to load sound " << name() << std::endl;
 }
+
+void Sound::stopCloneSounds()
+{
+    if (impl->target && !impl->target->isStage()) {
+        Sprite *sprite = static_cast<Sprite *>(impl->target);
+
+        if (sprite->isClone())
+            sprite = sprite->cloneSprite();
+
+        // Stop the sound in the sprite (clone root)
+        auto sound = sprite->soundAt(sprite->findSound(name()));
+
+        if (sound && sound.get() != this)
+            sound->impl->player->stop();
+
+        // Stop the sound in clones
+        const auto &clones = sprite->clones();
+
+        for (auto clone : clones) {
+            auto sound = clone->soundAt(clone->findSound(name()));
+            assert(sound);
+
+            if (sound && sound.get() != this)
+                sound->impl->player->stop();
+        }
+    }
+}
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index e197e930..7f7e9d44 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -1,8 +1,9 @@
 #include <scratchcpp/sound.h>
-#include <scratchcpp/target.h>
+#include <scratchcpp/sprite.h>
 #include <scratch/sound_p.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <enginemock.h>
 
 #include "../common.h"
 
@@ -119,16 +120,16 @@ TEST_F(SoundTest, Target)
 
 TEST_F(SoundTest, Clone)
 {
-    Sound sound("sound1", "a", "wav");
-    sound.setRate(44100);
-    sound.setSampleCount(10000);
+    auto sound = std::make_shared<Sound>("sound1", "a", "wav");
+    sound->setRate(44100);
+    sound->setSampleCount(10000);
 
     const char *data = "abc";
     void *dataPtr = const_cast<void *>(static_cast<const void *>(data));
 
     EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
     EXPECT_CALL(*m_player, load(3, dataPtr, 44100)).WillOnce(Return(true));
-    sound.setData(3, dataPtr);
+    sound->setData(3, dataPtr);
 
     auto clonePlayer = std::make_shared<AudioPlayerMock>();
     EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(clonePlayer));
@@ -136,11 +137,49 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.45));
     EXPECT_CALL(*clonePlayer, setVolume(0.45));
     EXPECT_CALL(*clonePlayer, isLoaded()).WillOnce(Return(true));
-    auto clone = sound.clone();
+    auto clone = sound->clone();
     ASSERT_TRUE(clone);
-    ASSERT_EQ(clone->name(), sound.name());
-    ASSERT_EQ(clone->id(), sound.id());
-    ASSERT_EQ(clone->dataFormat(), sound.dataFormat());
-    ASSERT_EQ(clone->rate(), sound.rate());
-    ASSERT_EQ(clone->sampleCount(), sound.sampleCount());
+    ASSERT_EQ(clone->name(), sound->name());
+    ASSERT_EQ(clone->id(), sound->id());
+    ASSERT_EQ(clone->dataFormat(), sound->dataFormat());
+    ASSERT_EQ(clone->rate(), sound->rate());
+    ASSERT_EQ(clone->sampleCount(), sound->sampleCount());
+
+    // Stopping/starting the sound should stop its clones
+    auto anotherPlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(anotherPlayer));
+    auto another = std::make_shared<Sound>("another", "c", "mp3");
+    Sprite sprite;
+    EngineMock engine;
+    sprite.setEngine(&engine);
+
+    EXPECT_CALL(engine, cloneLimit()).WillOnce(Return(-1));
+    EXPECT_CALL(engine, initClone);
+    EXPECT_CALL(engine, requestRedraw);
+    EXPECT_CALL(engine, moveSpriteBehindOther);
+    auto spriteClone = sprite.clone();
+
+    EXPECT_CALL(*anotherPlayer, setVolume).Times(2);
+    EXPECT_CALL(*m_player, setVolume);
+    EXPECT_CALL(*clonePlayer, setVolume);
+    sprite.addSound(another);
+    sprite.addSound(sound);
+    spriteClone->addSound(another);
+    spriteClone->addSound(clone);
+
+    EXPECT_CALL(*m_player, stop());
+    EXPECT_CALL(*clonePlayer, stop());
+    sound->stop();
+
+    EXPECT_CALL(*m_player, stop());
+    EXPECT_CALL(*clonePlayer, stop());
+    clone->stop();
+
+    EXPECT_CALL(*m_player, start());
+    EXPECT_CALL(*clonePlayer, stop());
+    sound->start();
+
+    EXPECT_CALL(*m_player, stop());
+    EXPECT_CALL(*clonePlayer, start());
+    clone->start();
 }
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index c5b2b366..77fef23b 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -2,12 +2,12 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
-#include <scratchcpp/target.h>
 #include <scratchcpp/sound.h>
 #include <scratch/sound_p.h>
 #include <enginemock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <targetmock.h>
 
 #include "../common.h"
 #include "blocks/soundblocks.h"
@@ -212,7 +212,8 @@ TEST_F(SoundBlocksTest, PlayImpl)
     EXPECT_CALL(*player1, setVolume);
     EXPECT_CALL(*player2, setVolume);
     EXPECT_CALL(*player3, setVolume);
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, isStage()).WillRepeatedly(Return(true));
     target.addSound(std::make_shared<Sound>("some sound", "", ""));
     target.addSound(std::make_shared<Sound>("test", "", ""));
     target.addSound(std::make_shared<Sound>("another sound", "", ""));
@@ -412,7 +413,8 @@ TEST_F(SoundBlocksTest, PlayUntilDoneImpl)
     EXPECT_CALL(*player1, setVolume);
     EXPECT_CALL(*player2, setVolume);
     EXPECT_CALL(*player3, setVolume);
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, isStage()).WillRepeatedly(Return(true));
     target.addSound(std::make_shared<Sound>("some sound", "", ""));
     target.addSound(std::make_shared<Sound>("test", "", ""));
     target.addSound(std::make_shared<Sound>("another sound", "", ""));
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 198678bc..0481f8cd 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -275,9 +275,7 @@ TEST(EngineTest, StopSounds)
 
     auto engine = p.engine();
 
-    EXPECT_CALL(*player1, isPlaying()).WillOnce(Return(false));
-    EXPECT_CALL(*player2, isPlaying()).WillOnce(Return(true));
-    EXPECT_CALL(*player3, isPlaying()).WillOnce(Return(true));
+    EXPECT_CALL(*player1, stop());
     EXPECT_CALL(*player2, stop());
     EXPECT_CALL(*player3, stop());
     engine->stopSounds();

From 0ee4164676119f3c42c145c2c71249b731815225 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 14 Apr 2024 14:52:24 +0200
Subject: [PATCH 07/71] Add minimal build test workflow

---
 .github/workflows/utests-minimal.yml | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 .github/workflows/utests-minimal.yml

diff --git a/.github/workflows/utests-minimal.yml b/.github/workflows/utests-minimal.yml
new file mode 100644
index 00000000..00e02639
--- /dev/null
+++ b/.github/workflows/utests-minimal.yml
@@ -0,0 +1,28 @@
+name: Unit tests (minimal build)
+
+on:
+  push:
+    branches: '*'
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+
+    - name: Configure CMake
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DLIBSCRATCHCPP_BUILD_UNIT_TESTS=ON -DLIBSCRATCHCPP_AUDIO_SUPPORT=OFF -DLIBSCRATCHCPP_NETWORK_SUPPORT=OFF -DLIBSCRATCHCPP_COMPUTED_GOTO=OFF
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j$(nproc --all)
+
+    - name: Run unit tests
+      run: ctest --test-dir build -V

From 3200f4bb09b20912314510db35534e0b1f3f34af Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 14 Apr 2024 16:40:45 +0200
Subject: [PATCH 08/71] Link compiler test against nlohmann_json

---
 test/compiler/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/compiler/CMakeLists.txt b/test/compiler/CMakeLists.txt
index 867f0265..9dd42696 100644
--- a/test/compiler/CMakeLists.txt
+++ b/test/compiler/CMakeLists.txt
@@ -9,6 +9,7 @@ target_link_libraries(
   compiler_test
   GTest::gtest_main
   scratchcpp
+  nlohmann_json::nlohmann_json
 )
 
 gtest_discover_tests(compiler_test)

From 809951690905be46cd7e8b5ce48762cf7ba9a863 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 15 Apr 2024 09:16:46 +0200
Subject: [PATCH 09/71] Add project stopped signal

---
 include/scratchcpp/iengine.h   |  3 ++
 src/engine/internal/engine.cpp |  7 ++++
 src/engine/internal/engine.h   |  2 +
 test/engine/engine_test.cpp    | 67 ++++++++++++++++++++++++++--------
 test/mocks/enginemock.h        |  1 +
 5 files changed, 64 insertions(+), 16 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 88e95521..105b9f27 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -116,6 +116,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Emits when a script is about to stop. */
         virtual sigslot::signal<VirtualMachine *> &threadAboutToStop() = 0;
 
+        /*! Emits when the project is stopped by calling stop(). */
+        virtual sigslot::signal<> &stopped() = 0;
+
         /*! Returns true if the project is currently running. */
         virtual bool isRunning() const = 0;
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index e8e92db4..a370a68e 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -383,6 +383,8 @@ void Engine::stop()
         m_threads.clear();
         m_running = false;
     }
+
+    m_stopped();
 }
 
 VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
@@ -565,6 +567,11 @@ sigslot::signal<VirtualMachine *> &Engine::threadAboutToStop()
     return m_threadAboutToStop;
 }
 
+sigslot::signal<> &Engine::stopped()
+{
+    return m_stopped;
+}
+
 std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L70-L173
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 69b05dd6..76319ac0 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -51,6 +51,7 @@ class Engine : public IEngine
 
         sigslot::signal<> &aboutToRender() override;
         sigslot::signal<VirtualMachine *> &threadAboutToStop() override;
+        sigslot::signal<> &stopped() override;
 
         bool isRunning() const override;
 
@@ -268,6 +269,7 @@ class Engine : public IEngine
         bool m_redrawRequested = false;
         sigslot::signal<> m_aboutToRedraw;
         sigslot::signal<VirtualMachine *> m_threadAboutToStop;
+        sigslot::signal<> m_stopped;
         bool m_stopEventLoop = false;
         std::mutex m_stopEventLoopMutex;
 
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 0481f8cd..0454da9d 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -47,10 +47,11 @@ class RedrawMock
         MOCK_METHOD(void, redraw, ());
 };
 
-class ThreadAboutToStopMock
+class StopMock
 {
     public:
         MOCK_METHOD(void, threadRemoved, (VirtualMachine *));
+        MOCK_METHOD(void, stopped, ());
 };
 
 class AddRemoveMonitorMock
@@ -124,13 +125,13 @@ TEST(EngineTest, ClearThreadAboutToStopSignal)
     engine->start();
     engine->step();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     engine->clear();
 }
 
@@ -143,16 +144,50 @@ TEST(EngineTest, StopThreadAboutToStopSignal)
     engine->start();
     engine->step();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     engine->stop();
 }
 
+TEST(EngineTest, StopSignal)
+{
+    StopMock stopMock;
+
+    {
+        Project p("3_threads.sb3");
+        ASSERT_TRUE(p.load());
+        auto engine = p.engine();
+
+        engine->stopped().connect(&StopMock::stopped, &stopMock);
+        EXPECT_CALL(stopMock, stopped());
+        engine->start();
+        engine->step();
+
+        EXPECT_CALL(stopMock, stopped());
+        engine->stop();
+    }
+
+    {
+        Project p("stop_all_bypass.sb3");
+        ASSERT_TRUE(p.load());
+        auto engine = p.engine();
+
+        engine->stopped().connect(&StopMock::stopped, &stopMock);
+        EXPECT_CALL(stopMock, stopped());
+        engine->start();
+        EXPECT_CALL(stopMock, stopped());
+        engine->step();
+
+        EXPECT_CALL(stopMock, stopped());
+        engine->stop();
+    }
+}
+
 TEST(EngineTest, CompileAndExecuteMonitors)
 {
     Engine engine;
@@ -1894,13 +1929,13 @@ TEST(EngineTest, BroadcastsProject)
 
     auto engine = p.engine();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     engine->setFps(1000);
     p.run();
 
@@ -1942,13 +1977,13 @@ TEST(EngineTest, StopAllBypass)
 
     auto engine = p.engine();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     p.run();
 
     Stage *stage = engine->stage();
@@ -1970,13 +2005,13 @@ TEST(EngineTest, StopOtherScriptsInSprite)
 
     auto engine = p.engine();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     p.run();
 
     Stage *stage = engine->stage();
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 1a3d67ee..7992ef08 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -34,6 +34,7 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(sigslot::signal<> &, aboutToRender, (), (override));
         MOCK_METHOD(sigslot::signal<VirtualMachine *> &, threadAboutToStop, (), (override));
+        MOCK_METHOD(sigslot::signal<> &, stopped, (), (override));
 
         MOCK_METHOD(bool, isRunning, (), (const, override));
 

From bba47fcd52bc343ee8fa502d4b6625b95a470c80 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 15 Apr 2024 09:29:34 +0200
Subject: [PATCH 10/71] Add missing clocale include to Value

---
 include/scratchcpp/value.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/scratchcpp/value.h b/include/scratchcpp/value.h
index fa53716a..ebde5d1c 100644
--- a/include/scratchcpp/value.h
+++ b/include/scratchcpp/value.h
@@ -10,6 +10,7 @@
 #include <iomanip>
 #include <utf8.h>
 #include <iostream>
+#include <clocale>
 
 #include "global.h"
 

From 9f8f75c7431a3856e55121e9eb691a32ea4ead84 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 15 Apr 2024 14:36:08 +0200
Subject: [PATCH 11/71] Add IAudioEngine interface with volume methods

---
 src/audio/CMakeLists.txt               |  3 +++
 src/audio/iaudioengine.h               | 21 +++++++++++++++++
 src/audio/internal/audioengine.cpp     | 30 +++++++++++++++++++++----
 src/audio/internal/audioengine.h       | 16 ++++++++++---
 src/audio/internal/audioenginestub.cpp | 26 +++++++++++++++++++++
 src/audio/internal/audioenginestub.h   | 24 ++++++++++++++++++++
 src/audio/internal/audioplayer.cpp     |  1 +
 test/audio/CMakeLists.txt              | 18 +++++++++++++++
 test/audio/audioengine_test.cpp        | 31 ++++++++++++++++++++++++++
 test/mocks/audioenginemock.h           | 13 +++++++++++
 10 files changed, 176 insertions(+), 7 deletions(-)
 create mode 100644 src/audio/iaudioengine.h
 create mode 100644 src/audio/internal/audioenginestub.cpp
 create mode 100644 src/audio/internal/audioenginestub.h
 create mode 100644 test/audio/audioengine_test.cpp
 create mode 100644 test/mocks/audioenginemock.h

diff --git a/src/audio/CMakeLists.txt b/src/audio/CMakeLists.txt
index 5bf4e0b3..536c266b 100644
--- a/src/audio/CMakeLists.txt
+++ b/src/audio/CMakeLists.txt
@@ -15,6 +15,7 @@ endif()
 
 target_sources(scratchcpp-audio
   PUBLIC
+    iaudioengine.h
     iaudioplayer.h
     iaudiooutput.h
     audiooutput.cpp
@@ -38,6 +39,8 @@ if (LIBSCRATCHCPP_AUDIO_SUPPORT)
 else()
     target_sources(scratchcpp-audio
       PUBLIC
+        internal/audioenginestub.cpp
+        internal/audioenginestub.h
         internal/audioplayerstub.cpp
         internal/audioplayerstub.h
         internal/audioloudnessstub.cpp
diff --git a/src/audio/iaudioengine.h b/src/audio/iaudioengine.h
new file mode 100644
index 00000000..8100334b
--- /dev/null
+++ b/src/audio/iaudioengine.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+namespace libscratchcpp
+{
+
+class IAudioEngine
+{
+    public:
+        virtual ~IAudioEngine() { }
+
+        static IAudioEngine *instance();
+
+        virtual float volume() const = 0;
+        virtual void setVolume(float volume) = 0;
+};
+
+} // namespace libscratchcpp
diff --git a/src/audio/internal/audioengine.cpp b/src/audio/internal/audioengine.cpp
index 710a394e..1af3874d 100644
--- a/src/audio/internal/audioengine.cpp
+++ b/src/audio/internal/audioengine.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <iostream>
+#include <miniaudio.h>
 
 #include "audioengine.h"
 
@@ -8,12 +9,17 @@ using namespace libscratchcpp;
 
 AudioEngine AudioEngine::instance;
 
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngine::instance;
+}
+
 ma_engine *AudioEngine::engine()
 {
     if (!instance.m_initialized)
         instance.init();
 
-    return instance.m_initialized ? &instance.m_engine : nullptr;
+    return instance.m_initialized ? instance.m_engine : nullptr;
 }
 
 bool AudioEngine::initialized()
@@ -24,20 +30,36 @@ bool AudioEngine::initialized()
     return instance.m_initialized;
 }
 
+float AudioEngine::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngine::setVolume(float volume)
+{
+    m_volume = volume;
+
+    if (m_initialized)
+        ma_engine_set_volume(m_engine, volume);
+}
+
 AudioEngine::AudioEngine()
 {
 }
 
 AudioEngine::~AudioEngine()
 {
-    if (m_initialized)
-        ma_engine_uninit(&m_engine);
+    if (m_initialized && m_engine) {
+        ma_engine_uninit(m_engine);
+        delete m_engine;
+    }
 }
 
 void AudioEngine::init()
 {
     ma_result result;
-    result = ma_engine_init(NULL, &m_engine);
+    m_engine = new ma_engine;
+    result = ma_engine_init(NULL, m_engine);
 
     if (result != MA_SUCCESS) {
         std::cerr << "Failed to initialize audio engine." << std::endl;
diff --git a/src/audio/internal/audioengine.h b/src/audio/internal/audioengine.h
index 49097871..02672ff3 100644
--- a/src/audio/internal/audioengine.h
+++ b/src/audio/internal/audioengine.h
@@ -3,18 +3,26 @@
 #pragma once
 
 #include <memory>
-#include <miniaudio.h>
+
+#include "../iaudioengine.h"
+
+struct ma_engine;
 
 namespace libscratchcpp
 {
 
 // This is a singleton which initializes and uninitializes the miniaudio engine
-class AudioEngine
+class AudioEngine : public IAudioEngine
 {
     public:
+        friend class IAudioEngine;
+
         static ma_engine *engine();
         static bool initialized();
 
+        float volume() const override;
+        void setVolume(float volume) override;
+
     private:
         AudioEngine();
         ~AudioEngine();
@@ -22,8 +30,10 @@ class AudioEngine
         void init();
 
         static AudioEngine instance;
-        ma_engine m_engine;
+
+        ma_engine *m_engine = nullptr;
         bool m_initialized = false;
+        float m_volume = 1.0f;
 };
 
 } // namespace libscratchcpp
diff --git a/src/audio/internal/audioenginestub.cpp b/src/audio/internal/audioenginestub.cpp
new file mode 100644
index 00000000..83b8bd45
--- /dev/null
+++ b/src/audio/internal/audioenginestub.cpp
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "audioenginestub.h"
+
+using namespace libscratchcpp;
+
+AudioEngineStub AudioEngineStub::instance;
+
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngineStub::instance;
+}
+
+AudioEngineStub::AudioEngineStub()
+{
+}
+
+float AudioEngineStub::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngineStub::setVolume(float volume)
+{
+    m_volume = volume;
+}
diff --git a/src/audio/internal/audioenginestub.h b/src/audio/internal/audioenginestub.h
new file mode 100644
index 00000000..e49e076c
--- /dev/null
+++ b/src/audio/internal/audioenginestub.h
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../iaudioengine.h"
+
+namespace libscratchcpp
+{
+
+class AudioEngineStub : public IAudioEngine
+{
+    public:
+        friend class IAudioEngine;
+        AudioEngineStub();
+
+        float volume() const override;
+        void setVolume(float volume) override;
+
+    private:
+        static AudioEngineStub instance;
+        float m_volume = 1.0f;
+};
+
+} // namespace libscratchcpp
diff --git a/src/audio/internal/audioplayer.cpp b/src/audio/internal/audioplayer.cpp
index e7cc03a5..4bb4922d 100644
--- a/src/audio/internal/audioplayer.cpp
+++ b/src/audio/internal/audioplayer.cpp
@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <cassert>
+#include <miniaudio.h>
 
 #include "audioplayer.h"
 #include "audioengine.h"
diff --git a/test/audio/CMakeLists.txt b/test/audio/CMakeLists.txt
index c4aba7b4..40897a6e 100644
--- a/test/audio/CMakeLists.txt
+++ b/test/audio/CMakeLists.txt
@@ -1,3 +1,21 @@
+# audioengine_test
+add_executable(
+  audioengine_test
+  audioengine_test.cpp
+)
+
+target_link_libraries(
+  audioengine_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(audioengine_test)
+
+if (LIBSCRATCHCPP_AUDIO_SUPPORT)
+    target_compile_definitions(audioengine_test PRIVATE LIBSCRATCHCPP_AUDIO_SUPPORT)
+endif()
+
 # audiooutput_test
 add_executable(
   audiooutput_test
diff --git a/test/audio/audioengine_test.cpp b/test/audio/audioengine_test.cpp
new file mode 100644
index 00000000..e0476858
--- /dev/null
+++ b/test/audio/audioengine_test.cpp
@@ -0,0 +1,31 @@
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+#include <audio/internal/audioengine.h>
+#else
+#include <audio/internal/audioenginestub.h>
+#endif
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(AudioEngineTest, Instance)
+{
+    IAudioEngine *instance = IAudioEngine::instance();
+    ASSERT_TRUE(instance);
+
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+    ASSERT_TRUE(dynamic_cast<AudioEngine *>(instance));
+#else
+    ASSERT_TRUE(dynamic_cast<AudioEngineStub *>(instance));
+#endif
+}
+
+TEST(AudioEngineTest, Volume)
+{
+    IAudioEngine *engine = IAudioEngine::instance();
+    ASSERT_TRUE(engine);
+    ASSERT_EQ(engine->volume(), 1.0f);
+
+    engine->setVolume(0.86f);
+    ASSERT_EQ(engine->volume(), 0.86f);
+}
diff --git a/test/mocks/audioenginemock.h b/test/mocks/audioenginemock.h
new file mode 100644
index 00000000..6d7c9003
--- /dev/null
+++ b/test/mocks/audioenginemock.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <audio/iaudioengine.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class AudioEngineMock : public IAudioEngine
+{
+    public:
+        MOCK_METHOD(float, volume, (), (const, override));
+        MOCK_METHOD(void, setVolume, (float), (override));
+};

From cdcc4677da2694bb3e303190bd58c15d8a3b6381 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 15 Apr 2024 14:36:25 +0200
Subject: [PATCH 12/71] Add global volume API

---
 include/scratchcpp/iengine.h   |  6 ++++++
 src/engine/internal/engine.cpp | 14 +++++++++++++-
 src/engine/internal/engine.h   |  5 +++++
 test/engine/engine_test.cpp    | 19 +++++++++++++++++++
 test/mocks/enginemock.h        |  3 +++
 5 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 105b9f27..8c0870b4 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -87,6 +87,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Stops all currently playing sounds. */
         virtual void stopSounds() = 0;
 
+        /*! Returns the global volume of all sounds (in %). */
+        virtual double globalVolume() const = 0;
+
+        /*! Sets the global volume of all sounds (in %). */
+        virtual void setGlobalVolume(double volume) = 0;
+
         /*! Updates the values of stage monitors. */
         virtual void updateMonitors() = 0;
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index a370a68e..4c06ac5d 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -26,6 +26,7 @@
 #include "blocksectioncontainer.h"
 #include "timer.h"
 #include "clock.h"
+#include "audio/iaudioengine.h"
 #include "blocks/standardblocks.h"
 #include "blocks/variableblocks.h"
 #include "blocks/listblocks.h"
@@ -46,7 +47,8 @@ const std::unordered_map<Engine::HatType, bool> Engine::m_hatEdgeActivated = {
 Engine::Engine() :
     m_defaultTimer(std::make_unique<Timer>()),
     m_timer(m_defaultTimer.get()),
-    m_clock(Clock::instance().get())
+    m_clock(Clock::instance().get()),
+    m_audioEngine(IAudioEngine::instance())
 {
 }
 
@@ -469,6 +471,16 @@ void Engine::stopSounds()
     }
 }
 
+double Engine::globalVolume() const
+{
+    return m_audioEngine->volume() * 100;
+}
+
+void Engine::setGlobalVolume(double volume)
+{
+    m_audioEngine->setVolume(volume / 100);
+}
+
 void Engine::updateMonitors()
 {
     // Execute the "script" of each visible monitor
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 76319ac0..348ee2d2 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -19,6 +19,7 @@ namespace libscratchcpp
 
 class Entity;
 class IClock;
+class IAudioEngine;
 
 class Engine : public IEngine
 {
@@ -41,7 +42,10 @@ class Engine : public IEngine
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
         void initClone(std::shared_ptr<Sprite> clone) override;
         void deinitClone(std::shared_ptr<Sprite> clone) override;
+
         void stopSounds() override;
+        virtual double globalVolume() const override;
+        virtual void setGlobalVolume(double volume) override;
 
         void updateMonitors() override;
         void step() override;
@@ -163,6 +167,7 @@ class Engine : public IEngine
         void setUserAgent(const std::string &agent) override;
 
         IClock *m_clock = nullptr;
+        IAudioEngine *m_audioEngine = nullptr;
 
     private:
         enum class HatType
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 0454da9d..31f1743e 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -14,6 +14,7 @@
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
+#include <audioenginemock.h>
 #include <audioinputmock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
@@ -318,6 +319,24 @@ TEST(EngineTest, StopSounds)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST(EngineTest, GlobalVolume)
+{
+    Engine engine;
+    ASSERT_EQ(engine.globalVolume(), 100);
+
+    engine.setGlobalVolume(58.3);
+    ASSERT_EQ(std::round(engine.globalVolume() * 100) / 100, 58.3);
+
+    AudioEngineMock audioEngine;
+    engine.m_audioEngine = &audioEngine;
+
+    EXPECT_CALL(audioEngine, volume()).WillOnce(Return(0.275));
+    ASSERT_EQ(engine.globalVolume(), 27.5);
+
+    EXPECT_CALL(audioEngine, setVolume(0.9236));
+    engine.setGlobalVolume(92.36);
+}
+
 TEST(EngineTest, Step)
 {
     Project p("step.sb3");
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 7992ef08..e844c540 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -24,7 +24,10 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
         MOCK_METHOD(void, initClone, (std::shared_ptr<Sprite>), (override));
         MOCK_METHOD(void, deinitClone, (std::shared_ptr<Sprite>), (override));
+
         MOCK_METHOD(void, stopSounds, (), (override));
+        MOCK_METHOD(double, globalVolume, (), (const, override));
+        MOCK_METHOD(void, setGlobalVolume, (double), (override));
 
         MOCK_METHOD(void, updateMonitors, (), (override));
         MOCK_METHOD(void, step, (), (override));

From f9ee2fc36c6ef353e895f8479546bda9032c339b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 18 Apr 2024 17:53:27 +0200
Subject: [PATCH 13/71] Add target parameter to Script::runHatPredicate()

---
 include/scratchcpp/script.h    |  2 +-
 src/engine/internal/engine.cpp |  2 +-
 src/engine/script.cpp          | 34 ++++++++++++++--------------------
 src/engine/script_p.h          |  2 --
 test/script/script_test.cpp    | 30 ++++++++++++++----------------
 5 files changed, 30 insertions(+), 40 deletions(-)

diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index fe3a44ee..b82aaf48 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -35,7 +35,7 @@ class LIBSCRATCHCPP_EXPORT Script
         void setBytecode(const std::vector<unsigned int> &code);
 
         void setHatPredicateBytecode(const std::vector<unsigned int> &code);
-        bool runHatPredicate();
+        bool runHatPredicate(Target *target);
 
         void setProcedures(const std::vector<unsigned int *> &procedures);
         void setConstValues(const std::vector<Value> &values);
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 4c06ac5d..8b436f09 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -531,7 +531,7 @@ void Engine::step()
                         oldValue = fieldIt->second;
                 }
 
-                bool newValue = thread->script()->runHatPredicate();
+                bool newValue = thread->script()->runHatPredicate(hatBlock->target());
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
                 m_edgeActivatedHatValues[hatType][fieldValueId] = newValue;
 
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index d544b5b8..edaf6e75 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -53,29 +53,26 @@ void Script::setBytecode(const std::vector<unsigned int> &code)
 void Script::setHatPredicateBytecode(const std::vector<unsigned int> &code)
 {
     impl->hatPredicateBytecodeVector = code;
-
-    if (impl->engine && !code.empty()) {
-        impl->hatPredicateVm = std::make_shared<VirtualMachine>(impl->engine->stage(), impl->engine, this);
-        impl->hatPredicateVm->setBytecode(impl->hatPredicateBytecodeVector.data());
-        impl->hatPredicateVm->setConstValues(impl->constValues);
-    }
 }
 
 /*!
- * Runs the edge-activated hat predicate and returns the reported value.
+ * Runs the edge-activated hat predicate as the given target and returns the reported value.
  * \note If there isn't any predicate, nothing will happen and the returned value will be false.
  */
-bool Script::runHatPredicate()
+bool Script::runHatPredicate(Target *target)
 {
-    if (impl->hatPredicateVm && impl->hatPredicateVm->bytecode()) {
-        impl->hatPredicateVm->reset();
-        impl->hatPredicateVm->setFunctions(getFunctions());
-        impl->hatPredicateVm->run();
-        assert(impl->hatPredicateVm->registerCount() == 1);
-
-        if (impl->hatPredicateVm->registerCount() == 1)
-            return impl->hatPredicateVm->getInput(0, 1)->toBool();
-    }
+    if (!target || !impl->engine || impl->hatPredicateBytecodeVector.empty())
+        return false;
+
+    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
+    vm->setBytecode(impl->hatPredicateBytecodeVector.data());
+    vm->setConstValues(impl->constValues);
+    vm->setFunctions(getFunctions());
+    vm->run();
+    assert(vm->registerCount() == 1);
+
+    if (vm->registerCount() == 1)
+        return vm->getInput(0, 1)->toBool();
 
     return false;
 }
@@ -161,9 +158,6 @@ void Script::setConstValues(const std::vector<Value> &values)
 {
     impl->constValuesVector = values;
     impl->constValues = impl->constValuesVector.data();
-
-    if (impl->hatPredicateVm)
-        impl->hatPredicateVm->setConstValues(impl->constValues);
 }
 
 /*! Sets the list of variables. */
diff --git a/src/engine/script_p.h b/src/engine/script_p.h
index d3f991a4..6d029160 100644
--- a/src/engine/script_p.h
+++ b/src/engine/script_p.h
@@ -22,9 +22,7 @@ struct ScriptPrivate
 
         unsigned int *bytecode = nullptr;
         std::vector<unsigned int> bytecodeVector;
-
         std::vector<unsigned int> hatPredicateBytecodeVector;
-        std::shared_ptr<VirtualMachine> hatPredicateVm;
 
         Target *target = nullptr;
         std::shared_ptr<Block> topBlock;
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 9f687d53..840680b7 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -42,22 +42,20 @@ TEST_F(ScriptTest, Bytecode)
     ASSERT_EQ(script.bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
 }
 
-static Target *stageTest = nullptr;
+static Target *targetTest = nullptr;
 static IEngine *engineTest = nullptr;
 static Script *scriptTest = nullptr;
 
 TEST_F(ScriptTest, HatPredicate)
 {
     Script script(&m_target, nullptr, &m_engine);
-    ASSERT_FALSE(script.runHatPredicate());
-
-    Stage stage;
-    EXPECT_CALL(m_engine, stage()).Times(3).WillRepeatedly(Return(&stage));
+    Target target;
+    ASSERT_FALSE(script.runHatPredicate(&target));
 
     BlockFunc f1 = [](VirtualMachine *vm) -> unsigned int {
         vm->addReturnValue(true);
         vm->stop(false, false, false);
-        stageTest = vm->target();
+        targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
         return 0;
@@ -68,7 +66,7 @@ TEST_F(ScriptTest, HatPredicate)
     BlockFunc f3 = [](VirtualMachine *vm) -> unsigned int {
         vm->addReturnValue(false);
         vm->stop(false, false, false);
-        stageTest = vm->target();
+        targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
         return 0;
@@ -78,38 +76,38 @@ TEST_F(ScriptTest, HatPredicate)
     std::vector<BlockFunc> functions2 = { f1, f2, f3 };
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions1));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setConstValues({ "test" });
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 0, vm::OP_HALT });
     testing::internal::CaptureStdout();
-    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_TRUE(script.runHatPredicate(&target));
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "test\n");
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 1, vm::OP_HALT });
     script.setConstValues({ 5 });
     testing::internal::CaptureStdout();
-    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_TRUE(script.runHatPredicate(&m_target));
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "5\n");
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(targetTest, &m_target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT });
-    ASSERT_FALSE(script.runHatPredicate());
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_FALSE(script.runHatPredicate(&target));
+    ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 }

From 53bec00b3e7a7a25051e31bb5d2715008fbb2291 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 18 Apr 2024 18:00:53 +0200
Subject: [PATCH 14/71] Fix edge-activated hats without fields

---
 src/engine/internal/engine.cpp | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 8b436f09..892fe0f7 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -516,9 +516,16 @@ void Engine::step()
                 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);
+
+                // TODO: Edge-activated hats currently support only one field
+                // If there isn't any field, -1 is used as the field value ID
+                int fieldValueId = -1;
+
+                if (hatBlock->fieldAt(0)) {
+                    fieldValueId = hatBlock->fieldAt(0)->specialValueId();
+                    assert(fieldValueId != -1);
+                }
+
                 auto it = m_edgeActivatedHatValues.find(hatType);
 
                 if (it == m_edgeActivatedHatValues.cend()) {

From fe061a5809cac842388ebf8225cacc3a0239303e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 18 Apr 2024 18:05:12 +0200
Subject: [PATCH 15/71] Store edge-activated hats by target

---
 src/engine/internal/engine.cpp | 21 +++++++++++++++------
 src/engine/internal/engine.h   |  3 ++-
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 892fe0f7..d6818fb7 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -526,21 +526,30 @@ void Engine::step()
                     assert(fieldValueId != -1);
                 }
 
+                Target *target = hatBlock->target();
+                assert(target);
                 auto it = m_edgeActivatedHatValues.find(hatType);
 
                 if (it == m_edgeActivatedHatValues.cend()) {
-                    m_edgeActivatedHatValues[hatType] = {};
+                    m_edgeActivatedHatValues[hatType] = { { target, {} } };
                 } else {
-                    const std::unordered_map<int, bool> &values = it->second;
-                    auto fieldIt = values.find(fieldValueId);
+                    auto &map = it->second;
+                    auto it = map.find(target);
 
-                    if (fieldIt != values.cend())
-                        oldValue = fieldIt->second;
+                    if (it == map.cend())
+                        map[target] = {};
+                    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(hatBlock->target());
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
-                m_edgeActivatedHatValues[hatType][fieldValueId] = newValue;
+                m_edgeActivatedHatValues[hatType][target][fieldValueId] = newValue;
 
                 if (!edgeWasActivated)
                     stopThread(thread.get());
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 348ee2d2..8bb6a65c 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -252,7 +252,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, 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::unordered_map<HatType, std::unordered_map<Target *, std::unordered_map<int, bool>>> m_edgeActivatedHatValues; // (target, field value ID, 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;

From a663b7b3360cdc95cf4bdeb43a429c639c55b666 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 18 Apr 2024 18:45:11 +0200
Subject: [PATCH 16/71] Add API for the when touching object block

---
 include/scratchcpp/iengine.h   |  3 +++
 src/engine/internal/engine.cpp | 17 +++++++++++++----
 src/engine/internal/engine.h   |  3 +++
 test/mocks/enginemock.h        |  1 +
 4 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 8c0870b4..b392be8d 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -297,6 +297,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the index of the broadcast with the given ID. */
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
+        /* Registers the given "when touching object" script. */
+        virtual void addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Registers the "green flag" script. */
         virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index d6818fb7..ac3cea22 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -35,13 +35,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::WhenGreaterThan, false }
+    { HatType::WhenTouchingObject, false }, { 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::WhenGreaterThan, true }
+    { HatType::WhenTouchingObject, true }, { 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,7 @@ void Engine::clear()
     m_scripts.clear();
     m_functions.clear();
 
+    m_whenTouchingObjectHats.clear();
     m_greenFlagHats.clear();
     m_backdropChangeHats.clear();
     m_broadcastHats.clear();
@@ -1096,6 +1097,11 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
         return it - m_broadcasts.begin();
 }
 
+void Engine::addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock)
+{
+    addHatToMap(m_whenTouchingObjectHats, m_scripts[hatBlock].get());
+}
+
 void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
 {
     addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
@@ -1527,6 +1533,9 @@ const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
     }
 
     switch (type) {
+        case HatType::WhenTouchingObject:
+            return m_whenTouchingObjectHats[target];
+
         case HatType::GreenFlag:
             return m_greenFlagHats[target];
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 8bb6a65c..a666f07d 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -126,6 +126,7 @@ class Engine : public IEngine
         int findBroadcast(const std::string &broadcastName) const override;
         int findBroadcastById(const std::string &broadcastId) const override;
 
+        void addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock) override;
         void addGreenFlagScript(std::shared_ptr<Block> hatBlock) override;
         void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast) override;
         void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
@@ -172,6 +173,7 @@ class Engine : public IEngine
     private:
         enum class HatType
         {
+            WhenTouchingObject,
             GreenFlag,
             BroadcastReceived,
             BackdropChanged,
@@ -242,6 +244,7 @@ class Engine : public IEngine
         std::recursive_mutex m_eventLoopMutex;
         std::string m_userAgent;
 
+        std::unordered_map<Target *, std::vector<Script *>> m_whenTouchingObjectHats;
         std::unordered_map<Target *, std::vector<Script *>> m_greenFlagHats;
         std::unordered_map<Target *, std::vector<Script *>> m_backdropChangeHats;
         std::unordered_map<Target *, std::vector<Script *>> m_broadcastHats;
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index e844c540..48fc505b 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -106,6 +106,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(int, findBroadcast, (const std::string &), (const, override));
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, override));
 
+        MOCK_METHOD(void, addWhenTouchingObjectScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addGreenFlagScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, int, Broadcast *), (override));
         MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>, int), (override));

From 2a4876a45d6b55cd55c43c78b7af41b12a557ee2 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 18 Apr 2024 18:45:52 +0200
Subject: [PATCH 17/71] Implement event_whentouchingobject block

---
 src/blocks/eventblocks.cpp        |  45 ++++++++
 src/blocks/eventblocks.h          |   5 +
 test/blocks/event_blocks_test.cpp | 173 ++++++++++++++++++++++++++++++
 3 files changed, 223 insertions(+)

diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 282437c6..470ceafc 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -6,6 +6,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/block.h>
@@ -27,6 +28,7 @@ std::string EventBlocks::name() const
 void EventBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
+    engine->addCompileFunction(this, "event_whentouchingobject", &compileWhenTouchingObject);
     engine->addCompileFunction(this, "event_whenflagclicked", &compileWhenFlagClicked);
     engine->addCompileFunction(this, "event_whenthisspriteclicked", &compileWhenThisSpriteClicked);
     engine->addCompileFunction(this, "event_whenstageclicked", &compileWhenStageClicked);
@@ -38,9 +40,11 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_whenkeypressed", &compileWhenKeyPressed);
 
     // Hat predicates
+    engine->addHatPredicateCompileFunction(this, "event_whentouchingobject", &compileWhenTouchingObjectPredicate);
     engine->addHatPredicateCompileFunction(this, "event_whengreaterthan", &compileWhenGreaterThanPredicate);
 
     // Inputs
+    engine->addInput(this, "TOUCHINGOBJECTMENU", TOUCHINGOBJECTMENU);
     engine->addInput(this, "BROADCAST_INPUT", BROADCAST_INPUT);
     engine->addInput(this, "VALUE", VALUE);
 
@@ -55,6 +59,27 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addFieldValue(this, "TIMER", Timer);
 }
 
+void EventBlocks::compileWhenTouchingObjectPredicate(Compiler *compiler)
+{
+    Input *input = compiler->input(TOUCHINGOBJECTMENU);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string value = input->selectedMenuItem();
+
+        compiler->addConstValue(value);
+        compiler->addFunctionCall(&whenTouchingObjectPredicate);
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&whenTouchingObjectPredicate);
+    }
+}
+
+void EventBlocks::compileWhenTouchingObject(Compiler *compiler)
+{
+    compiler->engine()->addWhenTouchingObjectScript(compiler->block());
+}
+
 void EventBlocks::compileWhenFlagClicked(Compiler *compiler)
 {
     compiler->engine()->addGreenFlagScript(compiler->block());
@@ -151,6 +176,26 @@ void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
     compiler->engine()->addKeyPressScript(compiler->block(), KEY_OPTION);
 }
 
+unsigned int EventBlocks::whenTouchingObjectPredicate(VirtualMachine *vm)
+{
+    std::string value = vm->getInput(0, 1)->toString();
+
+    if (value == "_mouse_")
+        vm->replaceReturnValue(vm->target()->touchingPoint(vm->engine()->mouseX(), vm->engine()->mouseY()), 1);
+    else if (value == "_edge_")
+        vm->replaceReturnValue(vm->target()->touchingEdge(), 1);
+    else {
+        Target *target = vm->engine()->targetAt(vm->engine()->findTarget(value));
+
+        if (target && !target->isStage())
+            vm->replaceReturnValue(vm->target()->touchingSprite(static_cast<Sprite *>(target)), 1);
+        else
+            vm->replaceReturnValue(false, 1);
+    }
+
+    return 0;
+}
+
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
     vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index 49479da7..0c5e5fd6 100644
--- a/src/blocks/eventblocks.h
+++ b/src/blocks/eventblocks.h
@@ -17,6 +17,7 @@ class EventBlocks : public IBlockSection
     public:
         enum Inputs
         {
+            TOUCHINGOBJECTMENU,
             BROADCAST_INPUT,
             VALUE
         };
@@ -39,6 +40,8 @@ class EventBlocks : public IBlockSection
 
         void registerBlocks(IEngine *engine) override;
 
+        static void compileWhenTouchingObjectPredicate(Compiler *compiler);
+        static void compileWhenTouchingObject(Compiler *compiler);
         static void compileWhenFlagClicked(Compiler *compiler);
         static void compileWhenThisSpriteClicked(Compiler *compiler);
         static void compileWhenStageClicked(Compiler *compiler);
@@ -50,6 +53,8 @@ class EventBlocks : public IBlockSection
         static void compileWhenGreaterThan(Compiler *compiler);
         static void compileWhenKeyPressed(Compiler *compiler);
 
+        static unsigned int whenTouchingObjectPredicate(VirtualMachine *vm);
+
         static unsigned int broadcast(VirtualMachine *vm);
         static unsigned int broadcastByIndex(VirtualMachine *vm);
         static unsigned int broadcastAndWait(VirtualMachine *vm);
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 8b2be2e8..144b5113 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -4,12 +4,14 @@
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/broadcast.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/costume.h>
 #include <enginemock.h>
 #include <audioinputmock.h>
 #include <audioloudnessmock.h>
 #include <timermock.h>
+#include <targetmock.h>
 
 #include "../common.h"
 #include "blocks/eventblocks.h"
@@ -35,6 +37,15 @@ class EventBlocksTest : public testing::Test
         // For any event block
         std::shared_ptr<Block> createEventBlock(const std::string &id, const std::string &opcode) const { return std::make_shared<Block>(id, opcode); }
 
+        std::shared_ptr<Block> createNullBlock(const std::string &id)
+        {
+            std::shared_ptr<Block> block = std::make_shared<Block>(id, "");
+            BlockComp func = [](Compiler *compiler) { compiler->addInstruction(vm::OP_NULL); };
+            block->setCompileFunction(func);
+
+            return block;
+        }
+
         void addBroadcastInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id, std::shared_ptr<Broadcast> broadcast) const
         {
             auto input = std::make_shared<Input>(name, Input::Type::Shadow);
@@ -45,6 +56,15 @@ class EventBlocksTest : public testing::Test
             block->addInput(input);
         }
 
+        std::shared_ptr<Input> addNullInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::Shadow);
+            input->setInputId(id);
+            block->addInput(input);
+
+            return input;
+        }
+
         void addValueInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id, const Value &value) const
         {
             auto input = std::make_shared<Input>(name, Input::Type::Shadow);
@@ -61,6 +81,26 @@ class EventBlocksTest : public testing::Test
             block->addInput(input);
         }
 
+        void addDropdownInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id, const std::string &selectedValue, std::shared_ptr<Block> valueBlock = nullptr) const
+        {
+            if (valueBlock)
+                addObscuredInput(block, name, id, valueBlock);
+            else {
+                auto input = addNullInput(block, name, id);
+                auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                input->setValueBlock(menu);
+                addDropdownField(menu, name, static_cast<EventBlocks::Fields>(-1), selectedValue, static_cast<EventBlocks::FieldValues>(-1));
+            }
+        }
+
+        void addDropdownField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, const std::string &value, EventBlocks::FieldValues valueId) const
+        {
+            auto field = std::make_shared<Field>(name, value);
+            field->setFieldId(id);
+            field->setSpecialValueId(valueId);
+            block->addField(field);
+        }
+
         void addValueField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, const std::string &value, int valueId = -1) const
         {
             auto field = std::make_shared<Field>(name, value);
@@ -95,6 +135,7 @@ TEST_F(EventBlocksTest, CategoryVisible)
 TEST_F(EventBlocksTest, RegisterBlocks)
 {
     // Blocks
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whentouchingobject", &EventBlocks::compileWhenTouchingObject));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenflagclicked", &EventBlocks::compileWhenFlagClicked));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenthisspriteclicked", &EventBlocks::compileWhenThisSpriteClicked));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenstageclicked", &EventBlocks::compileWhenStageClicked));
@@ -106,9 +147,11 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenkeypressed", &EventBlocks::compileWhenKeyPressed));
 
     // Hat predicates
+    EXPECT_CALL(m_engineMock, addHatPredicateCompileFunction(m_section.get(), "event_whentouchingobject", &EventBlocks::compileWhenTouchingObjectPredicate));
     EXPECT_CALL(m_engineMock, addHatPredicateCompileFunction(m_section.get(), "event_whengreaterthan", &EventBlocks::compileWhenGreaterThanPredicate));
 
     // Inputs
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", EventBlocks::VALUE));
 
@@ -125,6 +168,136 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     m_section->registerBlocks(&m_engineMock);
 }
 
+TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
+{
+    Compiler compiler(&m_engineMock);
+
+    // when touching (Sprite1)
+    auto block1 = createEventBlock("a", "event_whentouchingobject");
+    addDropdownInput(block1, "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU, "Sprite1");
+
+    // when touching (null block)
+    auto block2 = createEventBlock("b", "event_whentouchingobject");
+    addDropdownInput(block2, "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU, "", createNullBlock("e"));
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::whenTouchingObjectPredicate)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    EventBlocks::compileWhenTouchingObjectPredicate(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::whenTouchingObjectPredicate)).WillOnce(Return(0));
+    compiler.setBlock(block2);
+    EventBlocks::compileWhenTouchingObjectPredicate(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0], "Sprite1");
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(EventBlocksTest, WhenTouchingObjectPredicateImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &EventBlocks::whenTouchingObjectPredicate };
+    static Value constValues[] = { "Sprite2", "_mouse_", "_edge_", "", 1, -1, 2 };
+
+    TargetMock target;
+    target.setEngine(&m_engineMock);
+    Sprite sprite;
+    VirtualMachine vm(&target, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    // touching "Sprite2"
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, targetAt(3)).WillOnce(Return(&sprite));
+    EXPECT_CALL(target, touchingClones).WillOnce(Return(false));
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, targetAt(3)).WillOnce(Return(&sprite));
+    EXPECT_CALL(target, touchingClones).WillOnce(Return(true));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    // touching "_mouse_"
+    EXPECT_CALL(m_engineMock, mouseX()).WillOnce(Return(24.5));
+    EXPECT_CALL(m_engineMock, mouseY()).WillOnce(Return(-16.04));
+    EXPECT_CALL(target, touchingPoint(24.5, -16.04)).WillOnce(Return(true));
+    vm.setBytecode(bytecode2);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    // touching "_edge_"
+    EXPECT_CALL(m_engineMock, stageWidth()).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, stageHeight()).WillOnce(Return(0));
+    EXPECT_CALL(target, boundingRect()).WillOnce(Return(Rect(-5, 5, 5, -5)));
+    vm.setBytecode(bytecode3);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(m_engineMock, stageWidth()).WillOnce(Return(10));
+    EXPECT_CALL(m_engineMock, stageHeight()).WillOnce(Return(10));
+    EXPECT_CALL(target, boundingRect()).WillOnce(Return(Rect(-5, 5, 5, -5)));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    // touching ""
+    EXPECT_CALL(m_engineMock, findTarget("")).WillOnce(Return(-1));
+    EXPECT_CALL(m_engineMock, targetAt(-1)).WillOnce(Return(nullptr));
+    vm.setBytecode(bytecode4);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+}
+
+TEST_F(EventBlocksTest, WhenTouchingObject)
+{
+    Compiler compiler(&m_engineMock);
+
+    // when touching (Sprite1)
+    auto block = createEventBlock("a", "event_whentouchingobject");
+    addDropdownInput(block, "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU, "Sprite1");
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, addWhenTouchingObjectScript(block));
+    compiler.setBlock(block);
+    EventBlocks::compileWhenTouchingObject(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
 TEST_F(EventBlocksTest, WhenFlagClicked)
 {
     Compiler compiler(&m_engineMock);

From 985ebff39e04d62120fe4add971878ae01f7e75c Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 20 Apr 2024 12:33:23 +0200
Subject: [PATCH 18/71] fix #545: Add variables and lists to edge-activated
 hats

---
 src/engine/script.cpp       |  2 ++
 test/script/script_test.cpp | 26 ++++++++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index edaf6e75..2dfd39a7 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -68,6 +68,8 @@ bool Script::runHatPredicate(Target *target)
     vm->setBytecode(impl->hatPredicateBytecodeVector.data());
     vm->setConstValues(impl->constValues);
     vm->setFunctions(getFunctions());
+    vm->setVariables(impl->variableValues.data());
+    vm->setLists(impl->lists.data());
     vm->run();
     assert(vm->registerCount() == 1);
 
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 840680b7..7faf3c49 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -45,6 +45,8 @@ TEST_F(ScriptTest, Bytecode)
 static Target *targetTest = nullptr;
 static IEngine *engineTest = nullptr;
 static Script *scriptTest = nullptr;
+static Value **variablesTest = nullptr;
+static List **listsTest = nullptr;
 
 TEST_F(ScriptTest, HatPredicate)
 {
@@ -58,6 +60,8 @@ TEST_F(ScriptTest, HatPredicate)
         targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
+        variablesTest = vm->variables();
+        listsTest = vm->lists();
         return 0;
     };
 
@@ -69,16 +73,28 @@ TEST_F(ScriptTest, HatPredicate)
         targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
+        variablesTest = vm->variables();
+        listsTest = vm->lists();
         return 0;
     };
 
     std::vector<BlockFunc> functions1 = { f1 };
     std::vector<BlockFunc> functions2 = { f1, f2, f3 };
 
+    Variable var1("", "var1", "a");
+    Variable var2("", "var2", 4);
+    script.setVariables({ &var1, &var2 });
+
+    List list1("", "list1");
+    List list2("", "list2");
+    script.setLists({ &list1, &list2 });
+
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions1));
     targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
+    variablesTest = nullptr;
+    listsTest = nullptr;
     script.setConstValues({ "test" });
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 0, vm::OP_HALT });
     testing::internal::CaptureStdout();
@@ -87,11 +103,19 @@ TEST_F(ScriptTest, HatPredicate)
     ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
+    ASSERT_TRUE(variablesTest);
+    ASSERT_EQ(variablesTest[0], var1.valuePtr());
+    ASSERT_EQ(variablesTest[1], var2.valuePtr());
+    ASSERT_TRUE(listsTest);
+    ASSERT_EQ(listsTest[0], &list1);
+    ASSERT_EQ(listsTest[1], &list2);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
     targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
+    variablesTest = nullptr;
+    listsTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 1, vm::OP_HALT });
     script.setConstValues({ 5 });
     testing::internal::CaptureStdout();
@@ -105,6 +129,8 @@ TEST_F(ScriptTest, HatPredicate)
     targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
+    variablesTest = nullptr;
+    listsTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT });
     ASSERT_FALSE(script.runHatPredicate(&target));
     ASSERT_EQ(targetTest, &target);

From 9c80d41dd5d7407b1504739c5aadeac8e3b65a14 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 20 Apr 2024 12:39:14 +0200
Subject: [PATCH 19/71] Store edge-activated hat values by block and target

---
 src/engine/internal/engine.cpp | 26 +++++---------------------
 src/engine/internal/engine.h   |  3 +--
 2 files changed, 6 insertions(+), 23 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index ac3cea22..a8c0cfeb 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -518,39 +518,23 @@ void Engine::step()
                 auto hatBlock = thread->script()->topBlock();
                 assert(hatBlock);
 
-                // TODO: Edge-activated hats currently support only one field
-                // If there isn't any field, -1 is used as the field value ID
-                int fieldValueId = -1;
-
-                if (hatBlock->fieldAt(0)) {
-                    fieldValueId = hatBlock->fieldAt(0)->specialValueId();
-                    assert(fieldValueId != -1);
-                }
-
                 Target *target = hatBlock->target();
                 assert(target);
-                auto it = m_edgeActivatedHatValues.find(hatType);
+                auto it = m_edgeActivatedHatValues.find(hatBlock.get());
 
                 if (it == m_edgeActivatedHatValues.cend()) {
-                    m_edgeActivatedHatValues[hatType] = { { target, {} } };
+                    m_edgeActivatedHatValues[hatBlock.get()] = {};
                 } else {
                     auto &map = it->second;
                     auto it = map.find(target);
 
-                    if (it == map.cend())
-                        map[target] = {};
-                    else {
-                        const std::unordered_map<int, bool> &values = it->second;
-                        auto fieldIt = values.find(fieldValueId);
-
-                        if (fieldIt != values.cend())
-                            oldValue = fieldIt->second;
-                    }
+                    if (it != map.cend())
+                        oldValue = it->second;
                 }
 
                 bool newValue = thread->script()->runHatPredicate(hatBlock->target());
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
-                m_edgeActivatedHatValues[hatType][target][fieldValueId] = newValue;
+                m_edgeActivatedHatValues[hatBlock.get()][target] = newValue;
 
                 if (!edgeWasActivated)
                     stopThread(thread.get());
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index a666f07d..f359bdf3 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -255,8 +255,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, std::unordered_map<Target *, std::unordered_map<int, bool>>> m_edgeActivatedHatValues; // (target, field value ID, last value) edge-activated hats only run after
-                                                                                                                           // the value changes from false to true
+        std::unordered_map<Block *, std::unordered_map<Target *, bool>> m_edgeActivatedHatValues; // (block, target, 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;

From c9d1802b41dce5e42587852ea2cac82f774d719e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 20 Apr 2024 13:31:58 +0200
Subject: [PATCH 20/71] Add methods for costume width and height

---
 include/scratchcpp/ispritehandler.h  |  6 ++++++
 include/scratchcpp/istagehandler.h   |  6 ++++++
 include/scratchcpp/sprite.h          |  3 +++
 include/scratchcpp/stage.h           |  3 +++
 include/scratchcpp/target.h          |  2 ++
 src/scratch/sprite.cpp               | 18 ++++++++++++++++++
 src/scratch/stage.cpp                | 18 ++++++++++++++++++
 src/scratch/target.cpp               | 12 ++++++++++++
 test/mocks/spritehandlermock.h       |  3 +++
 test/mocks/stagehandlermock.h        |  3 +++
 test/mocks/targetmock.h              |  4 ++++
 test/scratch_classes/sprite_test.cpp | 22 ++++++++++++++++++++++
 test/scratch_classes/stage_test.cpp  | 22 ++++++++++++++++++++++
 test/scratch_classes/target_test.cpp | 12 ++++++++++++
 14 files changed, 134 insertions(+)

diff --git a/include/scratchcpp/ispritehandler.h b/include/scratchcpp/ispritehandler.h
index 35173c03..9bfb4307 100644
--- a/include/scratchcpp/ispritehandler.h
+++ b/include/scratchcpp/ispritehandler.h
@@ -65,6 +65,12 @@ class LIBSCRATCHCPP_EXPORT ISpriteHandler
         /*! Called when the bubble text changes. */
         virtual void onBubbleTextChanged(const std::string &text) = 0;
 
+        /*! Used to get the current costume width. */
+        virtual int costumeWidth() const = 0;
+
+        /*! Used to get the current costume height. */
+        virtual int costumeHeight() const = 0;
+
         /*!
          * Used to get the bounding rectangle of the sprite.
          * \note The rectangle must be relative to the stage, so make sure to use the sprite's coordinates.
diff --git a/include/scratchcpp/istagehandler.h b/include/scratchcpp/istagehandler.h
index 31b3c7f3..0b397e17 100644
--- a/include/scratchcpp/istagehandler.h
+++ b/include/scratchcpp/istagehandler.h
@@ -46,6 +46,12 @@ class LIBSCRATCHCPP_EXPORT IStageHandler
         /*! Called when the bubble text changes. */
         virtual void onBubbleTextChanged(const std::string &text) = 0;
 
+        /*! Used to get the current costume width. */
+        virtual int costumeWidth() const = 0;
+
+        /*! Used to get the current costume height. */
+        virtual int costumeHeight() const = 0;
+
         /*! Used to get the bounding rectangle of the stage. */
         virtual Rect boundingRect() const = 0;
 
diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index 97805772..328c6371 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -59,6 +59,9 @@ class LIBSCRATCHCPP_EXPORT Sprite
 
         void setCostumeIndex(int newCostumeIndex) override;
 
+        int currentCostumeWidth() const override;
+        int currentCostumeHeight() const override;
+
         double direction() const;
         void setDirection(double newDirection);
 
diff --git a/include/scratchcpp/stage.h b/include/scratchcpp/stage.h
index 5c6b1564..0d37c862 100644
--- a/include/scratchcpp/stage.h
+++ b/include/scratchcpp/stage.h
@@ -33,6 +33,9 @@ class LIBSCRATCHCPP_EXPORT Stage : public Target
 
         void setCostumeIndex(int newCostumeIndex) override;
 
+        int currentCostumeWidth() const override;
+        int currentCostumeHeight() const override;
+
         int tempo() const;
         void setTempo(int newTempo);
 
diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 8007bf31..5083275d 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -69,6 +69,8 @@ class LIBSCRATCHCPP_EXPORT Target
         virtual void setCostumeIndex(int newCostumeIndex);
 
         std::shared_ptr<Costume> currentCostume() const;
+        virtual int currentCostumeWidth() const;
+        virtual int currentCostumeHeight() const;
 
         const std::vector<std::shared_ptr<Costume>> &costumes() const;
         int addCostume(std::shared_ptr<Costume> costume);
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 8e9845fa..83370bfe 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -288,6 +288,24 @@ void Sprite::setCostumeIndex(int newCostumeIndex)
         impl->iface->onCostumeChanged(costume.get());
 }
 
+/*! Overrides Target#currentCostumeWidth(). */
+int Sprite::currentCostumeWidth() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeWidth();
+}
+
+/*! Overrides Target#currentCostumeHeight(). */
+int Sprite::currentCostumeHeight() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeHeight();
+}
+
 /*! Returns the direction. */
 double Sprite::direction() const
 {
diff --git a/src/scratch/stage.cpp b/src/scratch/stage.cpp
index a632570e..d798451e 100644
--- a/src/scratch/stage.cpp
+++ b/src/scratch/stage.cpp
@@ -46,6 +46,24 @@ void Stage::setCostumeIndex(int newCostumeIndex)
         impl->iface->onCostumeChanged(costume.get());
 }
 
+/*! Overrides Target#currentCostumeWidth(). */
+int Stage::currentCostumeWidth() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeWidth();
+}
+
+/*! Overrides Target#currentCostumeHeight(). */
+int Stage::currentCostumeHeight() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeHeight();
+}
+
 /*! Returns the tempo. */
 int Stage::tempo() const
 {
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 651d373b..99559fe7 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -278,6 +278,18 @@ std::shared_ptr<Costume> Target::currentCostume() const
     return costumeAt(impl->costumeIndex);
 }
 
+/*! Returns the width of the current costume. */
+int Target::currentCostumeWidth() const
+{
+    return 0;
+}
+
+/*! Returns the height of the current costume. */
+int Target::currentCostumeHeight() const
+{
+    return 0;
+}
+
 /*! Returns the list of costumes. */
 const std::vector<std::shared_ptr<Costume>> &Target::costumes() const
 {
diff --git a/test/mocks/spritehandlermock.h b/test/mocks/spritehandlermock.h
index 14bb30f8..d944f807 100644
--- a/test/mocks/spritehandlermock.h
+++ b/test/mocks/spritehandlermock.h
@@ -29,6 +29,9 @@ class SpriteHandlerMock : public ISpriteHandler
         MOCK_METHOD(void, onBubbleTypeChanged, (Target::BubbleType), (override));
         MOCK_METHOD(void, onBubbleTextChanged, (const std::string &), (override));
 
+        MOCK_METHOD(int, costumeWidth, (), (const, override));
+        MOCK_METHOD(int, costumeHeight, (), (const, override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/mocks/stagehandlermock.h b/test/mocks/stagehandlermock.h
index a060ac3d..a7e15055 100644
--- a/test/mocks/stagehandlermock.h
+++ b/test/mocks/stagehandlermock.h
@@ -20,6 +20,9 @@ class StageHandlerMock : public IStageHandler
         MOCK_METHOD(void, onBubbleTypeChanged, (Target::BubbleType), (override));
         MOCK_METHOD(void, onBubbleTextChanged, (const std::string &), (override));
 
+        MOCK_METHOD(int, costumeWidth, (), (const, override));
+        MOCK_METHOD(int, costumeHeight, (), (const, override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 2ca5140d..169048d4 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -11,6 +11,10 @@ class TargetMock : public Target
         MOCK_METHOD(bool, isStage, (), (const, override));
 
         MOCK_METHOD(void, setCostumeIndex, (int), (override));
+
+        MOCK_METHOD(int, currentCostumeWidth, (), (const, override));
+        MOCK_METHOD(int, currentCostumeHeight, (), (const, override));
+
         MOCK_METHOD(void, setLayerOrder, (int), (override));
 
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index c2f11ed9..74d59082 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -662,6 +662,28 @@ TEST(SpriteTest, KeepInFence)
     ASSERT_EQ(std::round(fencedY * 100) / 100, 150.9);
 }
 
+TEST(SpriteTest, CurrentCostumeWidth)
+{
+    Sprite sprite;
+    SpriteHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    sprite.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeWidth()).WillOnce(Return(46));
+    ASSERT_EQ(sprite.currentCostumeWidth(), 46);
+}
+
+TEST(SpriteTest, CurrentCostumeHeight)
+{
+    Sprite sprite;
+    SpriteHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    sprite.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeHeight()).WillOnce(Return(24));
+    ASSERT_EQ(sprite.currentCostumeHeight(), 24);
+}
+
 TEST(SpriteTest, DefaultBoundingRect)
 {
     Sprite sprite;
diff --git a/test/scratch_classes/stage_test.cpp b/test/scratch_classes/stage_test.cpp
index 4418d06f..78d3763b 100644
--- a/test/scratch_classes/stage_test.cpp
+++ b/test/scratch_classes/stage_test.cpp
@@ -137,6 +137,28 @@ TEST(StageTest, DefaultBoundingRect)
     ASSERT_EQ(rect.bottom(), 0);
 }
 
+TEST(StageTest, CurrentCostumeWidth)
+{
+    Stage stage;
+    StageHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    stage.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeWidth()).WillOnce(Return(46));
+    ASSERT_EQ(stage.currentCostumeWidth(), 46);
+}
+
+TEST(StageTest, CurrentCostumeHeight)
+{
+    Stage stage;
+    StageHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    stage.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeHeight()).WillOnce(Return(24));
+    ASSERT_EQ(stage.currentCostumeHeight(), 24);
+}
+
 TEST(StageTest, DefaultFastBoundingRect)
 {
     Stage stage;
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index ca9dea89..2cd7e330 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -511,6 +511,18 @@ TEST(TargetTest, Volume)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST(TargetTest, CurrentCostumeWidth)
+{
+    Target target;
+    ASSERT_EQ(target.currentCostumeWidth(), 0);
+}
+
+TEST(TargetTest, CurrentCostumeHeight)
+{
+    Target target;
+    ASSERT_EQ(target.currentCostumeHeight(), 0);
+}
+
 TEST(TargetTest, BoundingRect)
 {
     Target target;

From 5894adec3d8c288318b8a5fd85730c86a1142450 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 20 Apr 2024 13:45:40 +0200
Subject: [PATCH 21/71] Add sprite size limit

---
 src/scratch/sprite.cpp                        | 16 +++++++---
 test/scratch_classes/sprite_test.cpp          | 32 ++++++++++++++++---
 .../target_interfaces/ispritehandler_test.cpp | 14 +++++++-
 3 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 83370bfe..7697cee7 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -258,13 +258,21 @@ double Sprite::size() const
 /*! Sets the size. */
 void Sprite::setSize(double newSize)
 {
+    IEngine *engine = this->engine();
+
+    if (engine) {
+        const int oldWidth = currentCostumeWidth();
+        const int oldHeight = currentCostumeHeight();
+        const double minScale = std::min(1.0, std::max(5.0 / oldWidth, 5.0 / oldHeight));
+        const double maxScale = std::min((1.5 * engine->stageWidth()) / oldWidth, (1.5 * engine->stageHeight()) / oldHeight);
+        newSize = std::clamp(newSize, minScale * 100, maxScale * 100);
+    }
+
     impl->size = newSize;
 
     if (impl->visible) {
-        IEngine *eng = engine();
-
-        if (eng)
-            eng->requestRedraw();
+        if (engine)
+            engine->requestRedraw();
     }
 
     if (impl->iface)
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index 74d59082..ede233d3 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -448,21 +448,43 @@ TEST(SpriteTest, Dragging)
 TEST(SpriteTest, Size)
 {
     Sprite sprite;
+    SpriteHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    sprite.setInterface(&handler);
     ASSERT_EQ(sprite.size(), 100);
 
     EngineMock engine;
     sprite.setEngine(&engine);
-    EXPECT_CALL(engine, requestRedraw()).Times(4);
+    EXPECT_CALL(engine, requestRedraw()).WillRepeatedly(Return());
+    EXPECT_CALL(engine, stageWidth()).WillRepeatedly(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillRepeatedly(Return(360));
+    EXPECT_CALL(handler, onSizeChanged).WillRepeatedly(Return());
 
+    EXPECT_CALL(handler, costumeWidth()).WillRepeatedly(Return(50));
+    EXPECT_CALL(handler, costumeHeight()).WillRepeatedly(Return(30));
     sprite.setSize(63.724);
     ASSERT_EQ(sprite.size(), 63.724);
-
-    sprite.setCostumeIndex(1);
+    sprite.setSize(0);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 16.67);
+    sprite.setSize(2000);
+    ASSERT_EQ(sprite.size(), 1440);
+
+    EXPECT_CALL(handler, costumeWidth()).WillRepeatedly(Return(30));
+    EXPECT_CALL(handler, costumeHeight()).WillRepeatedly(Return(50));
+    sprite.setSize(0);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 16.67);
+    sprite.setSize(2000);
+    ASSERT_EQ(sprite.size(), 1080);
+
+    EXPECT_CALL(handler, costumeWidth()).WillRepeatedly(Return(88));
+    EXPECT_CALL(handler, costumeHeight()).WillRepeatedly(Return(88));
+    sprite.setSize(0);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 5.68);
+    sprite.setSize(2000);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 613.64);
 
     sprite.setSize(186.84);
     ASSERT_EQ(sprite.size(), 186.84);
-
-    sprite.setCostumeIndex(0);
 }
 
 TEST(SpriteTest, CostumeIndex)
diff --git a/test/target_interfaces/ispritehandler_test.cpp b/test/target_interfaces/ispritehandler_test.cpp
index f80772f1..752593e9 100644
--- a/test/target_interfaces/ispritehandler_test.cpp
+++ b/test/target_interfaces/ispritehandler_test.cpp
@@ -116,9 +116,21 @@ TEST_F(ISpriteHandlerTest, Position)
 
 TEST_F(ISpriteHandlerTest, Size)
 {
-    EXPECT_CALL(m_handler, onSizeChanged(53.8)).Times(1);
+    EXPECT_CALL(m_handler, onSizeChanged(53.8));
+    EXPECT_CALL(m_handler, costumeWidth()).WillOnce(Return(100));
+    EXPECT_CALL(m_handler, costumeHeight()).WillOnce(Return(100));
+    EXPECT_CALL(m_engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(m_engine, stageHeight()).WillOnce(Return(360));
     EXPECT_CALL(m_engine, requestRedraw());
     m_sprite.setSize(53.8);
+
+    EXPECT_CALL(m_handler, onSizeChanged(540));
+    EXPECT_CALL(m_handler, costumeWidth()).WillOnce(Return(100));
+    EXPECT_CALL(m_handler, costumeHeight()).WillOnce(Return(100));
+    EXPECT_CALL(m_engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(m_engine, stageHeight()).WillOnce(Return(360));
+    EXPECT_CALL(m_engine, requestRedraw());
+    m_sprite.setSize(100000);
 }
 
 TEST_F(ISpriteHandlerTest, Direction)

From 9f50e1d193de934ed0f8ce40d52506a96b763307 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 20 Apr 2024 16:07:21 +0200
Subject: [PATCH 22/71] fix #547: Always stop threads owned by clones

Closes #547
---
 src/engine/internal/engine.cpp                |  26 ++++++++++++++++--
 test/engine/engine_test.cpp                   |  17 ++++++++++++
 .../547_stop_clone_threads_in_stop_all.sb3    | Bin 0 -> 1760 bytes
 3 files changed, 40 insertions(+), 3 deletions(-)
 create mode 100644 test/regtest_projects/547_stop_clone_threads_in_stop_all.sb3

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index a8c0cfeb..39fa79e2 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -366,15 +366,33 @@ void Engine::start()
 void Engine::stop()
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L2057-L2081
-    deleteClones();
-    stopSounds();
-
     if (m_activeThread) {
         stopThread(m_activeThread.get());
         // NOTE: The project should continue running even after "stop all" is called and the remaining threads should be stepped once.
         // The remaining threads can even start new threads which will ignore the "stop all" call and will "restart" the project.
         // This is probably a bug in the Scratch VM, but let's keep it here to keep it compatible.
         m_threadsToStop = m_threads;
+
+        // Remove threads owned by clones because clones are going to be deleted (#547)
+        m_threads.erase(
+            std::remove_if(
+                m_threads.begin(),
+                m_threads.end(),
+                [](std::shared_ptr<VirtualMachine> thread) {
+                    assert(thread);
+                    Target *target = thread->target();
+                    assert(target);
+
+                    if (!target->isStage()) {
+                        Sprite *sprite = static_cast<Sprite *>(target);
+
+                        if (sprite->isClone())
+                            return true;
+                    }
+
+                    return false;
+                }),
+            m_threads.end());
     } else {
         // If there isn't any active thread, it means the project was stopped from the outside
         // In this case all threads should be removed and the project should be considered stopped
@@ -387,6 +405,8 @@ void Engine::stop()
         m_running = false;
     }
 
+    deleteClones();
+    stopSounds();
     m_stopped();
 }
 
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 31f1743e..9b8991f7 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -2303,3 +2303,20 @@ TEST(EngineTest, NoCrashWithUndefinedVariableOrList)
     ASSERT_EQ(list->id(), "}l+w#Er5y!:*gh~5!3t%");
     ASSERT_TRUE(list->empty());
 }
+
+TEST(EngineTest, AlwaysStopCloneThreads)
+{
+    // Regtest for #547
+    Project p("regtest_projects/547_stop_clone_threads_in_stop_all.sb3");
+    ASSERT_TRUE(p.load());
+
+    auto engine = p.engine();
+
+    Stage *stage = engine->stage();
+    ASSERT_TRUE(stage);
+
+    engine->run();
+
+    ASSERT_VAR(stage, "test");
+    ASSERT_EQ(GET_VAR(stage, "test")->value().toInt(), 0);
+}
diff --git a/test/regtest_projects/547_stop_clone_threads_in_stop_all.sb3 b/test/regtest_projects/547_stop_clone_threads_in_stop_all.sb3
new file mode 100644
index 0000000000000000000000000000000000000000..455831d15e942bd792eb2181f643340bb2f71e8c
GIT binary patch
literal 1760
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
B`}qI>

literal 0
HcmV?d00001


From e5ba5130e9e2e885a073ffe18504f740e2b9d8cc Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 29 Apr 2024 09:06:42 +0200
Subject: [PATCH 23/71] fix #548: Do not use OP_READ_VAR in sensing_of block

---
 src/blocks/sensingblocks.cpp        | 20 +++++++++++++--
 src/blocks/sensingblocks.h          |  1 +
 test/blocks/sensing_blocks_test.cpp | 38 ++++++++++++++++++++++-------
 3 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
index 722be78a..43f8303b 100644
--- a/src/blocks/sensingblocks.cpp
+++ b/src/blocks/sensingblocks.cpp
@@ -276,13 +276,16 @@ void SensingBlocks::compileOf(Compiler *compiler)
 
             default: {
                 // Variable
+                f = &variableOfTargetByIndex;
                 Target *target = engine->targetAt(index);
                 auto varIndex = target->findVariable(property->value().toString());
 
                 if (varIndex == -1)
                     compiler->addInstruction(vm::OP_NULL);
-                else
-                    compiler->addInstruction(vm::OP_READ_VAR, { compiler->variableIndex(target->variableAt(varIndex)) });
+                else {
+                    // NOTE: The OP_READ_VAR instruction can't be used for this (see #548)
+                    compiler->addConstValue(varIndex);
+                }
 
                 break;
             }
@@ -869,6 +872,19 @@ unsigned int SensingBlocks::variableOfTarget(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int SensingBlocks::variableOfTargetByIndex(VirtualMachine *vm)
+{
+    Target *target = vm->engine()->targetAt(vm->getInput(0, 1)->toInt());
+
+    if (target) {
+        const int varIndex = vm->getInput(0, 2)->toInt();
+        vm->replaceReturnValue(target->variableAt(varIndex)->value(), 2);
+    } else
+        vm->replaceReturnValue(0, 2);
+
+    return 1;
+}
+
 unsigned int SensingBlocks::backdropNumberOfStage(VirtualMachine *vm)
 {
     Target *target = vm->engine()->targetAt(vm->engine()->findTarget(vm->getInput(0, 1)->toString()));
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
index 032c0561..b00b20ce 100644
--- a/src/blocks/sensingblocks.h
+++ b/src/blocks/sensingblocks.h
@@ -131,6 +131,7 @@ class SensingBlocks : public IBlockSection
         static unsigned int volumeOfTarget(VirtualMachine *vm);
         static unsigned int volumeOfTargetByIndex(VirtualMachine *vm);
         static unsigned int variableOfTarget(VirtualMachine *vm);
+        static unsigned int variableOfTargetByIndex(VirtualMachine *vm);
         static unsigned int backdropNumberOfStage(VirtualMachine *vm);
         static unsigned int backdropNumberOfStageByIndex(VirtualMachine *vm);
         static unsigned int backdropNameOfStage(VirtualMachine *vm);
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
index 3ad92fae..f821f5ea 100644
--- a/test/blocks/sensing_blocks_test.cpp
+++ b/test/blocks/sensing_blocks_test.cpp
@@ -1356,8 +1356,8 @@ TEST_F(SensingBlocksTest, Of)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).Times(9).WillRepeatedly(Return(6));
-    EXPECT_CALL(m_engineMock, findTarget("_stage_")).Times(5).WillRepeatedly(Return(0));
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillRepeatedly(Return(6));
+    EXPECT_CALL(m_engineMock, findTarget("_stage_")).WillRepeatedly(Return(0));
 
     EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::xPositionOfSpriteByIndex)).WillOnce(Return(0));
     compiler.setBlock(block1);
@@ -1444,10 +1444,12 @@ TEST_F(SensingBlocksTest, Of)
     auto v2 = std::make_shared<Variable>("var2", "some variable");
     stage.addVariable(v1);
     stage.addVariable(v2);
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
     compiler.setBlock(block21);
     SensingBlocks::compileOf(&compiler);
 
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
     compiler.setBlock(block22);
     SensingBlocks::compileOf(&compiler);
@@ -1455,10 +1457,12 @@ TEST_F(SensingBlocksTest, Of)
     Sprite sprite;
     auto v3 = std::make_shared<Variable>("var3", "some variable");
     sprite.addVariable(v3);
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
     compiler.setBlock(block23);
     SensingBlocks::compileOf(&compiler);
 
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
     compiler.setBlock(block24);
     SensingBlocks::compileOf(&compiler);
@@ -1547,21 +1551,37 @@ TEST_F(SensingBlocksTest, Of)
               vm::OP_NULL,
               vm::OP_EXEC,
               17,
-              vm::OP_READ_VAR,
-              0,
+              vm::OP_CONST,
+              10,
+              vm::OP_CONST,
+              11,
+              vm::OP_EXEC,
+              19,
               vm::OP_NULL,
-              vm::OP_READ_VAR,
-              1,
+              vm::OP_CONST,
+              12,
+              vm::OP_EXEC,
+              19,
+              vm::OP_CONST,
+              13,
+              vm::OP_CONST,
+              14,
+              vm::OP_EXEC,
+              19,
               vm::OP_NULL,
               vm::OP_CONST,
-              10,
+              15,
+              vm::OP_EXEC,
+              19,
+              vm::OP_CONST,
+              16,
               vm::OP_NULL,
               vm::OP_EXEC,
               18,
               vm::OP_NULL,
               vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, "some variable" }));
-    ASSERT_EQ(compiler.variables(), std::vector<Variable *>({ v2.get(), v3.get() }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 1, 0, 0, 0, 6, 6, "some variable" }));
+    ASSERT_TRUE(compiler.variables().empty());
 }
 
 TEST_F(SensingBlocksTest, XPositionOfSprite)

From cc2f104af086483b3131877fd9129df416d8f0a6 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 1 May 2024 12:06:52 +0200
Subject: [PATCH 24/71] Add questionAborted() signal

---
 include/scratchcpp/iengine.h   | 3 +++
 src/engine/internal/engine.cpp | 5 +++++
 src/engine/internal/engine.h   | 2 ++
 test/mocks/enginemock.h        | 1 +
 4 files changed, 11 insertions(+)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index b392be8d..2e31b927 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -370,6 +370,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Emits when a question is asked, for example using the 'ask and wait' block. */
         virtual sigslot::signal<const std::string &> &questionAsked() = 0;
 
+        /*! Emits when the current question is aborted. */
+        virtual sigslot::signal<> &questionAborted() = 0;
+
         /*! Emits when a question is answered. */
         virtual sigslot::signal<const std::string &> &questionAnswered() = 0;
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 39fa79e2..1f1235df 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1349,6 +1349,11 @@ sigslot::signal<const std::string &> &Engine::questionAsked()
     return m_questionAsked;
 }
 
+sigslot::signal<> &Engine::questionAborted()
+{
+    return m_questionAborted;
+}
+
 sigslot::signal<const std::string &> &Engine::questionAnswered()
 {
     return m_questionAnswered;
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index f359bdf3..1d9efd82 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -154,6 +154,7 @@ class Engine : public IEngine
         sigslot::signal<Monitor *, IMonitorHandler *> &monitorRemoved() override;
 
         sigslot::signal<const std::string &> &questionAsked() override;
+        sigslot::signal<> &questionAborted() override;
         sigslot::signal<const std::string &> &questionAnswered() override;
 
         const std::vector<std::string> &extensions() const override;
@@ -284,6 +285,7 @@ class Engine : public IEngine
         sigslot::signal<Monitor *> m_monitorAdded;
         sigslot::signal<Monitor *, IMonitorHandler *> m_monitorRemoved;
         sigslot::signal<const std::string &> m_questionAsked;
+        sigslot::signal<> m_questionAborted;
         sigslot::signal<const std::string &> m_questionAnswered;
 };
 
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 48fc505b..bed2b592 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -134,6 +134,7 @@ class EngineMock : public IEngine
         MOCK_METHOD((sigslot::signal<Monitor *, IMonitorHandler *> &), monitorRemoved, (), (override));
 
         MOCK_METHOD(sigslot::signal<const std::string &> &, questionAsked, (), (override));
+        MOCK_METHOD(sigslot::signal<> &, questionAborted, (), (override));
         MOCK_METHOD(sigslot::signal<const std::string &> &, questionAnswered, (), (override));
 
         MOCK_METHOD(std::vector<std::string> &, extensions, (), (const, override));

From d120f2cb974b6df2c45ba45a9af9f03b31bd9b89 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 1 May 2024 12:10:04 +0200
Subject: [PATCH 25/71] fix #486: Clear pending questions when a script stops

---
 src/blocks/sensingblocks.cpp | 16 ++++++++++++++++
 src/blocks/sensingblocks.h   |  1 +
 2 files changed, 17 insertions(+)

diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
index 43f8303b..8914d83c 100644
--- a/src/blocks/sensingblocks.cpp
+++ b/src/blocks/sensingblocks.cpp
@@ -95,6 +95,22 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->questionAnswered().connect(&onAnswer);
 }
 
+void SensingBlocks::onInit(IEngine *engine)
+{
+    engine->threadAboutToStop().connect([engine](VirtualMachine *thread) {
+        if (!m_questionList.empty()) {
+            // Abort the question of this thread if it's currently being displayed
+            if (m_questionList.front()->vm == thread) {
+                thread->target()->setBubbleText("");
+                engine->questionAborted()();
+            }
+
+            m_questionList
+                .erase(std::remove_if(m_questionList.begin(), m_questionList.end(), [thread](const std::unique_ptr<Question> &question) { return question->vm == thread; }), m_questionList.end());
+        }
+    });
+}
+
 void SensingBlocks::compileTouchingObject(Compiler *compiler)
 {
     Input *input = compiler->input(TOUCHINGOBJECTMENU);
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
index b00b20ce..e281827f 100644
--- a/src/blocks/sensingblocks.h
+++ b/src/blocks/sensingblocks.h
@@ -60,6 +60,7 @@ class SensingBlocks : public IBlockSection
         std::string name() const override;
 
         void registerBlocks(IEngine *engine) override;
+        void onInit(IEngine *engine) override;
 
         static void compileTouchingObject(Compiler *compiler);
         static void compileTouchingColor(Compiler *compiler);

From 5cf0951f73cc9e5431bf250b05b09261e09e1570 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 1 May 2024 12:10:37 +0200
Subject: [PATCH 26/71] fix #468: Hide all text bubbles when the project stops

---
 src/blocks/looksblocks.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index b10691a4..0ca63b52 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -103,6 +103,14 @@ void LooksBlocks::onInit(IEngine *engine)
         m_timeMap.erase(vm);
         erase_if(m_waitingBubbles, [vm](const std::pair<Target *, VirtualMachine *> &pair) { return pair.second == vm; });
     });
+
+    engine->stopped().connect([engine]() {
+        const auto &targets = engine->targets();
+
+        for (auto target : targets) {
+            target->setBubbleText("");
+        }
+    });
 }
 
 void LooksBlocks::compileSayForSecs(Compiler *compiler)

From ba283bc32a4566d8741830a18faa1717a3a282f6 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 1 May 2024 12:11:10 +0200
Subject: [PATCH 27/71] fix #460: Clear graphic effects when the project stops

---
 src/blocks/looksblocks.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index 0ca63b52..21421d46 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -109,6 +109,7 @@ void LooksBlocks::onInit(IEngine *engine)
 
         for (auto target : targets) {
             target->setBubbleText("");
+            target->clearGraphicsEffects();
         }
     });
 }

From a04e9e265ee65df50b1f823d4c4e21d19c510dee Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 1 May 2024 12:32:54 +0200
Subject: [PATCH 28/71] fix #552: Do not cloned sounds which aren't loaded

Closes #552
---
 src/scratch/sound.cpp      |  7 +++++--
 test/assets/sound_test.cpp | 11 +++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index 53772e90..ed7a96f8 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -85,9 +85,12 @@ std::shared_ptr<Sound> Sound::clone() const
     auto sound = std::make_shared<Sound>(name(), id(), dataFormat());
     sound->setRate(rate());
     sound->setSampleCount(sampleCount());
-    sound->impl->player->loadCopy(impl->player.get());
     sound->impl->player->setVolume(impl->player->volume());
-    sound->setData(dataSize(), const_cast<void *>(data()));
+
+    if (impl->player->isLoaded()) {
+        sound->impl->player->loadCopy(impl->player.get());
+        sound->setData(dataSize(), const_cast<void *>(data()));
+    }
 
     return sound;
 }
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index 7f7e9d44..e394cba4 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -133,6 +133,7 @@ TEST_F(SoundTest, Clone)
 
     auto clonePlayer = std::make_shared<AudioPlayerMock>();
     EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(clonePlayer));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(true));
     EXPECT_CALL(*clonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
     EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.45));
     EXPECT_CALL(*clonePlayer, setVolume(0.45));
@@ -145,6 +146,16 @@ TEST_F(SoundTest, Clone)
     ASSERT_EQ(clone->rate(), sound->rate());
     ASSERT_EQ(clone->sampleCount(), sound->sampleCount());
 
+    auto anotherClonePlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(clonePlayer));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
+    EXPECT_CALL(*clonePlayer, loadCopy).Times(0);
+    EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.62));
+    EXPECT_CALL(*clonePlayer, setVolume(0.62));
+    EXPECT_CALL(*clonePlayer, isLoaded()).Times(0);
+    auto anotherClone = sound->clone();
+    ASSERT_TRUE(anotherClone);
+
     // Stopping/starting the sound should stop its clones
     auto anotherPlayer = std::make_shared<AudioPlayerMock>();
     EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(anotherPlayer));

From 3a013e1d18abb5b91b954af2874e8e012f2991b8 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 1 May 2024 13:26:10 +0200
Subject: [PATCH 29/71] fix #553: Use clone root audio player when cloning
 sounds

---
 src/scratch/sound.cpp      | 13 ++++++++-----
 src/scratch/sound_p.h      |  2 ++
 test/assets/sound_test.cpp | 22 ++++++++++++++++------
 3 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index ed7a96f8..dccba675 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -82,13 +82,15 @@ void Sound::setTarget(Target *target)
 /*! Returns an independent copy of the sound which is valid for as long as the original sound exists. */
 std::shared_ptr<Sound> Sound::clone() const
 {
+    const Sound *root = impl->cloneRoot ? impl->cloneRoot : this;
     auto sound = std::make_shared<Sound>(name(), id(), dataFormat());
     sound->setRate(rate());
     sound->setSampleCount(sampleCount());
+    sound->impl->cloneRoot = root;
     sound->impl->player->setVolume(impl->player->volume());
 
-    if (impl->player->isLoaded()) {
-        sound->impl->player->loadCopy(impl->player.get());
+    if (root->impl->player->isLoaded()) {
+        sound->impl->player->loadCopy(root->impl->player.get());
         sound->setData(dataSize(), const_cast<void *>(data()));
     }
 
@@ -113,10 +115,11 @@ void Sound::stopCloneSounds()
             sprite = sprite->cloneSprite();
 
         // Stop the sound in the sprite (clone root)
-        auto sound = sprite->soundAt(sprite->findSound(name()));
+        const Sound *root = impl->cloneRoot ? impl->cloneRoot : this;
+        assert(root == sprite->soundAt(sprite->findSound(name())).get());
 
-        if (sound && sound.get() != this)
-            sound->impl->player->stop();
+        if (root != this)
+            root->impl->player->stop();
 
         // Stop the sound in clones
         const auto &clones = sprite->clones();
diff --git a/src/scratch/sound_p.h b/src/scratch/sound_p.h
index 68cbe980..3df2ca3f 100644
--- a/src/scratch/sound_p.h
+++ b/src/scratch/sound_p.h
@@ -11,6 +11,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class Sound;
 
 struct SoundPrivate
 {
@@ -22,6 +23,7 @@ struct SoundPrivate
         static IAudioOutput *audioOutput;
         std::shared_ptr<IAudioPlayer> player = nullptr;
         Target *target = nullptr;
+        const Sound *cloneRoot = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index e394cba4..d9e0e371 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -146,14 +146,24 @@ TEST_F(SoundTest, Clone)
     ASSERT_EQ(clone->rate(), sound->rate());
     ASSERT_EQ(clone->sampleCount(), sound->sampleCount());
 
+    auto cloneClonePlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(cloneClonePlayer));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(true));
+    EXPECT_CALL(*cloneClonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
+    EXPECT_CALL(*clonePlayer, volume()).WillOnce(Return(0.62));
+    EXPECT_CALL(*cloneClonePlayer, setVolume(0.62));
+    EXPECT_CALL(*cloneClonePlayer, isLoaded()).WillOnce(Return(true));
+    auto cloneClone = clone->clone();
+    ASSERT_TRUE(cloneClone);
+
     auto anotherClonePlayer = std::make_shared<AudioPlayerMock>();
-    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(clonePlayer));
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(anotherClonePlayer));
     EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
-    EXPECT_CALL(*clonePlayer, loadCopy).Times(0);
-    EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.62));
-    EXPECT_CALL(*clonePlayer, setVolume(0.62));
-    EXPECT_CALL(*clonePlayer, isLoaded()).Times(0);
-    auto anotherClone = sound->clone();
+    EXPECT_CALL(*anotherClonePlayer, loadCopy).Times(0);
+    EXPECT_CALL(*clonePlayer, volume()).WillOnce(Return(0.62));
+    EXPECT_CALL(*anotherClonePlayer, setVolume(0.62));
+    EXPECT_CALL(*anotherClonePlayer, isLoaded()).Times(0);
+    auto anotherClone = clone->clone();
     ASSERT_TRUE(anotherClone);
 
     // Stopping/starting the sound should stop its clones

From 7197c44a07e231f1977feb6e81d10c43e2849b3a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 13:44:44 +0200
Subject: [PATCH 30/71] fix #550: Merge Shadow and NoShadow compiler code

---
 src/engine/compiler.cpp         | 29 ++++++++++++++++-------------
 test/compiler/compiler_test.cpp |  7 +++++--
 2 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/src/engine/compiler.cpp b/src/engine/compiler.cpp
index 9f737b73..0f549af6 100644
--- a/src/engine/compiler.cpp
+++ b/src/engine/compiler.cpp
@@ -174,23 +174,26 @@ void Compiler::addInput(Input *input)
     }
     switch (input->type()) {
         case Input::Type::Shadow:
+        case Input::Type::NoShadow: {
             if (input->pointsToDropdownMenu())
                 addInstruction(OP_CONST, { impl->constIndex(input->primaryValue(), true, input->selectedMenuItem()) });
-            else
-                addInstruction(OP_CONST, { impl->constIndex(input->primaryValue()) });
-            break;
-
-        case Input::Type::NoShadow: {
-            auto previousBlock = impl->block;
-            impl->block = input->valueBlock();
-            assert(impl->block);
-            if (impl->block->compileFunction())
-                impl->block->compile(this);
             else {
-                std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
-                addInstruction(OP_NULL);
+                auto previousBlock = impl->block;
+                impl->block = input->valueBlock();
+
+                if (impl->block) {
+                    if (impl->block->compileFunction())
+                        impl->block->compile(this);
+                    else {
+                        std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                        addInstruction(OP_NULL);
+                    }
+                } else
+                    addInstruction(OP_CONST, { impl->constIndex(input->primaryValue()) });
+
+                impl->block = previousBlock;
             }
-            impl->block = previousBlock;
+
             break;
         }
 
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index dde1626a..33a50c7b 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -315,7 +315,8 @@ TEST_F(CompilerTest, AddNoShadowInput)
     compiler.addInstruction(vm::OP_PRINT);
 
     Input input2("TEST_INPUT2", Input::Type::NoShadow);
-    EXPECT_DEATH({ compiler.addInput(&input2); }, "(Assertion)([ ]+)(.+)([ ]+)(failed)");
+    input2.setPrimaryValue("test");
+    compiler.addInput(&input2);
 
     Input input3("TEST_INPUT3", Input::Type::NoShadow);
     std::shared_ptr<Block> block2 = std::make_shared<Block>("", "test_block2");
@@ -324,7 +325,9 @@ TEST_F(CompilerTest, AddNoShadowInput)
     compiler.addInstruction(vm::OP_PRINT);
 
     compiler.addInstruction(vm::OP_HALT);
-    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0], "test");
 }
 
 TEST_F(CompilerTest, ResolveInput)

From a53115d33b790448f8db7edc5195dfe8cc5a503e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:00:18 +0200
Subject: [PATCH 31/71] fix #549: Fix dropdown menu detection logic

---
 src/scratch/input.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/scratch/input.cpp b/src/scratch/input.cpp
index 2e2e16c8..30de8fed 100644
--- a/src/scratch/input.cpp
+++ b/src/scratch/input.cpp
@@ -98,13 +98,13 @@ void Input::setValueBlockId(const std::string &id)
 
 /*!
  * Returns true if the input points to a dropdown menu.\n
- * (if type() == Type::Shadow and valueBlock() points to a block with a single field which does not point to an entity)
+ * (if valueBlock() points to a shadow block with a single field which does not point to an entity)
  */
 bool Input::pointsToDropdownMenu() const
 {
     auto block = valueBlock();
 
-    if ((impl->type != Type::Shadow) || !block)
+    if (!block || !block->shadow())
         return false;
 
     const auto &fields = block->fields();

From 44d13b86e1a7547057f15691ba3754492c7363bc Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:00:31 +0200
Subject: [PATCH 32/71] Update compiler test for new dropdown menu detection

---
 test/compiler/compiler_test.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index 33a50c7b..8d9a84d0 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -358,6 +358,7 @@ TEST_F(CompilerTest, ResolveDropdownMenuInput)
     auto block = std::make_shared<Block>("a", "test_block1");
     auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
     auto menu = std::make_shared<Block>("a", "test_menu");
+    menu->setShadow(true);
     auto optionField = std::make_shared<Field>("OPTION", "test");
     input->setInputId(TestBlockSection::INPUT1);
     input->setValueBlock(menu);

From 2e468920633240c6a9f9c6045aa6d3c98da7a049 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:03:02 +0200
Subject: [PATCH 33/71] Fix dropdown menus in control blocks

---
 src/blocks/controlblocks.cpp        | 3 +--
 test/blocks/control_blocks_test.cpp | 1 +
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blocks/controlblocks.cpp b/src/blocks/controlblocks.cpp
index d3f89b07..0f965123 100644
--- a/src/blocks/controlblocks.cpp
+++ b/src/blocks/controlblocks.cpp
@@ -175,8 +175,7 @@ void ControlBlocks::compileCreateClone(Compiler *compiler)
 {
     Input *input = compiler->input(CLONE_OPTION);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string spriteName = input->selectedMenuItem();
 
         if (spriteName == "_myself_")
diff --git a/test/blocks/control_blocks_test.cpp b/test/blocks/control_blocks_test.cpp
index 16145999..a49acbea 100644
--- a/test/blocks/control_blocks_test.cpp
+++ b/test/blocks/control_blocks_test.cpp
@@ -41,6 +41,7 @@ class ControlBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, "CLONE_OPTION", ControlBlocks::CLONE_OPTION);
                 auto menu = createControlBlock(id + "_menu", "control_create_clone_of_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, "CLONE_OPTION", static_cast<ControlBlocks::Fields>(-1), spriteName, static_cast<ControlBlocks::FieldValues>(-1));
             }

From 9afa021960101788ca16035a0db68fed0c311d08 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:05:16 +0200
Subject: [PATCH 34/71] Fix dropdown menus in event blocks

---
 src/blocks/eventblocks.cpp        | 3 +--
 test/blocks/event_blocks_test.cpp | 1 +
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 470ceafc..5a4c4fca 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -63,8 +63,7 @@ void EventBlocks::compileWhenTouchingObjectPredicate(Compiler *compiler)
 {
     Input *input = compiler->input(TOUCHINGOBJECTMENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         compiler->addConstValue(value);
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 144b5113..c7567a7d 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -88,6 +88,7 @@ class EventBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<EventBlocks::Fields>(-1), selectedValue, static_cast<EventBlocks::FieldValues>(-1));
             }

From 65704ad6578d078c6a1d5b8d451b2b317207023f Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:10:46 +0200
Subject: [PATCH 35/71] Fix dropdown menus in looks blocks

---
 src/blocks/looksblocks.cpp        | 9 +++------
 test/blocks/looks_blocks_test.cpp | 1 +
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index 21421d46..fb55f39d 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -349,8 +349,7 @@ void LooksBlocks::compileSwitchCostumeTo(Compiler *compiler)
 
     Input *input = compiler->input(COSTUME);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
         int index = target->findCostume(value);
 
@@ -394,8 +393,7 @@ void LooksBlocks::compileSwitchBackdropTo(Compiler *compiler)
 
     Input *input = compiler->input(BACKDROP);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
         int index = stage->findCostume(value);
 
@@ -436,8 +434,7 @@ void LooksBlocks::compileSwitchBackdropToAndWait(Compiler *compiler)
 
     Input *input = compiler->input(BACKDROP);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
         int index = stage->findCostume(value);
 
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index 2bf1e44a..950187b7 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -75,6 +75,7 @@ class LooksBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = createLooksBlock(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<LooksBlocks::Fields>(-1), selectedValue, static_cast<LooksBlocks::FieldValues>(-1));
             }

From 29b37d7d09baefa407369ef0615360314ef43a76 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:10:54 +0200
Subject: [PATCH 36/71] Fix dropdown menus in motion blocks

---
 src/blocks/motionblocks.cpp        | 9 +++------
 test/blocks/motion_blocks_test.cpp | 1 +
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/blocks/motionblocks.cpp b/src/blocks/motionblocks.cpp
index 012d436d..549cb18d 100644
--- a/src/blocks/motionblocks.cpp
+++ b/src/blocks/motionblocks.cpp
@@ -107,8 +107,7 @@ void MotionBlocks::compilePointTowards(Compiler *compiler)
 {
     Input *input = compiler->input(TOWARDS);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -137,8 +136,7 @@ void MotionBlocks::compileGoTo(Compiler *compiler)
 {
     Input *input = compiler->input(TO);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -171,8 +169,7 @@ void MotionBlocks::compileGlideTo(Compiler *compiler)
 
     Input *input = compiler->input(TO);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
diff --git a/test/blocks/motion_blocks_test.cpp b/test/blocks/motion_blocks_test.cpp
index 399b2030..4a2853ca 100644
--- a/test/blocks/motion_blocks_test.cpp
+++ b/test/blocks/motion_blocks_test.cpp
@@ -74,6 +74,7 @@ class MotionBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = createMotionBlock(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<MotionBlocks::Fields>(-1), selectedValue, static_cast<MotionBlocks::FieldValues>(-1));
             }

From 5b8029ec1fe1c24f334dfeaa68d53996f609b71f Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:12:24 +0200
Subject: [PATCH 37/71] Fix dropdown menus in sensing blocks

---
 src/blocks/sensingblocks.cpp        | 9 +++------
 test/blocks/sensing_blocks_test.cpp | 1 +
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
index 8914d83c..fee64bc0 100644
--- a/src/blocks/sensingblocks.cpp
+++ b/src/blocks/sensingblocks.cpp
@@ -115,8 +115,7 @@ void SensingBlocks::compileTouchingObject(Compiler *compiler)
 {
     Input *input = compiler->input(TOUCHINGOBJECTMENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -144,8 +143,7 @@ void SensingBlocks::compileDistanceTo(Compiler *compiler)
 {
     Input *input = compiler->input(DISTANCETOMENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -240,8 +238,7 @@ void SensingBlocks::compileOf(Compiler *compiler)
     assert(input);
     BlockFunc f = nullptr;
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         IEngine *engine = compiler->engine();
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
index f821f5ea..ecc61337 100644
--- a/test/blocks/sensing_blocks_test.cpp
+++ b/test/blocks/sensing_blocks_test.cpp
@@ -86,6 +86,7 @@ class SensingBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<SensingBlocks::Fields>(-1), selectedValue, static_cast<SensingBlocks::FieldValues>(-1));
             }

From 9c99ad95fd33ad7194366f835b5ef600469ea4bc Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:13:11 +0200
Subject: [PATCH 38/71] Fix dropdown menus in sound blocks

---
 src/blocks/soundblocks.cpp        | 3 +--
 test/blocks/sound_blocks_test.cpp | 1 +
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index fb999b87..f9e4a97f 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -61,8 +61,7 @@ bool SoundBlocks::compilePlayCommon(Compiler *compiler, bool untilDone, bool *by
 
     Input *input = compiler->input(SOUND_MENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         int index = target->findSound(value);
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index 77fef23b..d41c7b01 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -67,6 +67,7 @@ class SoundBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<SoundBlocks::Fields>(-1), selectedValue, static_cast<SoundBlocks::FieldValues>(-1));
             }

From ea005a8051690e7dde53d38dc6d874359394799d Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:24:28 +0200
Subject: [PATCH 39/71] Update Input test for new dropdown menu detection

---
 test/scratch_classes/input_test.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/scratch_classes/input_test.cpp b/test/scratch_classes/input_test.cpp
index ac8ca86f..48eb659f 100644
--- a/test/scratch_classes/input_test.cpp
+++ b/test/scratch_classes/input_test.cpp
@@ -81,6 +81,10 @@ TEST(InputTest, SelectedMenuItem)
 
     auto field1 = std::make_shared<Field>("OPTION1", "");
     block1->addField(field1);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    block1->setShadow(true);
     ASSERT_TRUE(input1.pointsToDropdownMenu());
     ASSERT_TRUE(input1.selectedMenuItem().empty());
 
@@ -90,6 +94,7 @@ TEST(InputTest, SelectedMenuItem)
     ASSERT_TRUE(input1.selectedMenuItem().empty());
 
     auto block2 = std::make_shared<Block>("def", "");
+    block2->setShadow(true);
     input1.setValueBlock(block2);
 
     field1 = std::make_shared<Field>("OPTION1", "something");

From ca98dff3cd3bc72b392508ec8d6baf1ffc85ecfd Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 14:49:13 +0200
Subject: [PATCH 40/71] fix #551: Make finding broadcasts by name case
 insensitive

Matches Scratch behavior.
---
 src/engine/internal/engine.cpp | 9 ++++++++-
 test/engine/engine_test.cpp    | 2 ++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 1f1235df..dabd0920 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1083,7 +1083,14 @@ std::shared_ptr<Broadcast> Engine::broadcastAt(int index) const
 
 int Engine::findBroadcast(const std::string &broadcastName) const
 {
-    auto it = std::find_if(m_broadcasts.begin(), m_broadcasts.end(), [broadcastName](std::shared_ptr<Broadcast> broadcast) { return broadcast->name() == broadcastName; });
+    std::string lowercaseName = broadcastName;
+    std::transform(lowercaseName.begin(), lowercaseName.end(), lowercaseName.begin(), ::tolower);
+
+    auto it = std::find_if(m_broadcasts.begin(), m_broadcasts.end(), [lowercaseName](std::shared_ptr<Broadcast> broadcast) {
+        std::string name = broadcast->name();
+        std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+        return name == lowercaseName;
+    });
 
     if (it == m_broadcasts.end())
         return -1;
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 9b8991f7..42b5d675 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -1289,6 +1289,8 @@ TEST(EngineTest, Broadcasts)
     ASSERT_EQ(engine.findBroadcast("message1"), 0);
     ASSERT_EQ(engine.findBroadcast("message2"), 1);
     ASSERT_EQ(engine.findBroadcast("Test"), 2);
+    ASSERT_EQ(engine.findBroadcast("MessAge2"), 1);
+    ASSERT_EQ(engine.findBroadcast("tEst"), 2);
 
     ASSERT_EQ(engine.findBroadcastById("d"), -1);
     ASSERT_EQ(engine.findBroadcastById("a"), 0);

From bb075ee0830528acc6661ed45d69d429c19c6900 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 17:50:52 +0200
Subject: [PATCH 41/71] fix #556: Rewrite download algorithm

---
 src/internal/projectdownloader.cpp      | 110 ++++++++++++++++--------
 test/network/projectdownloader_test.cpp |  49 +----------
 2 files changed, 77 insertions(+), 82 deletions(-)

diff --git a/src/internal/projectdownloader.cpp b/src/internal/projectdownloader.cpp
index 15e31246..c334da55 100644
--- a/src/internal/projectdownloader.cpp
+++ b/src/internal/projectdownloader.cpp
@@ -94,10 +94,8 @@ bool ProjectDownloader::downloadAssets(const std::vector<std::string> &assetIds)
     m_cancelMutex.unlock();
 
     auto count = assetIds.size();
-    unsigned int threadCount = std::thread::hardware_concurrency();
-
-    // Thread count: number of assets / 5, limited to maximum number of threads
-    threadCount = std::max(1u, std::min(threadCount, static_cast<unsigned int>(std::ceil(count / 5.0))));
+    // unsigned int threadCount = std::thread::hardware_concurrency();
+    unsigned int threadCount = 20;
 
     m_assets.clear();
     m_assets.reserve(count);
@@ -120,48 +118,92 @@ bool ProjectDownloader::downloadAssets(const std::vector<std::string> &assetIds)
         downloaders.push_back(m_downloaderFactory->create());
 
     // Download assets
-    auto f = [this, &downloaders, &assetIds, count, threadCount](unsigned int thread) {
-        auto downloader = downloaders[thread];
-        unsigned int n = std::ceil(count / static_cast<double>(threadCount));
+    auto f = [this, count](std::shared_ptr<IDownloader> downloader, int index, const std::string &id) {
+        m_cancelMutex.lock();
 
-        for (unsigned int i = 0; i < n; i++) {
-            unsigned int index = thread * n + i;
+        if (m_cancel)
+            return;
 
-            if (index < count) {
-                m_cancelMutex.lock();
+        m_cancelMutex.unlock();
 
-                if (m_cancel)
-                    return;
+        bool ret = downloader->download(ASSET_PREFIX + id + ASSET_SUFFIX);
 
-                m_cancelMutex.unlock();
+        if (!ret) {
+            std::cerr << "Failed to download asset: " << id << std::endl;
+            m_cancelMutex.lock();
+            m_cancel = true;
+            m_cancelMutex.unlock();
+            return;
+        }
 
-                bool ret = downloader->download(ASSET_PREFIX + assetIds[index] + ASSET_SUFFIX);
+        m_assetsMutex.lock();
+        m_assets[index] = downloader->text();
+        m_downloadedAssetCount++;
+        m_downloadProgressChanged(m_downloadedAssetCount, count);
+        m_assetsMutex.unlock();
+    };
 
-                if (!ret) {
-                    std::cerr << "Failed to download asset: " << assetIds[index] << std::endl;
-                    m_cancelMutex.lock();
-                    m_cancel = true;
-                    m_cancelMutex.unlock();
-                    return;
-                }
+    std::unordered_map<int, std::pair<std::thread, std::shared_ptr<IDownloader>>> threads;
+    bool done = false;
+    unsigned int lastCount = 0, i = 0;
 
-                m_assetsMutex.lock();
-                m_assets[index] = downloader->text();
-                m_downloadedAssetCount++;
-                std::cout << "Downloaded assets: " << m_downloadedAssetCount << " of " << count << std::endl;
-                m_downloadProgressChanged(m_downloadedAssetCount, count);
-                m_assetsMutex.unlock();
+    while (true) {
+        int addCount = threadCount - threads.size();
+
+        for (int j = 0; j < addCount; j++) {
+            if (i >= count) {
+                done = true;
+                break;
             }
+
+            std::shared_ptr<IDownloader> freeDownloader = nullptr;
+
+            for (auto downloader : downloaders) {
+                auto it = std::find_if(threads.begin(), threads.end(), [&downloader](std::pair<const int, std::pair<std::thread, std::shared_ptr<IDownloader>>> &pair) {
+                    return pair.second.second == downloader;
+                });
+
+                if (it == threads.cend()) {
+                    freeDownloader = downloader;
+                    break;
+                }
+            }
+
+            assert(freeDownloader);
+            threads[i] = { std::thread(f, freeDownloader, i, assetIds[i]), freeDownloader };
+            i++;
         }
-    };
 
-    std::vector<std::thread> threads;
+        std::this_thread::sleep_for(std::chrono::milliseconds(25));
 
-    for (unsigned int i = 0; i < threadCount; i++)
-        threads.emplace_back(std::thread(f, i));
+        m_assetsMutex.lock();
 
-    for (unsigned int i = 0; i < threadCount; i++)
-        threads[i].join();
+        if (m_downloadedAssetCount != lastCount) {
+            std::cout << "Downloaded assets: " << m_downloadedAssetCount << " of " << count << std::endl;
+            lastCount = m_downloadedAssetCount;
+        }
+
+        std::vector<int> toRemove;
+
+        for (auto &[index, info] : threads) {
+            if (!m_assets[index].empty())
+                toRemove.push_back(index);
+        }
+
+        m_assetsMutex.unlock();
+
+        for (int index : toRemove) {
+            threads[index].first.join();
+            threads.erase(index);
+        }
+
+        if (done) {
+            for (auto &[index, info] : threads)
+                info.first.join();
+
+            break;
+        }
+    }
 
     CHECK_CANCEL();
 
diff --git a/test/network/projectdownloader_test.cpp b/test/network/projectdownloader_test.cpp
index acda894d..25359160 100644
--- a/test/network/projectdownloader_test.cpp
+++ b/test/network/projectdownloader_test.cpp
@@ -75,51 +75,4 @@ TEST_F(ProjectDownloaderTest, DownloadJson)
     ASSERT_EQ(m_downloader->downloadedAssetCount(), 0);
 }
 
-TEST_F(ProjectDownloaderTest, DownloadAssets)
-{
-    static const std::string assetPrefix = "https://assets.scratch.mit.edu/internalapi/asset/";
-    static const std::string assetSuffix = "/get";
-    static const std::vector<std::string> assetIds = { "abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yzA", "BCD", "EFG", "HIJ", "KLM", "NOP", "QRS", "TUV", "WXY" };
-    static const std::vector<std::string> assetData = { "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", "a16", "a17" };
-    ASSERT_EQ(assetIds.size(), assetData.size());
-    std::vector<std::shared_ptr<DownloaderMock>> downloaders;
-    std::vector<unsigned int> downloaderTextIndexes;
-    unsigned int threadCount = std::thread::hardware_concurrency();
-    threadCount = std::max(1u, std::min(threadCount, static_cast<unsigned int>(std::ceil(assetIds.size() / 5.0))));
-
-    downloaders.reserve(threadCount);
-    downloaderTextIndexes.reserve(threadCount);
-
-    for (unsigned int i = 0; i < threadCount; i++) {
-        downloaders.push_back(std::make_shared<DownloaderMock>());
-        downloaderTextIndexes.push_back(0);
-    }
-
-    // Success
-    unsigned int count = 0;
-    EXPECT_CALL(*m_factory, create()).Times(threadCount);
-    ON_CALL(*m_factory, create()).WillByDefault(Invoke([&downloaders, &count]() {
-        assert(count < downloaders.size());
-        return downloaders[count++];
-    }));
-
-    for (unsigned int i = 0; i < threadCount; i++)
-        downloaderTextIndexes[i] = 0;
-
-    for (unsigned int i = 0; i < threadCount; i++) {
-        auto downloader = downloaders[i];
-        unsigned int n = std::ceil(assetIds.size() / static_cast<double>(threadCount));
-        unsigned int repeatCount = std::min(n, static_cast<unsigned int>(assetIds.size()) - i * n);
-
-        for (unsigned int j = 0; j < repeatCount; j++) {
-            unsigned int index = i * n + j;
-            EXPECT_CALL(*downloader, download(assetPrefix + assetIds[index] + assetSuffix)).WillOnce(Return(true));
-        }
-
-        EXPECT_CALL(*downloader, text()).Times(repeatCount).WillRepeatedly(Invoke([i, n, &downloaderTextIndexes]() -> const std::string & { return assetData[i * n + downloaderTextIndexes[i]++]; }));
-    }
-
-    ASSERT_TRUE(m_downloader->downloadAssets(assetIds));
-    ASSERT_EQ(m_downloader->assets(), assetData);
-    ASSERT_EQ(m_downloader->downloadedAssetCount(), assetIds.size());
-}
+// NOTE: Asset downloading should be tested manually

From 2e966edc29fda58cf1c2739148e94ba3277257fc Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 23:09:19 +0200
Subject: [PATCH 42/71] fix #555: Use int for index in IEngine::broadcast()

---
 include/scratchcpp/iengine.h   | 2 +-
 src/engine/internal/engine.cpp | 2 +-
 src/engine/internal/engine.h   | 2 +-
 test/mocks/enginemock.h        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 2e31b927..ef1735cc 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -60,7 +60,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
 
         /*! Starts the scripts of the broadcast with the given index. */
-        virtual void broadcast(unsigned int index) = 0;
+        virtual void broadcast(int index) = 0;
 
         /*! Starts the scripts of the given broadcast. */
         virtual void broadcastByPtr(Broadcast *broadcast) = 0;
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index dabd0920..d9a4bac6 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -415,7 +415,7 @@ VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target
     return pushThread(topLevelBlock, target).get();
 }
 
-void Engine::broadcast(unsigned int index)
+void Engine::broadcast(int index)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return;
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 1d9efd82..d5522f79 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -35,7 +35,7 @@ class Engine : public IEngine
         void start() override;
         void stop() override;
         VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *target) override;
-        void broadcast(unsigned int index) override;
+        void broadcast(int index) override;
         void broadcastByPtr(Broadcast *broadcast) override;
         void startBackdropScripts(Broadcast *broadcast) override;
         void stopScript(VirtualMachine *vm) override;
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index bed2b592..4b322e07 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -17,7 +17,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, start, (), (override));
         MOCK_METHOD(void, stop, (), (override));
         MOCK_METHOD(VirtualMachine *, startScript, (std::shared_ptr<Block>, Target *), (override));
-        MOCK_METHOD(void, broadcast, (unsigned int), (override));
+        MOCK_METHOD(void, broadcast, (int), (override));
         MOCK_METHOD(void, broadcastByPtr, (Broadcast *), (override));
         MOCK_METHOD(void, startBackdropScripts, (Broadcast *), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));

From 57967f2044a551f139190261a39cbc0061d1dec7 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 21 Aug 2024 23:50:11 +0200
Subject: [PATCH 43/71] fix #560: Return a list in IEngine::findBroadcasts()

---
 include/scratchcpp/iengine.h      |  4 +--
 src/blocks/eventblocks.cpp        | 50 ++++++++++++++++++++++++-------
 src/engine/internal/engine.cpp    | 18 +++++------
 src/engine/internal/engine.h      |  2 +-
 test/blocks/event_blocks_test.cpp | 44 +++++++++++++++++----------
 test/engine/engine_test.cpp       | 22 +++++++-------
 test/mocks/enginemock.h           |  2 +-
 7 files changed, 93 insertions(+), 49 deletions(-)

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index ef1735cc..2372d42c 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -291,8 +291,8 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the broadcast at index. */
         virtual std::shared_ptr<Broadcast> broadcastAt(int index) const = 0;
 
-        /*! Returns the index of the broadcast with the given name. */
-        virtual int findBroadcast(const std::string &broadcastName) const = 0;
+        /*! Returns the list of indexes of the broadcasts with the given name (case insensitive). */
+        virtual std::vector<int> findBroadcasts(const std::string &broadcastName) const = 0;
 
         /*! Returns the index of the broadcast with the given ID. */
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 5a4c4fca..e4c61902 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -99,8 +99,12 @@ void EventBlocks::compileBroadcast(Compiler *compiler)
     auto input = compiler->input(BROADCAST_INPUT);
 
     if (input->type() != Input::Type::ObscuredShadow) {
-        compiler->addConstValue(compiler->engine()->findBroadcast(input->primaryValue()->value().toString()));
-        compiler->addFunctionCall(&broadcastByIndex);
+        std::vector<int> broadcasts = compiler->engine()->findBroadcasts(input->primaryValue()->value().toString());
+
+        for (int index : broadcasts) {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&broadcastByIndex);
+        }
     } else {
         compiler->addInput(input);
         compiler->addFunctionCall(&broadcast);
@@ -112,11 +116,17 @@ void EventBlocks::compileBroadcastAndWait(Compiler *compiler)
     auto input = compiler->input(BROADCAST_INPUT);
 
     if (input->type() != Input::Type::ObscuredShadow) {
-        int index = compiler->engine()->findBroadcast(input->primaryValue()->value().toString());
-        compiler->addConstValue(index);
-        compiler->addFunctionCall(&broadcastByIndexAndWait);
-        compiler->addConstValue(index);
-        compiler->addFunctionCall(&checkBroadcastByIndex);
+        std::vector<int> broadcasts = compiler->engine()->findBroadcasts(input->primaryValue()->value().toString());
+
+        for (int index : broadcasts) {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&broadcastByIndexAndWait);
+        }
+
+        for (int index : broadcasts) {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&checkBroadcastByIndex);
+        }
     } else {
         compiler->addInput(input);
         compiler->addFunctionCall(&broadcastAndWait);
@@ -197,7 +207,11 @@ unsigned int EventBlocks::whenTouchingObjectPredicate(VirtualMachine *vm)
 
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
+    std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
+
+    for (int index : broadcasts)
+        vm->engine()->broadcast(index);
+
     return 1;
 }
 
@@ -209,7 +223,11 @@ unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
 
 unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
+    std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
+
+    for (int index : broadcasts)
+        vm->engine()->broadcast(index);
+
     return 1;
 }
 
@@ -221,8 +239,20 @@ unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
 
 unsigned int EventBlocks::checkBroadcast(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString())))
+    bool running = false;
+
+    std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
+
+    for (int index : broadcasts) {
+        if (vm->engine()->broadcastRunning(index)) {
+            running = true;
+            break;
+        }
+    }
+
+    if (running)
         vm->stop(true, true, true);
+
     return 1;
 }
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index d9a4bac6..216dc97b 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1081,21 +1081,21 @@ std::shared_ptr<Broadcast> Engine::broadcastAt(int index) const
     return m_broadcasts[index];
 }
 
-int Engine::findBroadcast(const std::string &broadcastName) const
+std::vector<int> Engine::findBroadcasts(const std::string &broadcastName) const
 {
+    std::vector<int> ret;
     std::string lowercaseName = broadcastName;
     std::transform(lowercaseName.begin(), lowercaseName.end(), lowercaseName.begin(), ::tolower);
 
-    auto it = std::find_if(m_broadcasts.begin(), m_broadcasts.end(), [lowercaseName](std::shared_ptr<Broadcast> broadcast) {
-        std::string name = broadcast->name();
+    for (unsigned int i = 0; i < m_broadcasts.size(); i++) {
+        std::string name = m_broadcasts[i]->name();
         std::transform(name.begin(), name.end(), name.begin(), ::tolower);
-        return name == lowercaseName;
-    });
 
-    if (it == m_broadcasts.end())
-        return -1;
-    else
-        return it - m_broadcasts.begin();
+        if (name == lowercaseName)
+            ret.push_back(i);
+    }
+
+    return ret;
 }
 
 int Engine::findBroadcastById(const std::string &broadcastId) const
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index d5522f79..d04f71f3 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -123,7 +123,7 @@ class Engine : public IEngine
         const std::vector<std::shared_ptr<Broadcast>> &broadcasts() const override;
         void setBroadcasts(const std::vector<std::shared_ptr<Broadcast>> &broadcasts) override;
         std::shared_ptr<Broadcast> broadcastAt(int index) const override;
-        int findBroadcast(const std::string &broadcastName) const override;
+        std::vector<int> findBroadcasts(const std::string &broadcastName) const override;
         int findBroadcastById(const std::string &broadcastId) const override;
 
         void addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock) override;
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index c7567a7d..5a6db769 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -373,8 +373,8 @@ TEST_F(EventBlocksTest, Broadcast)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndex)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 0, 3 })));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndex)).Times(2).WillRepeatedly(Return(0));
     EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcast)).WillOnce(Return(1));
 
     compiler.init();
@@ -384,9 +384,8 @@ TEST_F(EventBlocksTest, Broadcast)
     EventBlocks::compileBroadcast(&compiler);
     compiler.end();
 
-    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 1, vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues().size(), 1);
-    ASSERT_EQ(compiler.constValues()[0].toDouble(), 0);
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 3 }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
@@ -402,8 +401,9 @@ TEST_F(EventBlocksTest, BroadcastImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 1, 4 })));
+    EXPECT_CALL(m_engineMock, broadcast(1));
+    EXPECT_CALL(m_engineMock, broadcast(4));
 
     vm.setBytecode(bytecode1);
     vm.run();
@@ -432,9 +432,9 @@ TEST_F(EventBlocksTest, BroadcastAndWait)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::checkBroadcastByIndex)).WillOnce(Return(1));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 0, 3 })));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndexAndWait)).Times(2).WillRepeatedly(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::checkBroadcastByIndex)).Times(2).WillRepeatedly(Return(1));
     EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastAndWait)).WillOnce(Return(2));
     EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::checkBroadcast)).WillOnce(Return(3));
 
@@ -448,8 +448,9 @@ TEST_F(EventBlocksTest, BroadcastAndWait)
     ASSERT_EQ(
         compiler.bytecode(),
         std::vector<unsigned int>(
-            { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 2, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 3, vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 0 }));
+            { vm::OP_START, vm::OP_CONST, 0,           vm::OP_EXEC, 0,           vm::OP_CONST, 1,           vm::OP_EXEC, 0,          vm::OP_CONST, 2, vm::OP_EXEC, 1, vm::OP_CONST, 3, vm::OP_EXEC, 1,
+              vm::OP_NULL,  vm::OP_NOT,   vm::OP_EXEC, 2,           vm::OP_NULL, vm::OP_NOT,   vm::OP_EXEC, 3,           vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 3, 0, 3 }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
@@ -467,15 +468,16 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 1, 4 })));
+    EXPECT_CALL(m_engineMock, broadcast(1));
+    EXPECT_CALL(m_engineMock, broadcast(4));
 
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
     EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
 
     vm.setBytecode(bytecode2);
@@ -484,8 +486,18 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.atEnd(), false);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
+    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
+
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.atEnd(), false);
+
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
     EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(false));
 
     vm.run();
 
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 42b5d675..0d828a1b 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -1276,23 +1276,25 @@ TEST(EngineTest, Broadcasts)
     auto b1 = std::make_shared<Broadcast>("a", "message1");
     auto b2 = std::make_shared<Broadcast>("b", "message2");
     auto b3 = std::make_shared<Broadcast>("c", "Test");
-    engine.setBroadcasts({ b1, b2, b3 });
+    auto b4 = std::make_shared<Broadcast>("d", "TesT");
+    engine.setBroadcasts({ b1, b2, b3, b4 });
 
-    ASSERT_EQ(engine.broadcasts(), std::vector<std::shared_ptr<Broadcast>>({ b1, b2, b3 }));
+    ASSERT_EQ(engine.broadcasts(), std::vector<std::shared_ptr<Broadcast>>({ b1, b2, b3, b4 }));
     ASSERT_EQ(engine.broadcastAt(0), b1);
     ASSERT_EQ(engine.broadcastAt(1), b2);
     ASSERT_EQ(engine.broadcastAt(2), b3);
-    ASSERT_EQ(engine.broadcastAt(3), nullptr);
+    ASSERT_EQ(engine.broadcastAt(3), b4);
+    ASSERT_EQ(engine.broadcastAt(4), nullptr);
     ASSERT_EQ(engine.broadcastAt(-1), nullptr);
 
-    ASSERT_EQ(engine.findBroadcast("invalid"), -1);
-    ASSERT_EQ(engine.findBroadcast("message1"), 0);
-    ASSERT_EQ(engine.findBroadcast("message2"), 1);
-    ASSERT_EQ(engine.findBroadcast("Test"), 2);
-    ASSERT_EQ(engine.findBroadcast("MessAge2"), 1);
-    ASSERT_EQ(engine.findBroadcast("tEst"), 2);
+    ASSERT_TRUE(engine.findBroadcasts("invalid").empty());
+    ASSERT_EQ(engine.findBroadcasts("message1"), std::vector<int>({ 0 }));
+    ASSERT_EQ(engine.findBroadcasts("message2"), std::vector<int>({ 1 }));
+    ASSERT_EQ(engine.findBroadcasts("Test"), std::vector<int>({ 2, 3 }));
+    ASSERT_EQ(engine.findBroadcasts("MessAge2"), std::vector<int>({ 1 }));
+    ASSERT_EQ(engine.findBroadcasts("tEst"), std::vector<int>({ 2, 3 }));
 
-    ASSERT_EQ(engine.findBroadcastById("d"), -1);
+    ASSERT_EQ(engine.findBroadcastById("e"), -1);
     ASSERT_EQ(engine.findBroadcastById("a"), 0);
     ASSERT_EQ(engine.findBroadcastById("b"), 1);
     ASSERT_EQ(engine.findBroadcastById("c"), 2);
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 4b322e07..c64691f6 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -103,7 +103,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(const std::vector<std::shared_ptr<Broadcast>> &, broadcasts, (), (const, override));
         MOCK_METHOD(void, setBroadcasts, (const std::vector<std::shared_ptr<Broadcast>> &), (override));
         MOCK_METHOD(std::shared_ptr<Broadcast>, broadcastAt, (int), (const, override));
-        MOCK_METHOD(int, findBroadcast, (const std::string &), (const, override));
+        MOCK_METHOD(std::vector<int>, findBroadcasts, (const std::string &), (const, override));
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, override));
 
         MOCK_METHOD(void, addWhenTouchingObjectScript, (std::shared_ptr<Block>), (override));

From 319055d0f0191442a3e03cf91cb743251c32e18e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 14:07:12 +0200
Subject: [PATCH 44/71] Drop Scratch version API

Resolves #496
---
 include/scratchcpp/global.h             |  6 ---
 include/scratchcpp/project.h            |  4 --
 src/project.cpp                         | 25 ----------
 src/project_p.cpp                       | 66 +++++--------------------
 src/project_p.h                         |  7 +--
 test/compiler/compiler_test.cpp         |  4 +-
 test/load_project/load_project_test.cpp | 41 ++++-----------
 test/project/project_test.cpp           | 60 +---------------------
 8 files changed, 27 insertions(+), 186 deletions(-)

diff --git a/include/scratchcpp/global.h b/include/scratchcpp/global.h
index 91500012..c72c14f6 100644
--- a/include/scratchcpp/global.h
+++ b/include/scratchcpp/global.h
@@ -23,12 +23,6 @@
 namespace libscratchcpp
 {
 
-enum class ScratchVersion
-{
-    Invalid = 0, /*!< An unsupported version. */
-    Scratch3 = 3 /*!< Scratch 3.0 */
-};
-
 class VirtualMachine;
 class Compiler;
 class Block;
diff --git a/include/scratchcpp/project.h b/include/scratchcpp/project.h
index 414ae47b..6f1c455c 100644
--- a/include/scratchcpp/project.h
+++ b/include/scratchcpp/project.h
@@ -26,7 +26,6 @@ class LIBSCRATCHCPP_EXPORT Project
     public:
         Project();
         Project(const std::string &fileName);
-        Project(const std::string &fileName, ScratchVersion scratchVersion);
         Project(const Project &) = delete;
 
         bool load();
@@ -38,9 +37,6 @@ class LIBSCRATCHCPP_EXPORT Project
         const std::string &fileName() const;
         void setFileName(const std::string &newFileName);
 
-        ScratchVersion scratchVersion() const;
-        void setScratchVersion(const ScratchVersion &version);
-
         std::shared_ptr<IEngine> engine() const;
 
         sigslot::signal<unsigned int, unsigned int> &downloadProgressChanged();
diff --git a/src/project.cpp b/src/project.cpp
index b5d94afe..221d8f1a 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -21,15 +21,6 @@ Project::Project(const std::string &fileName) :
 {
 }
 
-/*!
- * Constructs ScratchProjects with the given file name, for the given Scratch version.
- * \note You shouldn't normally use this constructor because the Scratch version is determined automatically.
- */
-Project::Project(const std::string &fileName, ScratchVersion scratchVersion) :
-    impl(spimpl::make_unique_impl<ProjectPrivate>(fileName, scratchVersion))
-{
-}
-
 /*! Loads the project. Returns true if successful. */
 bool Project::load()
 {
@@ -75,22 +66,6 @@ const std::string &Project::fileName() const
 void Project::setFileName(const std::string &newFileName)
 {
     impl->fileName = newFileName;
-    impl->detectScratchVersion();
-}
-
-/*! Returns the version of Scratch used for the project. */
-ScratchVersion Project::scratchVersion() const
-{
-    return impl->scratchVersion;
-}
-
-/*!
- * Sets the version of Scratch.
- * \note You shouldn't use this as the Scratch version is automatically determined.
- */
-void Project::setScratchVersion(const ScratchVersion &version)
-{
-    impl->setScratchVersion(version);
 }
 
 /*! Returns the engine of the loaded project. \see IEngine */
diff --git a/src/project_p.cpp b/src/project_p.cpp
index 951c3f3f..e3450fb4 100644
--- a/src/project_p.cpp
+++ b/src/project_p.cpp
@@ -25,33 +25,28 @@ ProjectPrivate::ProjectPrivate() :
 }
 
 ProjectPrivate::ProjectPrivate(const std::string &fileName) :
-    ProjectPrivate()
-{
-    this->fileName = fileName;
-
-    // Auto detect Scratch version
-    detectScratchVersion();
-}
-
-ProjectPrivate::ProjectPrivate(const std::string &fileName, ScratchVersion scratchVersion) :
     fileName(fileName),
     engine(std::make_shared<Engine>())
 {
-    setScratchVersion(scratchVersion);
+    this->fileName = fileName;
 }
 
 bool ProjectPrivate::load()
 {
     std::shared_ptr<IProjectReader> reader;
-    switch (scratchVersion) {
-        case ScratchVersion::Invalid:
-            std::cerr << "Could not read the project because version is set to invalid." << std::endl;
-            return false;
-        case ScratchVersion::Scratch3:
-            reader = std::make_shared<Scratch3Reader>();
-            break;
-    }
 
+    // Scratch 3
+    reader = std::make_shared<Scratch3Reader>();
+
+    if (tryLoad(reader.get()))
+        return true;
+
+    std::cerr << "Unsupported Scratch version." << std::endl;
+    return false;
+}
+
+bool ProjectPrivate::tryLoad(IProjectReader *reader)
+{
     // Load from URL
     ProjectUrl url(fileName);
 
@@ -114,7 +109,6 @@ bool ProjectPrivate::load()
         // Load from file
         reader->setFileName(fileName);
         if (!reader->isValid()) {
-            scratchVersion = ScratchVersion::Invalid;
             std::cerr << "Could not read the project." << std::endl;
             return false;
         }
@@ -149,40 +143,6 @@ void ProjectPrivate::runEventLoop()
     engine->runEventLoop();
 }
 
-void ProjectPrivate::detectScratchVersion()
-{
-    ProjectUrl url(fileName);
-
-    scratchVersion = ScratchVersion::Invalid;
-    Scratch3Reader scratch3;
-
-    if (url.isProjectUrl()) {
-        if (!downloader->downloadJson(url.projectId())) {
-            std::cerr << "Failed to download the project file." << std::endl;
-            return;
-        }
-
-        scratch3.loadData(downloader->json());
-    } else
-        scratch3.setFileName(fileName);
-
-    if (scratch3.isValid())
-        scratchVersion = ScratchVersion::Scratch3;
-
-    if (scratchVersion == ScratchVersion::Invalid)
-        std::cerr << "Unable to determine Scratch version." << std::endl;
-}
-
-void ProjectPrivate::setScratchVersion(ScratchVersion version)
-{
-    // TODO: Use this when more versions become supported
-    // if((version >= Version::Scratch3) && (version <= Version::Scratch3))
-    if (version == ScratchVersion::Scratch3)
-        scratchVersion = version;
-    else
-        std::cerr << "Unsupported Scratch version: " << static_cast<int>(version) << std::endl;
-}
-
 sigslot::signal<unsigned int, unsigned int> &ProjectPrivate::downloadProgressChanged()
 {
     return downloader->downloadProgressChanged();
diff --git a/src/project_p.h b/src/project_p.h
index 6ccabfff..d935835c 100644
--- a/src/project_p.h
+++ b/src/project_p.h
@@ -9,6 +9,7 @@ namespace libscratchcpp
 {
 
 class IEngine;
+class IProjectReader;
 class IProjectDownloaderFactory;
 class IProjectDownloader;
 
@@ -16,21 +17,17 @@ struct ProjectPrivate
 {
         ProjectPrivate();
         ProjectPrivate(const std::string &fileName);
-        ProjectPrivate(const std::string &fileName, ScratchVersion scratchVersion);
         ProjectPrivate(const ProjectPrivate &) = delete;
 
         bool load();
+        bool tryLoad(IProjectReader *reader);
 
         void start();
         void run();
         void runEventLoop();
 
-        void detectScratchVersion();
-        void setScratchVersion(ScratchVersion version);
-
         sigslot::signal<unsigned int, unsigned int> &downloadProgressChanged();
 
-        ScratchVersion scratchVersion = ScratchVersion::Invalid;
         std::string fileName;
         std::shared_ptr<IEngine> engine = nullptr;
 
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index 8d9a84d0..e4691a78 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -159,7 +159,7 @@ TEST_F(CompilerTest, Lists)
 
 TEST_F(CompilerTest, EmptyProject)
 {
-    ProjectPrivate p("empty_project.sb3", ScratchVersion::Scratch3);
+    ProjectPrivate p("empty_project.sb3");
     ASSERT_TRUE(p.load());
     auto engine = p.engine;
     ASSERT_EQ(engine->targets().size(), 1);
@@ -171,7 +171,7 @@ TEST_F(CompilerTest, EmptyProject)
 
 TEST_F(CompilerTest, ResolveIds)
 {
-    ProjectPrivate p("resolve_id_test.sb3", ScratchVersion::Scratch3);
+    ProjectPrivate p("resolve_id_test.sb3");
     ASSERT_TRUE(p.load());
     auto engine = p.engine;
     ASSERT_EQ(engine->targets().size(), 2);
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index 827884e5..c7a505ff 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -22,7 +22,6 @@
 
 using namespace libscratchcpp;
 
-static const std::vector<ScratchVersion> scratchVersions = { ScratchVersion::Scratch3 };
 static const std::vector<std::string> fileExtensions = { ".sb3" };
 
 using ::testing::Return;
@@ -31,8 +30,8 @@ using ::testing::ReturnRef;
 TEST(LoadProjectTest, EmptyProject)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        Project p("empty_project" + fileExtensions[i], version);
+    for (auto ext : fileExtensions) {
+        Project p("empty_project" + ext);
 
         ASSERT_TRUE(p.load());
 
@@ -99,11 +98,6 @@ TEST(LoadProjectTest, DownloadDefaultProject)
     };
     static const std::vector<std::string> assetData = { "a", "b", "c", "d", "e" };
 
-    EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(true));
-    EXPECT_CALL(*downloader, json()).WillOnce(ReturnRef(data));
-    p.detectScratchVersion();
-    ASSERT_EQ(p.scratchVersion, ScratchVersion::Scratch3);
-
     EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(true));
     EXPECT_CALL(*downloader, json()).WillOnce(ReturnRef(data));
     EXPECT_CALL(*downloader, downloadAssets(assets)).WillOnce(Return(true));
@@ -168,15 +162,8 @@ TEST(LoadProjectTest, DownloadDefaultProjectFailure)
     static const std::vector<std::string> assetData = { "a", "b", "c", "d", "e" };
 
     EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(false));
-    p.detectScratchVersion();
-    ASSERT_EQ(p.scratchVersion, ScratchVersion::Invalid);
     ASSERT_FALSE(p.load());
 
-    EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(true));
-    EXPECT_CALL(*downloader, json()).WillOnce(ReturnRef(data));
-    p.detectScratchVersion();
-    ASSERT_EQ(p.scratchVersion, ScratchVersion::Scratch3);
-
     EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(false));
     ASSERT_FALSE(p.load());
 
@@ -195,8 +182,8 @@ TEST(LoadProjectTest, DownloadDefaultProjectFailure)
 TEST(LoadProjectTest, LoadTestProject)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        Project p("load_test" + fileExtensions[i], version);
+    for (auto ext : fileExtensions) {
+        Project p("load_test" + ext);
 
         ASSERT_TRUE(p.load());
 
@@ -647,8 +634,8 @@ TEST(LoadProjectTest, LoadTestProject)
 TEST(LoadProjectTest, LoadTopLevelReporterProject)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        Project p("top_level_reporter" + fileExtensions[i], version);
+    for (auto ext : fileExtensions) {
+        Project p("top_level_reporter" + ext);
 
         ASSERT_TRUE(p.load());
 
@@ -688,11 +675,10 @@ TEST(LoadProjectTest, LoadTopLevelReporterProject)
 TEST(LoadProjectTest, ProjectTest)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        std::string name = "load_test" + fileExtensions[i];
-        Project p(name, version);
+    for (auto ext : fileExtensions) {
+        std::string name = "load_test" + ext;
+        Project p(name);
         ASSERT_EQ(p.fileName(), name);
-        ASSERT_EQ(p.scratchVersion(), version);
         ASSERT_TRUE(p.load());
 
         auto engine = p.engine();
@@ -709,15 +695,6 @@ TEST(LoadProjectTest, ProjectTest)
     }
 }
 
-TEST(LoadProjectTest, ProjectInvalidTest)
-{
-    std::string name = "load_test.sb3";
-    Project p(name, ScratchVersion::Invalid);
-    ASSERT_EQ(p.fileName(), name);
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Invalid);
-    ASSERT_FALSE(p.load());
-}
-
 TEST(LoadProjectTest, LoadNullDimensionMonitor)
 {
     // Regtest for #448
diff --git a/test/project/project_test.cpp b/test/project/project_test.cpp
index c4346a22..93f350f2 100644
--- a/test/project/project_test.cpp
+++ b/test/project/project_test.cpp
@@ -24,35 +24,16 @@ TEST_F(ProjectTest, Constructors)
     // Constructor 1
     Project p1;
     ASSERT_EQ(p1.fileName(), "");
-    ASSERT_EQ(p1.scratchVersion(), ScratchVersion::Invalid);
     ASSERT_TRUE(p1.engine());
 
     // Constructor 2
     Project p2("nonexistent.sb3");
     ASSERT_EQ(p2.fileName(), "nonexistent.sb3");
-    ASSERT_EQ(p2.scratchVersion(), ScratchVersion::Invalid);
     ASSERT_TRUE(p2.engine());
 
     Project p3("default_project.sb3");
     ASSERT_EQ(p3.fileName(), "default_project.sb3");
-    ASSERT_EQ(p3.scratchVersion(), ScratchVersion::Scratch3);
     ASSERT_TRUE(p3.engine());
-
-    // Constructor 3
-    Project p4("nonexistent.sb3", ScratchVersion::Scratch3);
-    ASSERT_EQ(p4.fileName(), "nonexistent.sb3");
-    ASSERT_EQ(p4.scratchVersion(), ScratchVersion::Scratch3);
-    ASSERT_TRUE(p4.engine());
-
-    Project p5("default_project.sb3", ScratchVersion::Scratch3);
-    ASSERT_EQ(p5.fileName(), "default_project.sb3");
-    ASSERT_EQ(p5.scratchVersion(), ScratchVersion::Scratch3);
-    ASSERT_TRUE(p5.engine());
-
-    Project p6("default_project.sb3", ScratchVersion::Invalid);
-    ASSERT_EQ(p6.fileName(), "default_project.sb3");
-    ASSERT_EQ(p6.scratchVersion(), ScratchVersion::Invalid);
-    ASSERT_TRUE(p6.engine());
 }
 
 TEST_F(ProjectTest, Load)
@@ -89,37 +70,6 @@ TEST_F(ProjectTest, Load)
     EXPECT_CALL(*m_engine, compile).Times(1);
     ASSERT_TRUE(p3.load());
 
-    // Constructor 3
-    ProjectPrivate p4("nonexistent.sb3", ScratchVersion::Scratch3);
-    p4.engine = m_engine;
-    EXPECT_CALL(*m_engine, clear).Times(0);
-    EXPECT_CALL(*m_engine, setTargets).Times(0);
-    EXPECT_CALL(*m_engine, setBroadcasts).Times(0);
-    EXPECT_CALL(*m_engine, setMonitors).Times(0);
-    EXPECT_CALL(*m_engine, setExtensions).Times(0);
-    EXPECT_CALL(*m_engine, compile).Times(0);
-    ASSERT_FALSE(p4.load());
-
-    ProjectPrivate p5("default_project.sb3", ScratchVersion::Scratch3);
-    p5.engine = m_engine;
-    EXPECT_CALL(*m_engine, clear).Times(1);
-    EXPECT_CALL(*m_engine, setTargets).Times(1);
-    EXPECT_CALL(*m_engine, setBroadcasts).Times(1);
-    EXPECT_CALL(*m_engine, setMonitors).Times(1);
-    EXPECT_CALL(*m_engine, setExtensions).Times(1);
-    EXPECT_CALL(*m_engine, compile).Times(1);
-    ASSERT_TRUE(p5.load());
-
-    ProjectPrivate p6("default_project.sb3", ScratchVersion::Invalid);
-    p6.engine = m_engine;
-    EXPECT_CALL(*m_engine, clear).Times(0);
-    EXPECT_CALL(*m_engine, setTargets).Times(0);
-    EXPECT_CALL(*m_engine, setBroadcasts).Times(0);
-    EXPECT_CALL(*m_engine, setMonitors).Times(0);
-    EXPECT_CALL(*m_engine, setExtensions).Times(0);
-    EXPECT_CALL(*m_engine, compile).Times(0);
-    ASSERT_FALSE(p6.load());
-
     testing::Mock::AllowLeak(m_engine.get());
 }
 
@@ -146,17 +96,9 @@ TEST_F(ProjectTest, FileName)
     Project p;
     p.setFileName("test.sb3");
     ASSERT_EQ(p.fileName(), "test.sb3");
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Invalid);
 
     p.setFileName("default_project.sb3");
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Scratch3);
-}
-
-TEST_F(ProjectTest, ScratchVersion)
-{
-    Project p;
-    p.setScratchVersion(ScratchVersion::Scratch3);
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Scratch3);
+    ASSERT_EQ(p.fileName(), "default_project.sb3");
 }
 
 TEST(LoadProjectTest, DownloadProgressChanged)

From 01c544fb1da3e3512efb5c0964c3ecbfd0ffd556 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 14:32:06 +0200
Subject: [PATCH 45/71] Add top level block position API

---
 include/scratchcpp/block.h          |  6 ++++++
 src/scratch/block.cpp               | 30 +++++++++++++++++++++++++++++
 src/scratch/block_p.h               |  2 ++
 test/scratch_classes/block_test.cpp | 18 +++++++++++++++++
 4 files changed, 56 insertions(+)

diff --git a/include/scratchcpp/block.h b/include/scratchcpp/block.h
index 02b7ddeb..fe6cf382 100644
--- a/include/scratchcpp/block.h
+++ b/include/scratchcpp/block.h
@@ -56,6 +56,12 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
 
         bool topLevel() const;
 
+        int x() const;
+        void setX(int x);
+
+        int y() const;
+        void setY(int y);
+
         std::shared_ptr<Comment> comment() const;
         const std::string &commentId() const;
         void setComment(std::shared_ptr<Comment> comment);
diff --git a/src/scratch/block.cpp b/src/scratch/block.cpp
index 6ce51593..0350ccd4 100644
--- a/src/scratch/block.cpp
+++ b/src/scratch/block.cpp
@@ -313,6 +313,36 @@ bool Block::topLevel() const
     return (impl->parentId == "" && !impl->parent);
 }
 
+/*! Returns the X-coordinate of the block in the code area (only for top level blocks). */
+int Block::x() const
+{
+    return impl->x;
+}
+
+/*! Sets the X-coordinate of the block in the code area (only for top level blocks). */
+void Block::setX(int x)
+{
+    if (!topLevel())
+        std::cout << "warning: setting X-coordinate of a block which is not a top level block" << std::endl;
+
+    impl->x = x;
+}
+
+/*! Returns the Y-coordinate of the block in the code area (only for top level blocks). */
+int Block::y() const
+{
+    return impl->y;
+}
+
+/*! Sets the Y-coordinate of the block in the code area (only for top level blocks). */
+void Block::setY(int y)
+{
+    if (!topLevel())
+        std::cout << "warning: setting Y-coordinate of a block which is not a top level block" << std::endl;
+
+    impl->y = y;
+}
+
 /*! Returns the comment which is attached to this block. */
 std::shared_ptr<Comment> Block::comment() const
 {
diff --git a/src/scratch/block_p.h b/src/scratch/block_p.h
index 215d3bbd..a1aecb7b 100644
--- a/src/scratch/block_p.h
+++ b/src/scratch/block_p.h
@@ -33,6 +33,8 @@ struct BlockPrivate
         std::vector<std::shared_ptr<Field>> fields;
         std::unordered_map<int, Field *> fieldMap;
         bool shadow = false;
+        int x = 0;
+        int y = 0;
         std::string commentId;
         std::shared_ptr<Comment> comment = nullptr;
         IEngine *engine = nullptr;
diff --git a/test/scratch_classes/block_test.cpp b/test/scratch_classes/block_test.cpp
index 905f5c64..a0b4545c 100644
--- a/test/scratch_classes/block_test.cpp
+++ b/test/scratch_classes/block_test.cpp
@@ -194,6 +194,24 @@ TEST_F(BlockTest, TopLevel)
     ASSERT_TRUE(block.topLevel());
 }
 
+TEST_F(BlockTest, X)
+{
+    Block block("", "");
+    ASSERT_EQ(block.x(), 0);
+
+    block.setX(12);
+    ASSERT_EQ(block.x(), 12);
+}
+
+TEST_F(BlockTest, Y)
+{
+    Block block("", "");
+    ASSERT_EQ(block.y(), 0);
+
+    block.setY(8);
+    ASSERT_EQ(block.y(), 8);
+}
+
 TEST_F(BlockTest, Comment)
 {
     Block block("", "");

From 30f7819c09d85c499daae9223bc10fe05d403ac2 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 15:29:47 +0200
Subject: [PATCH 46/71] Load coordinates of top level blocks

---
 src/internal/scratch3reader.cpp         |  14 ++++++++++++++
 test/load_project/load_project_test.cpp |  21 ++++++++++++++++++++-
 test/load_test.sb3                      | Bin 48599 -> 48710 bytes
 3 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/internal/scratch3reader.cpp b/src/internal/scratch3reader.cpp
index 14f6065b..8f2ec4c0 100644
--- a/src/internal/scratch3reader.cpp
+++ b/src/internal/scratch3reader.cpp
@@ -92,6 +92,9 @@ bool Scratch3Reader::load()
                     reporterInfo->setValueId(jsonToValue(blockInfo[2]).toString());
                     reporterInfo->setType(static_cast<InputValue::Type>(blockInfo[0]));
 
+                    block->setX(blockInfo[3]);
+                    block->setY(blockInfo[4]);
+
                     target->addBlock(block);
                     continue;
                 }
@@ -108,6 +111,17 @@ bool Scratch3Reader::load()
                 if (!blockInfo["parent"].is_null())
                     parentId = blockInfo["parent"];
                 block->setParentId(parentId);
+                READER_STEP(step, "target -> block -> parent");
+                if (!blockInfo["parent"].is_null())
+                    parentId = blockInfo["parent"];
+                block->setParentId(parentId);
+
+                if (block->topLevel()) {
+                    READER_STEP(step, "target -> block -> x");
+                    block->setX(blockInfo["x"]);
+                    READER_STEP(step, "target -> block -> y");
+                    block->setY(blockInfo["y"]);
+                }
 
                 // inputs
                 READER_STEP(step, "target -> block -> inputs");
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index c7a505ff..1830b446 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -228,7 +228,7 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_EQ(sprite1->name(), "Sprite1");
         ASSERT_EQ(sprite1->variables().size(), 1);
         ASSERT_EQ(sprite1->lists().size(), 1);
-        ASSERT_EQ(sprite1->blocks().size(), 18);
+        ASSERT_EQ(sprite1->blocks().size(), 19);
         ASSERT_EQ(sprite1->costumes().size(), 2);
         ASSERT_EQ(sprite1->comments().size(), 1);
         ASSERT_EQ(sprite1->costumeIndex(), 1);
@@ -278,6 +278,8 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_TRUE(sprite1->greenFlagBlocks()[0]);
         ASSERT_FALSE(sprite1->greenFlagBlocks()[0]->isTopLevelReporter());
         ASSERT_EQ(sprite1->greenFlagBlocks()[0]->opcode(), "event_whenflagclicked");
+        ASSERT_EQ(sprite1->greenFlagBlocks()[0]->x(), 0);
+        ASSERT_EQ(sprite1->greenFlagBlocks()[0]->y(), 0);
         auto block = sprite1->greenFlagBlocks()[0]->next();
         ASSERT_TRUE(block);
         ASSERT_EQ(block->parent(), sprite1->greenFlagBlocks()[0]);
@@ -343,6 +345,8 @@ TEST(LoadProjectTest, LoadTestProject)
             }
         }
         ASSERT_TRUE(defineBlock);
+        ASSERT_EQ(defineBlock->x(), 0);
+        ASSERT_EQ(defineBlock->y(), 384);
         ASSERT_INPUT(defineBlock, "custom_block");
         auto blockPrototype = GET_INPUT(defineBlock, "custom_block")->valueBlock();
         ASSERT_TRUE(blockPrototype);
@@ -372,6 +376,17 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_TRUE(argBlock);
         ASSERT_EQ(argBlock->opcode(), "argument_reporter_string_number");
 
+        std::shared_ptr<Block> keyPressedBlock = nullptr;
+        for (auto b : blocks) {
+            if (b->opcode() == "event_whenkeypressed") {
+                keyPressedBlock = b;
+                break;
+            }
+        }
+        ASSERT_TRUE(keyPressedBlock);
+        ASSERT_EQ(keyPressedBlock->x(), 488);
+        ASSERT_EQ(keyPressedBlock->y(), 152);
+
         // Balloon1
         ASSERT_NE(engine->findTarget("Balloon1"), -1);
         Sprite *sprite2 = dynamic_cast<Sprite *>(engine->targetAt(engine->findTarget("Balloon1")));
@@ -651,6 +666,8 @@ TEST(LoadProjectTest, LoadTopLevelReporterProject)
         auto block1 = sprite1->blockAt(0);
         ASSERT_TRUE(block1);
         ASSERT_TRUE(block1->isTopLevelReporter());
+        ASSERT_EQ(block1->x(), 335);
+        ASSERT_EQ(block1->y(), 335);
         InputValue *reporterInfo = block1->topLevelReporterInfo();
         ASSERT_TRUE(reporterInfo);
         ASSERT_EQ(reporterInfo->type(), InputValue::Type::Variable);
@@ -661,6 +678,8 @@ TEST(LoadProjectTest, LoadTopLevelReporterProject)
         auto block2 = sprite1->blockAt(1);
         ASSERT_TRUE(block2);
         ASSERT_TRUE(block2->isTopLevelReporter());
+        ASSERT_EQ(block2->x(), 313);
+        ASSERT_EQ(block2->y(), 435);
         reporterInfo = block2->topLevelReporterInfo();
         ASSERT_TRUE(reporterInfo);
         ASSERT_EQ(reporterInfo->type(), InputValue::Type::List);
diff --git a/test/load_test.sb3 b/test/load_test.sb3
index d1553e8e271ee74c1c26c944f535ca58e3104ac1..eeaa571f3e30bdd738e9792e91166c89f5afc10d 100644
GIT binary patch
delta 3146
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

delta 3030
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
X?gl{?YT(b6XwPmpB>-?x_mlk_A-9Jx


From a62a07cf2eeae634d1d41b9fb8f63a2d248c7308 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 16:35:06 +0200
Subject: [PATCH 47/71] Avoid copying in ZipReader::readFileToString()

Resolves: #290
---
 src/internal/scratch3reader.cpp |  4 +++-
 src/internal/zipreader.cpp      | 11 ++++-------
 src/internal/zipreader.h        |  2 +-
 test/zip/zip_test.cpp           |  4 +++-
 4 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/internal/scratch3reader.cpp b/src/internal/scratch3reader.cpp
index 8f2ec4c0..1e4b9916 100644
--- a/src/internal/scratch3reader.cpp
+++ b/src/internal/scratch3reader.cpp
@@ -558,7 +558,9 @@ void Scratch3Reader::read()
     if (m_zipReader->open()) {
         // Parse the JSON
         try {
-            m_json = json::parse(m_zipReader->readFileToString("project.json"));
+            std::string jsonStr;
+            m_zipReader->readFileToString("project.json", jsonStr);
+            m_json = json::parse(jsonStr);
         } catch (std::exception &e) {
             printErr("invalid JSON file", e.what());
         }
diff --git a/src/internal/zipreader.cpp b/src/internal/zipreader.cpp
index ae0358b0..fd8a48db 100644
--- a/src/internal/zipreader.cpp
+++ b/src/internal/zipreader.cpp
@@ -48,17 +48,14 @@ size_t ZipReader::readFile(const std::string &fileName, void **buf)
     return bufsize;
 }
 
-std::string ZipReader::readFileToString(const std::string &fileName)
+void ZipReader::readFileToString(const std::string &fileName, std::string &dst)
 {
     void *buf = nullptr;
     size_t bufsize = readFile(fileName, &buf);
 
     if (buf) {
-        std::string ret(reinterpret_cast<char *>(buf), bufsize);
+        dst.assign(reinterpret_cast<char *>(buf), bufsize);
         free(buf);
-
-        return ret;
-    }
-
-    return "";
+    } else
+        dst = "";
 }
diff --git a/src/internal/zipreader.h b/src/internal/zipreader.h
index 9c9db512..546aec69 100644
--- a/src/internal/zipreader.h
+++ b/src/internal/zipreader.h
@@ -20,7 +20,7 @@ class ZipReader
         void close();
 
         size_t readFile(const std::string &fileName, void **buf);
-        std::string readFileToString(const std::string &fileName);
+        void readFileToString(const std::string &fileName, std::string &dst);
 
     private:
         std::string m_fileName;
diff --git a/test/zip/zip_test.cpp b/test/zip/zip_test.cpp
index 666cfae7..a2a50576 100644
--- a/test/zip/zip_test.cpp
+++ b/test/zip/zip_test.cpp
@@ -8,7 +8,9 @@ inline std::string readSb3Json(const std::string &fileName)
     ZipReader reader(fileName);
     reader.open();
 
-    return reader.readFileToString("project.json");
+    std::string ret;
+    reader.readFileToString("project.json", ret);
+    return ret;
 }
 
 TEST(ZipTest, NonexistentProject)

From 7d86ce280d47d3695b801f534138ee26bd631bed Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 18:27:24 +0200
Subject: [PATCH 48/71] Add API for unsupported blocks to Compiler

---
 include/scratchcpp/compiler.h   |  3 +++
 src/engine/compiler.cpp         | 12 +++++++++++-
 src/engine/compiler_p.h         |  3 +++
 test/compiler/compiler_test.cpp | 32 ++++++++++++++++++++++++++++++++
 4 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/compiler.h b/include/scratchcpp/compiler.h
index a8b852bb..05ab0c7c 100644
--- a/include/scratchcpp/compiler.h
+++ b/include/scratchcpp/compiler.h
@@ -4,6 +4,7 @@
 
 #include <vector>
 #include <memory>
+#include <unordered_set>
 
 #include "global.h"
 #include "spimpl.h"
@@ -82,6 +83,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         BlockPrototype *procedurePrototype() const;
         void setProcedurePrototype(BlockPrototype *prototype);
 
+        const std::unordered_set<std::string> &unsupportedBlocks() const;
+
     private:
         spimpl::unique_impl_ptr<CompilerPrivate> impl;
 };
diff --git a/src/engine/compiler.cpp b/src/engine/compiler.cpp
index 0f549af6..2ff823ba 100644
--- a/src/engine/compiler.cpp
+++ b/src/engine/compiler.cpp
@@ -66,8 +66,10 @@ void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
 
         if (impl->block->compileFunction())
             impl->block->compile(this);
-        else
+        else {
             std::cout << "warning: unsupported block: " << impl->block->opcode() << std::endl;
+            impl->unsupportedBlocks.insert(impl->block->opcode());
+        }
 
         if (substacks != impl->substackTree.size())
             continue;
@@ -186,6 +188,7 @@ void Compiler::addInput(Input *input)
                         impl->block->compile(this);
                     else {
                         std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                        impl->unsupportedBlocks.insert(impl->block->opcode());
                         addInstruction(OP_NULL);
                     }
                 } else
@@ -205,6 +208,7 @@ void Compiler::addInput(Input *input)
                     impl->block->compile(this);
                 else {
                     std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                    impl->unsupportedBlocks.insert(impl->block->opcode());
                     addInstruction(OP_NULL);
                 }
             } else
@@ -356,6 +360,12 @@ void Compiler::setProcedurePrototype(BlockPrototype *prototype)
     impl->procedurePrototype = prototype;
 }
 
+/*! Returns unsupported block opcodes which were found when compiling. */
+const std::unordered_set<std::string> &libscratchcpp::Compiler::unsupportedBlocks() const
+{
+    return impl->unsupportedBlocks;
+}
+
 /*! Returns the list of custom block prototypes. */
 const std::vector<std::string> &Compiler::procedures() const
 {
diff --git a/src/engine/compiler_p.h b/src/engine/compiler_p.h
index a310eb47..5a396a7a 100644
--- a/src/engine/compiler_p.h
+++ b/src/engine/compiler_p.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <unordered_map>
+#include <unordered_set>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/inputvalue.h>
 
@@ -38,6 +39,8 @@ struct CompilerPrivate
         std::unordered_map<std::string, std::vector<std::string>> procedureArgs;
         BlockPrototype *procedurePrototype = nullptr;
         bool warp = false;
+
+        std::unordered_set<std::string> unsupportedBlocks;
 };
 
 } // namespace libscratchcpp
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index e4691a78..e4f3fea5 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -300,6 +300,7 @@ TEST_F(CompilerTest, AddObscuredInput)
 
     compiler.addInstruction(vm::OP_HALT);
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2" }));
 }
 
 TEST_F(CompilerTest, AddNoShadowInput)
@@ -328,6 +329,14 @@ TEST_F(CompilerTest, AddNoShadowInput)
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues().size(), 1);
     ASSERT_EQ(compiler.constValues()[0], "test");
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2" }));
+
+    Input input4("TEST_INPUT4", Input::Type::NoShadow);
+    std::shared_ptr<Block> block3 = std::make_shared<Block>("", "test_block3");
+    input4.setValueBlock(block3);
+    compiler.addInput(&input4);
+    compiler.addInstruction(vm::OP_PRINT);
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2", "test_block3" }));
 }
 
 TEST_F(CompilerTest, ResolveInput)
@@ -841,3 +850,26 @@ TEST_F(CompilerTest, EdgeActivatedHatPredicate)
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 1, vm::OP_PRINT, vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues(), std::vector<Value>({ true, "test" }));
 }
+
+TEST_F(CompilerTest, UnsupportedBlocks)
+{
+    auto block1 = std::make_shared<Block>("b1", "block1");
+
+    auto block2 = std::make_shared<Block>("b2", "block2");
+    block2->setParent(block1);
+    block1->setNext(block2);
+
+    auto block3 = std::make_shared<Block>("b3", "block3");
+    block3->setCompileFunction([](Compiler *) {});
+    block3->setParent(block2);
+    block2->setNext(block3);
+
+    auto block4 = std::make_shared<Block>("b4", "block4");
+    block4->setParent(block3);
+    block3->setNext(block4);
+
+    INIT_COMPILER(engine, compiler);
+    compiler.compile(block1);
+
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "block4" }));
+}

From f3bc87ffa317a870f8b0233a60e7908773d7f5fa Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 19:09:10 +0200
Subject: [PATCH 49/71] Do not compile top level reporter blocks

There's no reason to support this yet
---
 src/engine/internal/engine.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 216dc97b..64495178 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -265,7 +265,7 @@ void Engine::compile()
         Compiler compiler(this, target.get());
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
-            if (block->topLevel() && !block->shadow()) {
+            if (block->topLevel() && !block->isTopLevelReporter() && !block->shadow()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
                     auto script = std::make_shared<Script>(target.get(), block, this);

From 6037520d3a6fb8ed2b1a6c0027d787ec5bddf760 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 19:09:38 +0200
Subject: [PATCH 50/71] Add API for unsupported blocks to IEngine

---
 include/scratchcpp/iengine.h   |   4 ++++
 src/engine/internal/engine.cpp |  25 +++++++++++++++++++++++--
 src/engine/internal/engine.h   |   4 ++++
 test/engine/engine_test.cpp    |   9 +++++++++
 test/mocks/enginemock.h        |   2 ++
 test/unsupported_blocks.sb3    | Bin 0 -> 2106 bytes
 6 files changed, 42 insertions(+), 2 deletions(-)
 create mode 100644 test/unsupported_blocks.sb3

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 2372d42c..aa5aac94 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -5,6 +5,7 @@
 #include <memory>
 #include <vector>
 #include <unordered_map>
+#include <unordered_set>
 #include <functional>
 
 #include "global.h"
@@ -390,6 +391,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
 
         /*! Sets the user agent of the last person to edit the project. */
         virtual void setUserAgent(const std::string &agent) = 0;
+
+        /*! Returns the unsupported block opcodes which were found when compiling. */
+        virtual const std::unordered_set<std::string> &unsupportedBlocks() const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 64495178..9f321549 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -95,6 +95,8 @@ void Engine::clear()
     m_edgeActivatedHatValues.clear();
 
     m_running = false;
+
+    m_unsupportedBlocks.clear();
 }
 
 // Resolves ID references and sets pointers of entities.
@@ -280,8 +282,10 @@ void Engine::compile()
                         auto b = block->inputAt(block->findInput("custom_block"))->valueBlock();
                         procedureBytecodeMap[b->mutationPrototype()->procCode()] = script->bytecode();
                     }
-                } else
+                } else {
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
+                    m_unsupportedBlocks.insert(block->opcode());
+                }
             }
         }
 
@@ -298,6 +302,11 @@ void Engine::compile()
                 m_scripts[block]->setLists(compiler.lists());
             }
         }
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
     }
 
     // Compile monitor blocks to bytecode
@@ -343,8 +352,15 @@ void Engine::compile()
             script->setConstValues(compiler.constValues());
             script->setVariables(compiler.variables());
             script->setLists(compiler.lists());
-        } else
+        } else {
             std::cout << "warning: unsupported monitor block: " << block->opcode() << std::endl;
+            m_unsupportedBlocks.insert(block->opcode());
+        }
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
     }
 }
 
@@ -1622,6 +1638,11 @@ void Engine::setUserAgent(const std::string &agent)
     m_userAgent = agent;
 }
 
+const std::unordered_set<std::string> &Engine::unsupportedBlocks() const
+{
+    return m_unsupportedBlocks;
+}
+
 void Engine::finalize()
 {
     m_eventLoopMutex.lock();
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index d04f71f3..48a49708 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -168,6 +168,8 @@ class Engine : public IEngine
         const std::string &userAgent() const override;
         void setUserAgent(const std::string &agent) override;
 
+        const std::unordered_set<std::string> &unsupportedBlocks() const override;
+
         IClock *m_clock = nullptr;
         IAudioEngine *m_audioEngine = nullptr;
 
@@ -287,6 +289,8 @@ class Engine : public IEngine
         sigslot::signal<const std::string &> m_questionAsked;
         sigslot::signal<> m_questionAborted;
         sigslot::signal<const std::string &> m_questionAnswered;
+
+        std::unordered_set<std::string> m_unsupportedBlocks;
 };
 
 } // namespace libscratchcpp
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 0d828a1b..a5cb7961 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -2133,6 +2133,15 @@ TEST(EngineTest, UserAgent)
     ASSERT_EQ(engine.userAgent(), "test");
 }
 
+TEST(EngineTest, UnsupportedBlocks)
+{
+    Project p("unsupported_blocks.sb3");
+    ASSERT_TRUE(p.load());
+    ASSERT_EQ(
+        p.engine()->unsupportedBlocks(),
+        std::unordered_set<std::string>({ "ev3_motorTurnClockwise", "ev3_motorSetPower", "ev3_getMotorPosition", "ev3_whenButtonPressed", "ev3_getBrightness", "ev3_getDistance" }));
+}
+
 TEST(EngineTest, NoCrashAfterStop)
 {
     // Regtest for #186
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index c64691f6..deddb32f 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -144,6 +144,8 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(const std::string &, userAgent, (), (const, override));
         MOCK_METHOD(void, setUserAgent, (const std::string &), (override));
+
+        MOCK_METHOD(const std::unordered_set<std::string> &, unsupportedBlocks, (), (const, override));
 };
 
 } // namespace libscratchcpp
diff --git a/test/unsupported_blocks.sb3 b/test/unsupported_blocks.sb3
new file mode 100644
index 0000000000000000000000000000000000000000..7098a6541e5407b4cd03d024d87b350443ce34ee
GIT binary patch
literal 2106
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
bJs|!6^Bzlc{)0^b0CbS42Q^3V-`&3e4sy|z

literal 0
HcmV?d00001


From edb788ee2ba92328c68973312c468fc003ea2dcb Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 20:03:30 +0200
Subject: [PATCH 51/71] Fix top level blocks without a position

---
 src/internal/scratch3reader.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/internal/scratch3reader.cpp b/src/internal/scratch3reader.cpp
index 1e4b9916..203cf9b6 100644
--- a/src/internal/scratch3reader.cpp
+++ b/src/internal/scratch3reader.cpp
@@ -92,8 +92,10 @@ bool Scratch3Reader::load()
                     reporterInfo->setValueId(jsonToValue(blockInfo[2]).toString());
                     reporterInfo->setType(static_cast<InputValue::Type>(blockInfo[0]));
 
-                    block->setX(blockInfo[3]);
-                    block->setY(blockInfo[4]);
+                    if (blockInfo.size() > 3) {
+                        block->setX(blockInfo[3]);
+                        block->setY(blockInfo[4]);
+                    }
 
                     target->addBlock(block);
                     continue;
@@ -118,9 +120,11 @@ bool Scratch3Reader::load()
 
                 if (block->topLevel()) {
                     READER_STEP(step, "target -> block -> x");
-                    block->setX(blockInfo["x"]);
+                    if (!blockInfo["x"].is_null())
+                        block->setX(blockInfo["x"]);
                     READER_STEP(step, "target -> block -> y");
-                    block->setY(blockInfo["y"]);
+                    if (!blockInfo["y"].is_null())
+                        block->setY(blockInfo["y"]);
                 }
 
                 // inputs

From 421ef30374d1fc0a86c71b0507800ac48d9137f0 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 24 Aug 2024 16:01:56 +0200
Subject: [PATCH 52/71] Engine: Allow getting comments in getEntity()

---
 src/engine/internal/engine.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 9f321549..f8741e98 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1506,6 +1506,11 @@ std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
     if (broadcast)
         return std::static_pointer_cast<Entity>(broadcast);
 
+    // Comments
+    auto comment = getComment(id);
+    if (comment)
+        return std::static_pointer_cast<Entity>(comment);
+
     return nullptr;
 }
 

From 3402d16e0523ce511aa360fc88598f66f39fffb4 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 24 Aug 2024 16:26:59 +0200
Subject: [PATCH 53/71] Engine: Loop through blocks later in getEntity()

---
 src/engine/internal/engine.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index f8741e98..07c9d250 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1486,11 +1486,6 @@ std::shared_ptr<Comment> Engine::getComment(const std::string &id)
 // Returns the entity with the given ID. \see IEntity
 std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
 {
-    // Blocks
-    auto block = getBlock(id);
-    if (block)
-        return std::static_pointer_cast<Entity>(block);
-
     // Variables
     auto variable = getVariable(id);
     if (variable)
@@ -1506,6 +1501,11 @@ std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
     if (broadcast)
         return std::static_pointer_cast<Entity>(broadcast);
 
+    // Blocks
+    auto block = getBlock(id);
+    if (block)
+        return std::static_pointer_cast<Entity>(block);
+
     // Comments
     auto comment = getComment(id);
     if (comment)

From 3e5c33dd5eac0051920299bcf8695aab6ad9af55 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 24 Aug 2024 16:30:54 +0200
Subject: [PATCH 54/71] Engine: Optimize get entity methods by passing target

---
 src/engine/internal/engine.cpp | 54 +++++++++++++++++++++++-----------
 src/engine/internal/engine.h   |  6 ++--
 2 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 07c9d250..fda0004e 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -107,8 +107,8 @@ void Engine::resolveIds()
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
             auto container = blockSectionContainer(block->opcode());
-            block->setNext(getBlock(block->nextId()));
-            block->setParent(getBlock(block->parentId()));
+            block->setNext(getBlock(block->nextId(), target.get()));
+            block->setParent(getBlock(block->parentId(), target.get()));
 
             if (container) {
                 block->setCompileFunction(container->resolveBlockCompileFunc(block->opcode()));
@@ -117,16 +117,16 @@ void Engine::resolveIds()
 
             const auto &inputs = block->inputs();
             for (const auto &input : inputs) {
-                input->setValueBlock(getBlock(input->valueBlockId()));
+                input->setValueBlock(getBlock(input->valueBlockId(), target.get()));
 
                 if (container)
                     input->setInputId(container->resolveInput(input->name()));
 
                 InputValue *value = input->primaryValue();
                 std::string id = value->valueId(); // no reference!
-                value->setValuePtr(getEntity(id));
+                value->setValuePtr(getEntity(id, target.get()));
                 assert(input->secondaryValue()->type() != InputValue::Type::Variable && input->secondaryValue()->type() != InputValue::Type::List); // secondary values never have a variable or list
-                input->secondaryValue()->setValuePtr(getEntity(input->secondaryValue()->valueId()));
+                input->secondaryValue()->setValuePtr(getEntity(input->secondaryValue()->valueId(), target.get()));
 
                 // Add missing variables and lists
                 if (!value->valuePtr()) {
@@ -149,7 +149,7 @@ void Engine::resolveIds()
             const auto &fields = block->fields();
             for (auto field : fields) {
                 std::string id = field->valueId(); // no reference!
-                field->setValuePtr(getEntity(id));
+                field->setValuePtr(getEntity(id, target.get()));
 
                 if (container) {
                     field->setFieldId(container->resolveField(field->name()));
@@ -179,7 +179,7 @@ void Engine::resolveIds()
             block->updateInputMap();
             block->updateFieldMap();
 
-            auto comment = getComment(block->commentId());
+            auto comment = getComment(block->commentId(), target.get());
             block->setComment(comment);
 
             if (comment) {
@@ -209,7 +209,7 @@ void Engine::resolveIds()
         assert(target);
 
         for (auto field : fields) {
-            field->setValuePtr(getEntity(field->valueId()));
+            field->setValuePtr(getEntity(field->valueId(), target));
 
             if (container) {
                 field->setFieldId(container->resolveField(field->name()));
@@ -1411,17 +1411,27 @@ const std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> &Engin
 }
 
 // Returns the block with the given ID.
-std::shared_ptr<Block> Engine::getBlock(const std::string &id)
+std::shared_ptr<Block> Engine::getBlock(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findBlock(id);
+    int index;
+
+    if (target) {
+        index = target->findBlock(id);
+
         if (index != -1)
             return target->blockAt(index);
     }
 
+    for (auto t : m_targets) {
+        index = t->findBlock(id);
+
+        if (index != -1)
+            return t->blockAt(index);
+    }
+
     return nullptr;
 }
 
@@ -1469,22 +1479,32 @@ std::shared_ptr<Broadcast> Engine::getBroadcast(const std::string &id)
 }
 
 // Returns the comment with the given ID.
-std::shared_ptr<Comment> Engine::getComment(const std::string &id)
+std::shared_ptr<Comment> Engine::getComment(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findComment(id);
+    int index;
+
+    if (target) {
+        index = target->findComment(id);
+
         if (index != -1)
             return target->commentAt(index);
     }
 
+    for (auto t : m_targets) {
+        index = t->findComment(id);
+
+        if (index != -1)
+            return t->commentAt(index);
+    }
+
     return nullptr;
 }
 
 // Returns the entity with the given ID. \see IEntity
-std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
+std::shared_ptr<Entity> Engine::getEntity(const std::string &id, Target *target)
 {
     // Variables
     auto variable = getVariable(id);
@@ -1502,12 +1522,12 @@ std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
         return std::static_pointer_cast<Entity>(broadcast);
 
     // Blocks
-    auto block = getBlock(id);
+    auto block = getBlock(id, target);
     if (block)
         return std::static_pointer_cast<Entity>(block);
 
     // Comments
-    auto comment = getComment(id);
+    auto comment = getComment(id, target);
     if (comment)
         return std::static_pointer_cast<Entity>(comment);
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 48a49708..8648d2dd 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -202,12 +202,12 @@ class Engine : public IEngine
         void removeExecutableClones();
         void createMissingMonitors();
         void addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *target);
-        std::shared_ptr<Block> getBlock(const std::string &id);
+        std::shared_ptr<Block> getBlock(const std::string &id, Target *target);
         std::shared_ptr<Variable> getVariable(const std::string &id);
         std::shared_ptr<List> getList(const std::string &id);
         std::shared_ptr<Broadcast> getBroadcast(const std::string &id);
-        std::shared_ptr<Comment> getComment(const std::string &id);
-        std::shared_ptr<Entity> getEntity(const std::string &id);
+        std::shared_ptr<Comment> getComment(const std::string &id, Target *target);
+        std::shared_ptr<Entity> getEntity(const std::string &id, Target *target);
         std::shared_ptr<IBlockSection> blockSection(const std::string &opcode) const;
 
         void addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script);

From 366e11d126808d960a0081b8f9c8cbefee49056e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 24 Aug 2024 16:45:11 +0200
Subject: [PATCH 55/71] fix #567: Fix variable and list lookup order

---
 src/engine/internal/engine.cpp                |  58 +++++++++++++++---
 src/engine/internal/engine.h                  |   4 +-
 test/engine/engine_test.cpp                   |  17 +++++
 .../567_duplicate_variable_list_id.sb3        | Bin 0 -> 1692 bytes
 4 files changed, 69 insertions(+), 10 deletions(-)
 create mode 100644 test/regtest_projects/567_duplicate_variable_list_id.sb3

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index fda0004e..448103e4 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1436,32 +1436,74 @@ std::shared_ptr<Block> Engine::getBlock(const std::string &id, Target *target)
 }
 
 // Returns the variable with the given ID.
-std::shared_ptr<Variable> Engine::getVariable(const std::string &id)
+std::shared_ptr<Variable> Engine::getVariable(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findVariableById(id);
+    Stage *stage = this->stage();
+    int index;
+
+    // Check stage
+    index = stage->findVariableById(id);
+
+    if (index != -1)
+        return stage->variableAt(index);
+
+    // Check currently compiled target
+    if (target != stage) {
+        index = target->findVariableById(id);
+
         if (index != -1)
             return target->variableAt(index);
     }
 
+    // Fall back to checking all the other targets
+    for (auto t : m_targets) {
+        if (t.get() != stage && t.get() != target) {
+            int index = t->findVariableById(id);
+
+            if (index != -1)
+                return t->variableAt(index);
+        }
+    }
+
     return nullptr;
 }
 
 // Returns the Scratch list with the given ID.
-std::shared_ptr<List> Engine::getList(const std::string &id)
+std::shared_ptr<List> Engine::getList(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findListById(id);
+    Stage *stage = this->stage();
+    int index;
+
+    // Check stage
+    index = stage->findListById(id);
+
+    if (index != -1)
+        return stage->listAt(index);
+
+    // Check currently compiled target
+    if (target != stage) {
+        index = target->findListById(id);
+
         if (index != -1)
             return target->listAt(index);
     }
 
+    // Fall back to checking all the other targets
+    for (auto t : m_targets) {
+        if (t.get() != stage && t.get() != target) {
+            int index = t->findListById(id);
+
+            if (index != -1)
+                return t->listAt(index);
+        }
+    }
+
     return nullptr;
 }
 
@@ -1507,12 +1549,12 @@ std::shared_ptr<Comment> Engine::getComment(const std::string &id, Target *targe
 std::shared_ptr<Entity> Engine::getEntity(const std::string &id, Target *target)
 {
     // Variables
-    auto variable = getVariable(id);
+    auto variable = getVariable(id, target);
     if (variable)
         return std::static_pointer_cast<Entity>(variable);
 
     // Lists
-    auto list = getList(id);
+    auto list = getList(id, target);
     if (list)
         return std::static_pointer_cast<Entity>(list);
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 8648d2dd..218dc9ba 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -203,8 +203,8 @@ class Engine : public IEngine
         void createMissingMonitors();
         void addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *target);
         std::shared_ptr<Block> getBlock(const std::string &id, Target *target);
-        std::shared_ptr<Variable> getVariable(const std::string &id);
-        std::shared_ptr<List> getList(const std::string &id);
+        std::shared_ptr<Variable> getVariable(const std::string &id, Target *target);
+        std::shared_ptr<List> getList(const std::string &id, Target *target);
         std::shared_ptr<Broadcast> getBroadcast(const std::string &id);
         std::shared_ptr<Comment> getComment(const std::string &id, Target *target);
         std::shared_ptr<Entity> getEntity(const std::string &id, Target *target);
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index a5cb7961..86670a44 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -2333,3 +2333,20 @@ TEST(EngineTest, AlwaysStopCloneThreads)
     ASSERT_VAR(stage, "test");
     ASSERT_EQ(GET_VAR(stage, "test")->value().toInt(), 0);
 }
+
+TEST(EngineTest, DuplicateVariableOrListIDs)
+{
+    // Regtest for #567
+    Project p("regtest_projects/567_duplicate_variable_list_id.sb3");
+    ASSERT_TRUE(p.load());
+
+    auto engine = p.engine();
+
+    Stage *stage = engine->stage();
+    ASSERT_TRUE(stage);
+
+    engine->run();
+
+    ASSERT_VAR(stage, "passed");
+    ASSERT_TRUE(GET_VAR(stage, "passed")->value().toBool());
+}
diff --git a/test/regtest_projects/567_duplicate_variable_list_id.sb3 b/test/regtest_projects/567_duplicate_variable_list_id.sb3
new file mode 100644
index 0000000000000000000000000000000000000000..f93d7535f991ed34c539b3fdc57353f9feeb22bc
GIT binary patch
literal 1692
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

literal 0
HcmV?d00001


From 23044db243547628fe4c7bca69663680c104e439 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 24 Aug 2024 17:27:16 +0200
Subject: [PATCH 56/71] fix #564: Do not use utf8cpp functions in value.h

---
 include/scratchcpp/value.h          | 3 +--
 src/engine/virtualmachine_p.cpp     | 1 +
 src/scratch/CMakeLists.txt          | 1 +
 src/scratch/value.cpp               | 9 +++++++++
 test/scratch_classes/value_test.cpp | 1 +
 5 files changed, 13 insertions(+), 2 deletions(-)
 create mode 100644 src/scratch/value.cpp

diff --git a/include/scratchcpp/value.h b/include/scratchcpp/value.h
index ebde5d1c..94baeb55 100644
--- a/include/scratchcpp/value.h
+++ b/include/scratchcpp/value.h
@@ -8,7 +8,6 @@
 #include <ctgmath>
 #include <cassert>
 #include <iomanip>
-#include <utf8.h>
 #include <iostream>
 #include <clocale>
 
@@ -370,7 +369,7 @@ class LIBSCRATCHCPP_EXPORT Value
         };
 
         /*! Returns the UTF-16 representation of the value. */
-        std::u16string toUtf16() const { return utf8::utf8to16(toString()); };
+        std::u16string toUtf16() const;
 
         /*! Adds the given value to the value. */
         void add(const Value &v)
diff --git a/src/engine/virtualmachine_p.cpp b/src/engine/virtualmachine_p.cpp
index 50397788..6f2c0e4f 100644
--- a/src/engine/virtualmachine_p.cpp
+++ b/src/engine/virtualmachine_p.cpp
@@ -6,6 +6,7 @@
 #include <scratchcpp/list.h>
 #include <iostream>
 #include <cassert>
+#include <utf8.h>
 
 #include "virtualmachine_p.h"
 #include "internal/randomgenerator.h"
diff --git a/src/scratch/CMakeLists.txt b/src/scratch/CMakeLists.txt
index 7d2d47e4..d317335a 100644
--- a/src/scratch/CMakeLists.txt
+++ b/src/scratch/CMakeLists.txt
@@ -1,5 +1,6 @@
 target_sources(scratchcpp
   PRIVATE
+    value.cpp
     target.cpp
     target_p.cpp
     target_p.h
diff --git a/src/scratch/value.cpp b/src/scratch/value.cpp
new file mode 100644
index 00000000..f3d8ad46
--- /dev/null
+++ b/src/scratch/value.cpp
@@ -0,0 +1,9 @@
+#include <scratchcpp/value.h>
+#include <utf8.h>
+
+using namespace libscratchcpp;
+
+std::u16string Value::toUtf16() const
+{
+    return utf8::utf8to16(toString());
+}
diff --git a/test/scratch_classes/value_test.cpp b/test/scratch_classes/value_test.cpp
index 97ab5a36..69ea1fa0 100644
--- a/test/scratch_classes/value_test.cpp
+++ b/test/scratch_classes/value_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/value.h>
+#include <utf8.h>
 
 #include "../common.h"
 

From ca1fc7e82334483072e8093fff6bf5248c72fa20 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 19:15:04 +0200
Subject: [PATCH 57/71] audio: Add pitch API

---
 src/audio/iaudioplayer.h               |  3 +++
 src/audio/internal/audioplayer.cpp     | 24 ++++++++++++++++++++++++
 src/audio/internal/audioplayer.h       |  4 ++++
 src/audio/internal/audioplayerstub.cpp | 10 ++++++++++
 src/audio/internal/audioplayerstub.h   |  4 ++++
 test/audio/audioplayer_test.cpp        |  9 +++++++++
 test/mocks/audioplayermock.h           |  3 +++
 7 files changed, 57 insertions(+)

diff --git a/src/audio/iaudioplayer.h b/src/audio/iaudioplayer.h
index 0023f195..0b7d877d 100644
--- a/src/audio/iaudioplayer.h
+++ b/src/audio/iaudioplayer.h
@@ -16,6 +16,9 @@ class IAudioPlayer
         virtual float volume() const = 0;
         virtual void setVolume(float volume) = 0;
 
+        virtual float pitch() const = 0;
+        virtual void setPitch(float pitch) = 0;
+
         virtual bool isLoaded() const = 0;
 
         virtual void start() = 0;
diff --git a/src/audio/internal/audioplayer.cpp b/src/audio/internal/audioplayer.cpp
index 4bb4922d..acd345bc 100644
--- a/src/audio/internal/audioplayer.cpp
+++ b/src/audio/internal/audioplayer.cpp
@@ -58,6 +58,7 @@ bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sample
 
     m_loaded = true;
     ma_sound_set_volume(m_sound, m_volume);
+    ma_sound_set_pitch(m_sound, m_pitch);
     return true;
 }
 
@@ -81,6 +82,7 @@ bool AudioPlayer::loadCopy(IAudioPlayer *player)
     m_loaded = true;
     m_copy = true;
     ma_sound_set_volume(m_sound, m_volume);
+    ma_sound_set_pitch(m_sound, m_pitch);
     return true;
 }
 
@@ -99,6 +101,28 @@ void AudioPlayer::setVolume(float volume)
     ma_sound_set_volume(m_sound, volume);
 }
 
+float AudioPlayer::pitch() const
+{
+    return m_pitch;
+}
+
+void AudioPlayer::setPitch(float pitch)
+{
+    /*
+     * 0.5 -> 220 Hz
+     * 1 -> 440 Hz
+     * 2 -> 880 Hz
+     * 4 -> 1760 Hz
+     * ...
+     */
+    m_pitch = pitch;
+
+    if (!m_loaded)
+        return;
+
+    ma_sound_set_pitch(m_sound, pitch);
+}
+
 bool AudioPlayer::isLoaded() const
 {
     return m_loaded;
diff --git a/src/audio/internal/audioplayer.h b/src/audio/internal/audioplayer.h
index 8dd77b54..5adc04ac 100644
--- a/src/audio/internal/audioplayer.h
+++ b/src/audio/internal/audioplayer.h
@@ -22,6 +22,9 @@ class AudioPlayer : public IAudioPlayer
         float volume() const override;
         void setVolume(float volume) override;
 
+        float pitch() const override;
+        void setPitch(float pitch) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -36,6 +39,7 @@ class AudioPlayer : public IAudioPlayer
         bool m_copy = false;
         bool m_started = false;
         float m_volume = 1;
+        float m_pitch = 1;
 };
 
 } // namespace libscratchcpp
diff --git a/src/audio/internal/audioplayerstub.cpp b/src/audio/internal/audioplayerstub.cpp
index 82983f1c..ec011840 100644
--- a/src/audio/internal/audioplayerstub.cpp
+++ b/src/audio/internal/audioplayerstub.cpp
@@ -28,6 +28,16 @@ void AudioPlayerStub::setVolume(float volume)
     m_volume = volume;
 }
 
+float AudioPlayerStub::pitch() const
+{
+    return m_pitch;
+}
+
+void AudioPlayerStub::setPitch(float pitch)
+{
+    m_pitch = pitch;
+}
+
 bool AudioPlayerStub::isLoaded() const
 {
     return true;
diff --git a/src/audio/internal/audioplayerstub.h b/src/audio/internal/audioplayerstub.h
index a577ddb2..ac557dd1 100644
--- a/src/audio/internal/audioplayerstub.h
+++ b/src/audio/internal/audioplayerstub.h
@@ -18,6 +18,9 @@ class AudioPlayerStub : public IAudioPlayer
         float volume() const override;
         void setVolume(float volume) override;
 
+        float pitch() const override;
+        void setPitch(float pitch) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -27,6 +30,7 @@ class AudioPlayerStub : public IAudioPlayer
 
     private:
         float m_volume = 1;
+        float m_pitch = 1;
 };
 
 } // namespace libscratchcpp
diff --git a/test/audio/audioplayer_test.cpp b/test/audio/audioplayer_test.cpp
index cd19a920..7505a75d 100644
--- a/test/audio/audioplayer_test.cpp
+++ b/test/audio/audioplayer_test.cpp
@@ -12,3 +12,12 @@ TEST(AudioPlayerTest, Volume)
     player.setVolume(0.86f);
     ASSERT_EQ(player.volume(), 0.86f);
 }
+
+TEST(AudioPlayerTest, Pitch)
+{
+    AudioPlayer player;
+    ASSERT_EQ(player.pitch(), 1);
+
+    player.setPitch(1.5f);
+    ASSERT_EQ(player.pitch(), 1.5f);
+}
diff --git a/test/mocks/audioplayermock.h b/test/mocks/audioplayermock.h
index 893e6b10..90a0c646 100644
--- a/test/mocks/audioplayermock.h
+++ b/test/mocks/audioplayermock.h
@@ -14,6 +14,9 @@ class AudioPlayerMock : public IAudioPlayer
         MOCK_METHOD(float, volume, (), (const, override));
         MOCK_METHOD(void, setVolume, (float), (override));
 
+        MOCK_METHOD(float, pitch, (), (const, override));
+        MOCK_METHOD(void, setPitch, (float), (override));
+
         MOCK_METHOD(bool, isLoaded, (), (const, override));
 
         MOCK_METHOD(void, start, (), (override));

From f311ce24050a414fc19f7f6e203c1e76652a527b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 19:23:02 +0200
Subject: [PATCH 58/71] Sound: Implement pitch effect

---
 include/scratchcpp/sound.h |  6 ++++++
 src/scratch/sound.cpp      | 27 +++++++++++++++++++++++++++
 test/assets/sound_test.cpp | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 66 insertions(+)

diff --git a/include/scratchcpp/sound.h b/include/scratchcpp/sound.h
index 382ea007..32911c9e 100644
--- a/include/scratchcpp/sound.h
+++ b/include/scratchcpp/sound.h
@@ -16,6 +16,11 @@ class SoundPrivate;
 class LIBSCRATCHCPP_EXPORT Sound : public Asset
 {
     public:
+        enum class Effect
+        {
+            Pitch
+        };
+
         Sound(const std::string &name, const std::string &id, const std::string &format);
         Sound(const Sound &) = delete;
         virtual ~Sound() { }
@@ -27,6 +32,7 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
         void setSampleCount(int newSampleCount);
 
         virtual void setVolume(double volume);
+        virtual void setEffect(Effect effect, double value);
 
         virtual void start();
         virtual void stop();
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index dccba675..08915c17 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -3,11 +3,18 @@
 #include <scratchcpp/sound.h>
 #include <scratchcpp/sprite.h>
 #include <iostream>
+#include <unordered_map>
+#include <algorithm>
+#include <cmath>
 
 #include "sound_p.h"
 
 using namespace libscratchcpp;
 
+static std::unordered_map<Sound::Effect, std::pair<double, double>> EFFECT_RANGE = {
+    { Sound::Effect::Pitch, { -360, 360 } } // -3 to 3 octaves
+};
+
 /*! Constructs Sound. */
 Sound::Sound(const std::string &name, const std::string &id, const std::string &format) :
     Asset(name, id, format),
@@ -45,6 +52,25 @@ void Sound::setVolume(double volume)
     impl->player->setVolume(volume / 100);
 }
 
+/*! Sets the value of the given sound effect. */
+void Sound::setEffect(Effect effect, double value)
+{
+    auto it = EFFECT_RANGE.find(effect);
+
+    if (it == EFFECT_RANGE.cend())
+        return;
+
+    value = std::clamp(value, it->second.first, it->second.second);
+
+    switch (effect) {
+        case Effect::Pitch:
+            // Convert from linear
+            const double root = std::pow(2, 1 / 12.0);
+            impl->player->setPitch(std::pow(root, value / 10));
+            break;
+    }
+}
+
 /*! Starts the playback of the sound. */
 void Sound::start()
 {
@@ -88,6 +114,7 @@ std::shared_ptr<Sound> Sound::clone() const
     sound->setSampleCount(sampleCount());
     sound->impl->cloneRoot = root;
     sound->impl->player->setVolume(impl->player->volume());
+    sound->impl->player->setPitch(impl->player->pitch());
 
     if (root->impl->player->isLoaded()) {
         sound->impl->player->loadCopy(root->impl->player.get());
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index d9e0e371..0e3cd067 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -79,6 +79,33 @@ TEST_F(SoundTest, SetVolume)
     sound.setVolume(56.04);
 }
 
+TEST_F(SoundTest, SetEffect)
+{
+    Sound sound("sound1", "a", "wav");
+
+    // Pitch
+    EXPECT_CALL(*m_player, setPitch(0.125));
+    sound.setEffect(Sound::Effect::Pitch, -400);
+
+    EXPECT_CALL(*m_player, setPitch(0.125));
+    sound.setEffect(Sound::Effect::Pitch, -360);
+
+    EXPECT_CALL(*m_player, setPitch(0.5));
+    sound.setEffect(Sound::Effect::Pitch, -120);
+
+    EXPECT_CALL(*m_player, setPitch(1));
+    sound.setEffect(Sound::Effect::Pitch, 0);
+
+    EXPECT_CALL(*m_player, setPitch(2));
+    sound.setEffect(Sound::Effect::Pitch, 120);
+
+    EXPECT_CALL(*m_player, setPitch(8));
+    sound.setEffect(Sound::Effect::Pitch, 360);
+
+    EXPECT_CALL(*m_player, setPitch(8));
+    sound.setEffect(Sound::Effect::Pitch, 400);
+}
+
 TEST_F(SoundTest, Start)
 {
     Sound sound("sound1", "a", "wav");
@@ -137,6 +164,8 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*clonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
     EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.45));
     EXPECT_CALL(*clonePlayer, setVolume(0.45));
+    EXPECT_CALL(*m_player, pitch()).WillOnce(Return(1.25));
+    EXPECT_CALL(*clonePlayer, setPitch(1.25));
     EXPECT_CALL(*clonePlayer, isLoaded()).WillOnce(Return(true));
     auto clone = sound->clone();
     ASSERT_TRUE(clone);
@@ -152,6 +181,8 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*cloneClonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
     EXPECT_CALL(*clonePlayer, volume()).WillOnce(Return(0.62));
     EXPECT_CALL(*cloneClonePlayer, setVolume(0.62));
+    EXPECT_CALL(*clonePlayer, pitch()).WillOnce(Return(0.5));
+    EXPECT_CALL(*cloneClonePlayer, setPitch(0.5));
     EXPECT_CALL(*cloneClonePlayer, isLoaded()).WillOnce(Return(true));
     auto cloneClone = clone->clone();
     ASSERT_TRUE(cloneClone);
@@ -162,6 +193,8 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*anotherClonePlayer, loadCopy).Times(0);
     EXPECT_CALL(*clonePlayer, volume()).WillOnce(Return(0.62));
     EXPECT_CALL(*anotherClonePlayer, setVolume(0.62));
+    EXPECT_CALL(*clonePlayer, pitch()).WillOnce(Return(2));
+    EXPECT_CALL(*anotherClonePlayer, setPitch(2));
     EXPECT_CALL(*anotherClonePlayer, isLoaded()).Times(0);
     auto anotherClone = clone->clone();
     ASSERT_TRUE(anotherClone);

From 6ced28c16027aae25ae74a93c41f9543f9976209 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 19:34:12 +0200
Subject: [PATCH 59/71] Add missing 'const' to Sound::isPlaying()

---
 include/scratchcpp/sound.h | 2 +-
 src/scratch/sound.cpp      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/scratchcpp/sound.h b/include/scratchcpp/sound.h
index 32911c9e..0a0de22e 100644
--- a/include/scratchcpp/sound.h
+++ b/include/scratchcpp/sound.h
@@ -37,7 +37,7 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
         virtual void start();
         virtual void stop();
 
-        virtual bool isPlaying();
+        virtual bool isPlaying() const;
 
         Target *target() const;
         void setTarget(Target *target);
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index 08915c17..c6a1e506 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -88,7 +88,7 @@ void Sound::stop()
 }
 
 /*! Returns true if the sound is being played. */
-bool Sound::isPlaying()
+bool Sound::isPlaying() const
 {
     return impl->player->isPlaying();
 }

From 89d23cb497f3bd5c31536f4bbe56c4cec29a0e32 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 19:34:58 +0200
Subject: [PATCH 60/71] Add SoundMock

---
 test/mocks/soundmock.h | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 test/mocks/soundmock.h

diff --git a/test/mocks/soundmock.h b/test/mocks/soundmock.h
new file mode 100644
index 00000000..63c9526f
--- /dev/null
+++ b/test/mocks/soundmock.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <scratchcpp/sound.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class SoundMock : public Sound
+{
+    public:
+        SoundMock() :
+            Sound("", "", "")
+        {
+        }
+
+        MOCK_METHOD(void, setVolume, (double), (override));
+        MOCK_METHOD(void, setEffect, (Sound::Effect, double), (override));
+
+        MOCK_METHOD(void, start, (), (override));
+        MOCK_METHOD(void, stop, (), (override));
+        MOCK_METHOD(bool, isPlaying, (), (const, override));
+};

From 93012ac74b4d7f98d8087fe53a514491efefea71 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 20:01:44 +0200
Subject: [PATCH 61/71] audio: Add pan API

---
 src/audio/iaudioplayer.h               |  3 +++
 src/audio/internal/audioplayer.cpp     | 18 ++++++++++++++++++
 src/audio/internal/audioplayer.h       |  4 ++++
 src/audio/internal/audioplayerstub.cpp | 10 ++++++++++
 src/audio/internal/audioplayerstub.h   |  4 ++++
 test/mocks/audioplayermock.h           |  3 +++
 6 files changed, 42 insertions(+)

diff --git a/src/audio/iaudioplayer.h b/src/audio/iaudioplayer.h
index 0b7d877d..0531c8ed 100644
--- a/src/audio/iaudioplayer.h
+++ b/src/audio/iaudioplayer.h
@@ -19,6 +19,9 @@ class IAudioPlayer
         virtual float pitch() const = 0;
         virtual void setPitch(float pitch) = 0;
 
+        virtual float pan() const = 0;
+        virtual void setPan(float pan) = 0;
+
         virtual bool isLoaded() const = 0;
 
         virtual void start() = 0;
diff --git a/src/audio/internal/audioplayer.cpp b/src/audio/internal/audioplayer.cpp
index acd345bc..dce100fb 100644
--- a/src/audio/internal/audioplayer.cpp
+++ b/src/audio/internal/audioplayer.cpp
@@ -59,6 +59,7 @@ bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sample
     m_loaded = true;
     ma_sound_set_volume(m_sound, m_volume);
     ma_sound_set_pitch(m_sound, m_pitch);
+    ma_sound_set_pan(m_sound, m_pan);
     return true;
 }
 
@@ -83,6 +84,7 @@ bool AudioPlayer::loadCopy(IAudioPlayer *player)
     m_copy = true;
     ma_sound_set_volume(m_sound, m_volume);
     ma_sound_set_pitch(m_sound, m_pitch);
+    ma_sound_set_pan(m_sound, m_pan);
     return true;
 }
 
@@ -123,6 +125,22 @@ void AudioPlayer::setPitch(float pitch)
     ma_sound_set_pitch(m_sound, pitch);
 }
 
+float AudioPlayer::pan() const
+{
+    return m_pan;
+}
+
+void AudioPlayer::setPan(float pan)
+{
+    // -1 ... 0 ... 1
+    m_pan = pan;
+
+    if (!m_loaded)
+        return;
+
+    ma_sound_set_pan(m_sound, pan);
+}
+
 bool AudioPlayer::isLoaded() const
 {
     return m_loaded;
diff --git a/src/audio/internal/audioplayer.h b/src/audio/internal/audioplayer.h
index 5adc04ac..ad5a2e0d 100644
--- a/src/audio/internal/audioplayer.h
+++ b/src/audio/internal/audioplayer.h
@@ -25,6 +25,9 @@ class AudioPlayer : public IAudioPlayer
         float pitch() const override;
         void setPitch(float pitch) override;
 
+        float pan() const override;
+        void setPan(float pan) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -40,6 +43,7 @@ class AudioPlayer : public IAudioPlayer
         bool m_started = false;
         float m_volume = 1;
         float m_pitch = 1;
+        float m_pan = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/src/audio/internal/audioplayerstub.cpp b/src/audio/internal/audioplayerstub.cpp
index ec011840..0dc39939 100644
--- a/src/audio/internal/audioplayerstub.cpp
+++ b/src/audio/internal/audioplayerstub.cpp
@@ -38,6 +38,16 @@ void AudioPlayerStub::setPitch(float pitch)
     m_pitch = pitch;
 }
 
+float AudioPlayerStub::pan() const
+{
+    return m_pan;
+}
+
+void AudioPlayerStub::setPan(float pan)
+{
+    m_pan = pan;
+}
+
 bool AudioPlayerStub::isLoaded() const
 {
     return true;
diff --git a/src/audio/internal/audioplayerstub.h b/src/audio/internal/audioplayerstub.h
index ac557dd1..c8c297cf 100644
--- a/src/audio/internal/audioplayerstub.h
+++ b/src/audio/internal/audioplayerstub.h
@@ -21,6 +21,9 @@ class AudioPlayerStub : public IAudioPlayer
         float pitch() const override;
         void setPitch(float pitch) override;
 
+        float pan() const override;
+        void setPan(float pan) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -31,6 +34,7 @@ class AudioPlayerStub : public IAudioPlayer
     private:
         float m_volume = 1;
         float m_pitch = 1;
+        float m_pan = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/test/mocks/audioplayermock.h b/test/mocks/audioplayermock.h
index 90a0c646..6116ad37 100644
--- a/test/mocks/audioplayermock.h
+++ b/test/mocks/audioplayermock.h
@@ -17,6 +17,9 @@ class AudioPlayerMock : public IAudioPlayer
         MOCK_METHOD(float, pitch, (), (const, override));
         MOCK_METHOD(void, setPitch, (float), (override));
 
+        MOCK_METHOD(float, pan, (), (const, override));
+        MOCK_METHOD(void, setPan, (float), (override));
+
         MOCK_METHOD(bool, isLoaded, (), (const, override));
 
         MOCK_METHOD(void, start, (), (override));

From 7b7ba4eff2b8ee773733f45482c78dda21e5465b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 20:22:35 +0200
Subject: [PATCH 62/71] Sound: Implement pan effect

---
 include/scratchcpp/sound.h |  3 ++-
 src/scratch/sound.cpp      | 11 +++++++++--
 test/assets/sound_test.cpp | 28 ++++++++++++++++++++++++++++
 3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/include/scratchcpp/sound.h b/include/scratchcpp/sound.h
index 0a0de22e..90f5abc7 100644
--- a/include/scratchcpp/sound.h
+++ b/include/scratchcpp/sound.h
@@ -18,7 +18,8 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
     public:
         enum class Effect
         {
-            Pitch
+            Pitch,
+            Pan
         };
 
         Sound(const std::string &name, const std::string &id, const std::string &format);
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index c6a1e506..e4270b72 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -12,7 +12,8 @@
 using namespace libscratchcpp;
 
 static std::unordered_map<Sound::Effect, std::pair<double, double>> EFFECT_RANGE = {
-    { Sound::Effect::Pitch, { -360, 360 } } // -3 to 3 octaves
+    { Sound::Effect::Pitch, { -360, 360 } }, // -3 to 3 octaves
+    { Sound::Effect::Pan, { -100, 100 } }    // // 100% left to 100% right
 };
 
 /*! Constructs Sound. */
@@ -63,11 +64,16 @@ void Sound::setEffect(Effect effect, double value)
     value = std::clamp(value, it->second.first, it->second.second);
 
     switch (effect) {
-        case Effect::Pitch:
+        case Effect::Pitch: {
             // Convert from linear
             const double root = std::pow(2, 1 / 12.0);
             impl->player->setPitch(std::pow(root, value / 10));
             break;
+        }
+
+        case Effect::Pan:
+            impl->player->setPan(value / 100);
+            break;
     }
 }
 
@@ -115,6 +121,7 @@ std::shared_ptr<Sound> Sound::clone() const
     sound->impl->cloneRoot = root;
     sound->impl->player->setVolume(impl->player->volume());
     sound->impl->player->setPitch(impl->player->pitch());
+    sound->impl->player->setPan(impl->player->pan());
 
     if (root->impl->player->isLoaded()) {
         sound->impl->player->loadCopy(root->impl->player.get());
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index 0e3cd067..5fd8c636 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -104,6 +104,28 @@ TEST_F(SoundTest, SetEffect)
 
     EXPECT_CALL(*m_player, setPitch(8));
     sound.setEffect(Sound::Effect::Pitch, 400);
+
+    // Pan
+    EXPECT_CALL(*m_player, setPan(-1));
+    sound.setEffect(Sound::Effect::Pan, -150);
+
+    EXPECT_CALL(*m_player, setPan(-1));
+    sound.setEffect(Sound::Effect::Pan, -100);
+
+    EXPECT_CALL(*m_player, setPan(-0.5));
+    sound.setEffect(Sound::Effect::Pan, -50);
+
+    EXPECT_CALL(*m_player, setPan(0));
+    sound.setEffect(Sound::Effect::Pan, 0);
+
+    EXPECT_CALL(*m_player, setPan(0.5));
+    sound.setEffect(Sound::Effect::Pan, 50);
+
+    EXPECT_CALL(*m_player, setPan(1));
+    sound.setEffect(Sound::Effect::Pan, 100);
+
+    EXPECT_CALL(*m_player, setPan(1));
+    sound.setEffect(Sound::Effect::Pan, 150);
 }
 
 TEST_F(SoundTest, Start)
@@ -166,6 +188,8 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*clonePlayer, setVolume(0.45));
     EXPECT_CALL(*m_player, pitch()).WillOnce(Return(1.25));
     EXPECT_CALL(*clonePlayer, setPitch(1.25));
+    EXPECT_CALL(*m_player, pan()).WillOnce(Return(-0.75));
+    EXPECT_CALL(*clonePlayer, setPan(-0.75));
     EXPECT_CALL(*clonePlayer, isLoaded()).WillOnce(Return(true));
     auto clone = sound->clone();
     ASSERT_TRUE(clone);
@@ -183,6 +207,8 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*cloneClonePlayer, setVolume(0.62));
     EXPECT_CALL(*clonePlayer, pitch()).WillOnce(Return(0.5));
     EXPECT_CALL(*cloneClonePlayer, setPitch(0.5));
+    EXPECT_CALL(*clonePlayer, pan()).WillOnce(Return(0.25));
+    EXPECT_CALL(*cloneClonePlayer, setPan(0.25));
     EXPECT_CALL(*cloneClonePlayer, isLoaded()).WillOnce(Return(true));
     auto cloneClone = clone->clone();
     ASSERT_TRUE(cloneClone);
@@ -195,6 +221,8 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(*anotherClonePlayer, setVolume(0.62));
     EXPECT_CALL(*clonePlayer, pitch()).WillOnce(Return(2));
     EXPECT_CALL(*anotherClonePlayer, setPitch(2));
+    EXPECT_CALL(*clonePlayer, pan()).WillOnce(Return(1));
+    EXPECT_CALL(*anotherClonePlayer, setPan(1));
     EXPECT_CALL(*anotherClonePlayer, isLoaded()).Times(0);
     auto anotherClone = clone->clone();
     ASSERT_TRUE(anotherClone);

From 3abbb4e891bb62f991a52202cc00a52eb7a17e24 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 20:33:31 +0200
Subject: [PATCH 63/71] Target: Add API for sound effects

---
 include/scratchcpp/target.h          |  3 +++
 src/scratch/target.cpp               | 14 ++++++++++++
 src/scratch/target_p.h               |  1 +
 test/mocks/targetmock.h              |  2 ++
 test/scratch_classes/target_test.cpp | 33 ++++++++++++++++++++++++++++
 5 files changed, 53 insertions(+)

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 5083275d..f167a442 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -7,6 +7,7 @@
 #include "global.h"
 #include "spimpl.h"
 #include "rect.h"
+#include "sound.h"
 
 namespace libscratchcpp
 {
@@ -88,6 +89,8 @@ class LIBSCRATCHCPP_EXPORT Target
         double volume() const;
         void setVolume(double newVolume);
 
+        virtual void setSoundEffect(Sound::Effect effect, double value);
+
         virtual Rect boundingRect() const;
         virtual Rect fastBoundingRect() const;
 
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 99559fe7..0d1b1b69 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -359,6 +359,9 @@ int Target::addSound(std::shared_ptr<Sound> sound)
     if (sound) {
         sound->setTarget(this);
         sound->setVolume(impl->volume);
+
+        for (const auto &[effect, value] : impl->soundEffects)
+            sound->setEffect(effect, value);
     }
 
     impl->sounds.push_back(sound);
@@ -419,6 +422,17 @@ void Target::setVolume(double newVolume)
     }
 }
 
+/*! Sets the value of the given sound effect. */
+void Target::setSoundEffect(Sound::Effect effect, double value)
+{
+    impl->soundEffects[effect] = value;
+
+    for (auto sound : impl->sounds) {
+        if (sound)
+            sound->setEffect(effect, value);
+    }
+}
+
 /*! Returns the bounding rectangle of the sprite. */
 Rect Target::boundingRect() const
 {
diff --git a/src/scratch/target_p.h b/src/scratch/target_p.h
index 73db4087..71b7c48b 100644
--- a/src/scratch/target_p.h
+++ b/src/scratch/target_p.h
@@ -36,6 +36,7 @@ struct TargetPrivate
         std::vector<std::shared_ptr<Sound>> sounds;
         int layerOrder = 0;
         double volume = 100;
+        std::unordered_map<Sound::Effect, double> soundEffects;
         std::unordered_map<IGraphicsEffect *, double> graphicsEffects;
         Target::BubbleType bubbleType = Target::BubbleType::Say;
         std::string bubbleText;
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 169048d4..9c7f0009 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -17,6 +17,8 @@ class TargetMock : public Target
 
         MOCK_METHOD(void, setLayerOrder, (int), (override));
 
+        MOCK_METHOD(void, setSoundEffect, (Sound::Effect, double), (override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 2cd7e330..3442e332 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -13,6 +13,7 @@
 #include <graphicseffectmock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <soundmock.h>
 
 #include "../common.h"
 
@@ -511,6 +512,38 @@ TEST(TargetTest, Volume)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST(TargetTest, SetSoundEffect)
+{
+    Target target;
+
+    auto s1 = std::make_shared<SoundMock>();
+    auto s2 = std::make_shared<SoundMock>();
+    auto s3 = std::make_shared<SoundMock>();
+
+    EXPECT_CALL(*s1, setVolume);
+    EXPECT_CALL(*s2, setVolume);
+    EXPECT_CALL(*s3, setVolume);
+    target.addSound(s1);
+    target.addSound(s2);
+    target.addSound(s3);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 12.5));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pitch, 12.5));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pitch, 12.5));
+    target.setSoundEffect(Sound::Effect::Pitch, 12.5);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, -56.7));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pan, -56.7));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pan, -56.7));
+    target.setSoundEffect(Sound::Effect::Pan, -56.7);
+
+    auto s4 = std::make_shared<SoundMock>();
+    EXPECT_CALL(*s4, setVolume);
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pitch, 12.5));
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pan, -56.7));
+    target.addSound(s4);
+}
+
 TEST(TargetTest, CurrentCostumeWidth)
 {
     Target target;

From 71095b6b0c221811abc5db52a8aa8df9c53be45a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 30 Aug 2024 23:52:35 +0200
Subject: [PATCH 64/71] Implement sound_seteffectto block

---
 src/blocks/soundblocks.cpp        | 46 +++++++++++++++++++++
 src/blocks/soundblocks.h          | 10 ++++-
 test/blocks/sound_blocks_test.cpp | 66 +++++++++++++++++++++++++++++++
 3 files changed, 120 insertions(+), 2 deletions(-)

diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index f9e4a97f..1b68deaf 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -4,6 +4,7 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/target.h>
 #include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/sound.h>
 
 #include "soundblocks.h"
@@ -33,6 +34,7 @@ void SoundBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sound_play", &compilePlay);
     engine->addCompileFunction(this, "sound_playuntildone", &compilePlayUntilDone);
     engine->addCompileFunction(this, "sound_stopallsounds", &compileStopAllSounds);
+    engine->addCompileFunction(this, "sound_seteffectto", &compileSetEffectTo);
     engine->addCompileFunction(this, "sound_changevolumeby", &compileChangeVolumeBy);
     engine->addCompileFunction(this, "sound_setvolumeto", &compileSetVolumeTo);
     engine->addCompileFunction(this, "sound_volume", &compileVolume);
@@ -42,7 +44,15 @@ void SoundBlocks::registerBlocks(IEngine *engine)
 
     // Inputs
     engine->addInput(this, "SOUND_MENU", SOUND_MENU);
+    engine->addInput(this, "VALUE", VALUE);
     engine->addInput(this, "VOLUME", VOLUME);
+
+    // Fields
+    engine->addField(this, "EFFECT", EFFECT);
+
+    // Field values
+    engine->addFieldValue(this, "PITCH", PITCH);
+    engine->addFieldValue(this, "PAN", PAN);
 }
 
 void SoundBlocks::onInit(IEngine *engine)
@@ -118,6 +128,26 @@ void SoundBlocks::compileStopAllSounds(Compiler *compiler)
     compiler->addFunctionCall(&stopAllSounds);
 }
 
+void SoundBlocks::compileSetEffectTo(Compiler *compiler)
+{
+    compiler->addInput(VALUE);
+    int option = compiler->field(EFFECT)->specialValueId();
+
+    switch (option) {
+        case PITCH:
+            compiler->addFunctionCall(&setPitchEffectTo);
+            break;
+
+        case PAN:
+            compiler->addFunctionCall(&setPanEffectTo);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
 void SoundBlocks::compileChangeVolumeBy(Compiler *compiler)
 {
     compiler->addInput(VOLUME);
@@ -296,6 +326,22 @@ unsigned int SoundBlocks::stopAllSounds(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int SoundBlocks::setPitchEffectTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pitch, vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::setPanEffectTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pan, vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
 unsigned int SoundBlocks::changeVolumeBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
diff --git a/src/blocks/soundblocks.h b/src/blocks/soundblocks.h
index 866be118..df0ea8cc 100644
--- a/src/blocks/soundblocks.h
+++ b/src/blocks/soundblocks.h
@@ -20,17 +20,19 @@ class SoundBlocks : public IBlockSection
         enum Inputs
         {
             SOUND_MENU,
+            VALUE,
             VOLUME
         };
 
         enum Fields
         {
-
+            EFFECT
         };
 
         enum FieldValues
         {
-
+            PITCH,
+            PAN
         };
 
         std::string name() const override;
@@ -42,6 +44,7 @@ class SoundBlocks : public IBlockSection
         static void compilePlay(Compiler *compiler);
         static void compilePlayUntilDone(Compiler *compiler);
         static void compileStopAllSounds(Compiler *compiler);
+        static void compileSetEffectTo(Compiler *compiler);
         static void compileChangeVolumeBy(Compiler *compiler);
         static void compileSetVolumeTo(Compiler *compiler);
         static void compileVolume(Compiler *compiler);
@@ -62,6 +65,9 @@ class SoundBlocks : public IBlockSection
 
         static unsigned int stopAllSounds(VirtualMachine *vm);
 
+        static unsigned int setPitchEffectTo(VirtualMachine *vm);
+        static unsigned int setPanEffectTo(VirtualMachine *vm);
+
         static unsigned int changeVolumeBy(VirtualMachine *vm);
         static unsigned int setVolumeTo(VirtualMachine *vm);
         static unsigned int volume(VirtualMachine *vm);
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index d41c7b01..c85cad28 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -102,6 +102,7 @@ TEST_F(SoundBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_play", &SoundBlocks::compilePlay));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_playuntildone", &SoundBlocks::compilePlayUntilDone));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_stopallsounds", &SoundBlocks::compileStopAllSounds));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_seteffectto", &SoundBlocks::compileSetEffectTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changevolumeby", &SoundBlocks::compileChangeVolumeBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_setvolumeto", &SoundBlocks::compileSetVolumeTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_volume", &SoundBlocks::compileVolume));
@@ -111,8 +112,16 @@ TEST_F(SoundBlocksTest, RegisterBlocks)
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SOUND_MENU", SoundBlocks::SOUND_MENU));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", SoundBlocks::VALUE));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VOLUME", SoundBlocks::VOLUME));
 
+    // Fields
+    EXPECT_CALL(m_engineMock, addField(m_section.get(), "EFFECT", SoundBlocks::EFFECT));
+
+    // Field values
+    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "PITCH", SoundBlocks::PITCH));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "PAN", SoundBlocks::PAN));
+
     m_section->registerBlocks(&m_engineMock);
 }
 
@@ -589,6 +598,63 @@ TEST_F(SoundBlocksTest, StopAllSoundsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
+TEST_F(SoundBlocksTest, SetEffectTo)
+{
+    Compiler compiler(&m_engineMock);
+
+    // set [pitch] effect to (5.3)
+    auto block1 = std::make_shared<Block>("a", "sound_seteffectto");
+    addDropdownField(block1, "EFFECT", SoundBlocks::EFFECT, "PITCH", SoundBlocks::PITCH);
+    addValueInput(block1, "VALUE", SoundBlocks::VALUE, 5.3);
+
+    // set [pan] effect to (-79.52)
+    auto block2 = std::make_shared<Block>("b", "sound_seteffectto");
+    addDropdownField(block2, "EFFECT", SoundBlocks::EFFECT, "PAN", SoundBlocks::PAN);
+    addValueInput(block2, "VALUE", SoundBlocks::VALUE, -79.52);
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::setPitchEffectTo)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    SoundBlocks::compileSetEffectTo(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::setPanEffectTo)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    SoundBlocks::compileSetEffectTo(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 5.3, -79.52 }));
+}
+
+TEST_F(SoundBlocksTest, SetEffectToImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::setPitchEffectTo, &SoundBlocks::setPanEffectTo };
+    static Value constValues[] = { -20.7, 12.53 };
+
+    TargetMock target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode1);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pitch, -20.7));
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+
+    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pan, 12.53));
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}
+
 TEST_F(SoundBlocksTest, ChangeVolumeBy)
 {
     Compiler compiler(&m_engineMock);

From ca3c402de6d629007afa93afe130714f574e035a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 00:16:24 +0200
Subject: [PATCH 65/71] Target: Add sound effect getter

---
 include/scratchcpp/target.h          |  1 +
 src/scratch/target.cpp               | 11 +++++++++++
 test/mocks/targetmock.h              |  1 +
 test/scratch_classes/target_test.cpp |  8 +++++++-
 4 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index f167a442..7ed7cafe 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -89,6 +89,7 @@ class LIBSCRATCHCPP_EXPORT Target
         double volume() const;
         void setVolume(double newVolume);
 
+        virtual double soundEffect(Sound::Effect effect) const;
         virtual void setSoundEffect(Sound::Effect effect, double value);
 
         virtual Rect boundingRect() const;
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 0d1b1b69..482259e9 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -422,6 +422,17 @@ void Target::setVolume(double newVolume)
     }
 }
 
+/*! Returns the value of the given sound effect. */
+double Target::soundEffect(Sound::Effect effect) const
+{
+    auto it = impl->soundEffects.find(effect);
+
+    if (it != impl->soundEffects.cend())
+        return it->second;
+
+    return 0;
+}
+
 /*! Sets the value of the given sound effect. */
 void Target::setSoundEffect(Sound::Effect effect, double value)
 {
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 9c7f0009..71aaabc7 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -17,6 +17,7 @@ class TargetMock : public Target
 
         MOCK_METHOD(void, setLayerOrder, (int), (override));
 
+        MOCK_METHOD(double, soundEffect, (Sound::Effect), (const, override));
         MOCK_METHOD(void, setSoundEffect, (Sound::Effect, double), (override));
 
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 3442e332..7138e715 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -512,9 +512,11 @@ TEST(TargetTest, Volume)
     SoundPrivate::audioOutput = nullptr;
 }
 
-TEST(TargetTest, SetSoundEffect)
+TEST(TargetTest, SoundEffect)
 {
     Target target;
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), 0);
 
     auto s1 = std::make_shared<SoundMock>();
     auto s2 = std::make_shared<SoundMock>();
@@ -531,11 +533,15 @@ TEST(TargetTest, SetSoundEffect)
     EXPECT_CALL(*s2, setEffect(Sound::Effect::Pitch, 12.5));
     EXPECT_CALL(*s3, setEffect(Sound::Effect::Pitch, 12.5));
     target.setSoundEffect(Sound::Effect::Pitch, 12.5);
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 12.5);
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), 0);
 
     EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, -56.7));
     EXPECT_CALL(*s2, setEffect(Sound::Effect::Pan, -56.7));
     EXPECT_CALL(*s3, setEffect(Sound::Effect::Pan, -56.7));
     target.setSoundEffect(Sound::Effect::Pan, -56.7);
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 12.5);
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), -56.7);
 
     auto s4 = std::make_shared<SoundMock>();
     EXPECT_CALL(*s4, setVolume);

From 91c7655632266f71cef4a311a77d3d0ca7b4b9e7 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 00:16:46 +0200
Subject: [PATCH 66/71] Implement sound_changeeffectby block

---
 src/blocks/soundblocks.cpp        | 37 +++++++++++++++++++
 src/blocks/soundblocks.h          |  3 ++
 test/blocks/sound_blocks_test.cpp | 60 +++++++++++++++++++++++++++++++
 3 files changed, 100 insertions(+)

diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index 1b68deaf..09de4d1e 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -35,6 +35,7 @@ void SoundBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sound_playuntildone", &compilePlayUntilDone);
     engine->addCompileFunction(this, "sound_stopallsounds", &compileStopAllSounds);
     engine->addCompileFunction(this, "sound_seteffectto", &compileSetEffectTo);
+    engine->addCompileFunction(this, "sound_changeeffectby", &compileChangeEffectBy);
     engine->addCompileFunction(this, "sound_changevolumeby", &compileChangeVolumeBy);
     engine->addCompileFunction(this, "sound_setvolumeto", &compileSetVolumeTo);
     engine->addCompileFunction(this, "sound_volume", &compileVolume);
@@ -148,6 +149,26 @@ void SoundBlocks::compileSetEffectTo(Compiler *compiler)
     }
 }
 
+void SoundBlocks::compileChangeEffectBy(Compiler *compiler)
+{
+    compiler->addInput(VALUE);
+    int option = compiler->field(EFFECT)->specialValueId();
+
+    switch (option) {
+        case PITCH:
+            compiler->addFunctionCall(&changePitchEffectBy);
+            break;
+
+        case PAN:
+            compiler->addFunctionCall(&changePanEffectBy);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
 void SoundBlocks::compileChangeVolumeBy(Compiler *compiler)
 {
     compiler->addInput(VOLUME);
@@ -342,6 +363,22 @@ unsigned int SoundBlocks::setPanEffectTo(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int SoundBlocks::changePitchEffectBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pitch, target->soundEffect(Sound::Effect::Pitch) + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::changePanEffectBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pan, target->soundEffect(Sound::Effect::Pan) + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
 unsigned int SoundBlocks::changeVolumeBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
diff --git a/src/blocks/soundblocks.h b/src/blocks/soundblocks.h
index df0ea8cc..205c5092 100644
--- a/src/blocks/soundblocks.h
+++ b/src/blocks/soundblocks.h
@@ -45,6 +45,7 @@ class SoundBlocks : public IBlockSection
         static void compilePlayUntilDone(Compiler *compiler);
         static void compileStopAllSounds(Compiler *compiler);
         static void compileSetEffectTo(Compiler *compiler);
+        static void compileChangeEffectBy(Compiler *compiler);
         static void compileChangeVolumeBy(Compiler *compiler);
         static void compileSetVolumeTo(Compiler *compiler);
         static void compileVolume(Compiler *compiler);
@@ -67,6 +68,8 @@ class SoundBlocks : public IBlockSection
 
         static unsigned int setPitchEffectTo(VirtualMachine *vm);
         static unsigned int setPanEffectTo(VirtualMachine *vm);
+        static unsigned int changePitchEffectBy(VirtualMachine *vm);
+        static unsigned int changePanEffectBy(VirtualMachine *vm);
 
         static unsigned int changeVolumeBy(VirtualMachine *vm);
         static unsigned int setVolumeTo(VirtualMachine *vm);
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index c85cad28..ed236c06 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -103,6 +103,7 @@ TEST_F(SoundBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_playuntildone", &SoundBlocks::compilePlayUntilDone));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_stopallsounds", &SoundBlocks::compileStopAllSounds));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_seteffectto", &SoundBlocks::compileSetEffectTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changeeffectby", &SoundBlocks::compileChangeEffectBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changevolumeby", &SoundBlocks::compileChangeVolumeBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_setvolumeto", &SoundBlocks::compileSetVolumeTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_volume", &SoundBlocks::compileVolume));
@@ -655,6 +656,65 @@ TEST_F(SoundBlocksTest, SetEffectToImpl)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
+TEST_F(SoundBlocksTest, ChangeEffectBy)
+{
+    Compiler compiler(&m_engineMock);
+
+    // change [pitch] effect by (5.3)
+    auto block1 = std::make_shared<Block>("a", "sound_changeeffectby");
+    addDropdownField(block1, "EFFECT", SoundBlocks::EFFECT, "PITCH", SoundBlocks::PITCH);
+    addValueInput(block1, "VALUE", SoundBlocks::VALUE, 5.3);
+
+    // change [pan] effect by (-79.52)
+    auto block2 = std::make_shared<Block>("b", "sound_changeeffectby");
+    addDropdownField(block2, "EFFECT", SoundBlocks::EFFECT, "PAN", SoundBlocks::PAN);
+    addValueInput(block2, "VALUE", SoundBlocks::VALUE, -79.52);
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::changePitchEffectBy)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    SoundBlocks::compileChangeEffectBy(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::changePanEffectBy)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    SoundBlocks::compileChangeEffectBy(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 5.3, -79.52 }));
+}
+
+TEST_F(SoundBlocksTest, ChangeEffectByImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::changePitchEffectBy, &SoundBlocks::changePanEffectBy };
+    static Value constValues[] = { -20.7, 12.53 };
+
+    TargetMock target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode1);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    EXPECT_CALL(target, soundEffect(Sound::Effect::Pitch)).WillOnce(Return(56));
+    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pitch, 35.3));
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+
+    EXPECT_CALL(target, soundEffect(Sound::Effect::Pan)).WillOnce(Return(-2.5));
+    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pan, 10.03));
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}
+
 TEST_F(SoundBlocksTest, ChangeVolumeBy)
 {
     Compiler compiler(&m_engineMock);

From 4e077a244644ba471c922147b2bb911885d29505 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 10:14:58 +0200
Subject: [PATCH 67/71] Target: Add clearSoundEffects() method

---
 include/scratchcpp/target.h          |  2 ++
 src/scratch/target.cpp               | 11 +++++++++++
 test/mocks/targetmock.h              |  2 ++
 test/scratch_classes/target_test.cpp | 14 +++++++++++++-
 4 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 7ed7cafe..163db214 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -92,6 +92,8 @@ class LIBSCRATCHCPP_EXPORT Target
         virtual double soundEffect(Sound::Effect effect) const;
         virtual void setSoundEffect(Sound::Effect effect, double value);
 
+        virtual void clearSoundEffects();
+
         virtual Rect boundingRect() const;
         virtual Rect fastBoundingRect() const;
 
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 482259e9..181aa36e 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -444,6 +444,17 @@ void Target::setSoundEffect(Sound::Effect effect, double value)
     }
 }
 
+/*! Sets the value of all sound effects to 0 (clears them). */
+void Target::clearSoundEffects()
+{
+    std::unordered_map<Sound::Effect, double> effects = impl->soundEffects; // must copy!
+
+    for (const auto &[effect, value] : effects)
+        setSoundEffect(effect, 0);
+
+    impl->soundEffects.clear();
+}
+
 /*! Returns the bounding rectangle of the sprite. */
 Rect Target::boundingRect() const
 {
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 71aaabc7..416d1ff1 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -20,6 +20,8 @@ class TargetMock : public Target
         MOCK_METHOD(double, soundEffect, (Sound::Effect), (const, override));
         MOCK_METHOD(void, setSoundEffect, (Sound::Effect, double), (override));
 
+        MOCK_METHOD(void, clearSoundEffects, (), (override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 7138e715..7b09d0b7 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -512,7 +512,7 @@ TEST(TargetTest, Volume)
     SoundPrivate::audioOutput = nullptr;
 }
 
-TEST(TargetTest, SoundEffect)
+TEST(TargetTest, SoundEffects)
 {
     Target target;
     ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 0);
@@ -548,6 +548,18 @@ TEST(TargetTest, SoundEffect)
     EXPECT_CALL(*s4, setEffect(Sound::Effect::Pitch, 12.5));
     EXPECT_CALL(*s4, setEffect(Sound::Effect::Pan, -56.7));
     target.addSound(s4);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, 0));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pan, 0));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pan, 0));
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pan, 0));
+    target.clearSoundEffects();
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), 0);
 }
 
 TEST(TargetTest, CurrentCostumeWidth)

From 389c27f1c68e70a47825314f3a8519907c631f3a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 10:23:06 +0200
Subject: [PATCH 68/71] Implement sound_cleareffects block

---
 src/blocks/soundblocks.cpp        | 14 +++++++++++++
 src/blocks/soundblocks.h          |  2 ++
 test/blocks/sound_blocks_test.cpp | 35 +++++++++++++++++++++++++++++++
 3 files changed, 51 insertions(+)

diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index 09de4d1e..60baeb10 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -37,6 +37,7 @@ void SoundBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sound_seteffectto", &compileSetEffectTo);
     engine->addCompileFunction(this, "sound_changeeffectby", &compileChangeEffectBy);
     engine->addCompileFunction(this, "sound_changevolumeby", &compileChangeVolumeBy);
+    engine->addCompileFunction(this, "sound_cleareffects", &compileClearEffects);
     engine->addCompileFunction(this, "sound_setvolumeto", &compileSetVolumeTo);
     engine->addCompileFunction(this, "sound_volume", &compileVolume);
 
@@ -169,6 +170,11 @@ void SoundBlocks::compileChangeEffectBy(Compiler *compiler)
     }
 }
 
+void SoundBlocks::compileClearEffects(Compiler *compiler)
+{
+    compiler->addFunctionCall(&clearEffects);
+}
+
 void SoundBlocks::compileChangeVolumeBy(Compiler *compiler)
 {
     compiler->addInput(VOLUME);
@@ -379,6 +385,14 @@ unsigned int SoundBlocks::changePanEffectBy(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int SoundBlocks::clearEffects(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->clearSoundEffects();
+
+    return 0;
+}
+
 unsigned int SoundBlocks::changeVolumeBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
diff --git a/src/blocks/soundblocks.h b/src/blocks/soundblocks.h
index 205c5092..10e493c5 100644
--- a/src/blocks/soundblocks.h
+++ b/src/blocks/soundblocks.h
@@ -46,6 +46,7 @@ class SoundBlocks : public IBlockSection
         static void compileStopAllSounds(Compiler *compiler);
         static void compileSetEffectTo(Compiler *compiler);
         static void compileChangeEffectBy(Compiler *compiler);
+        static void compileClearEffects(Compiler *compiler);
         static void compileChangeVolumeBy(Compiler *compiler);
         static void compileSetVolumeTo(Compiler *compiler);
         static void compileVolume(Compiler *compiler);
@@ -70,6 +71,7 @@ class SoundBlocks : public IBlockSection
         static unsigned int setPanEffectTo(VirtualMachine *vm);
         static unsigned int changePitchEffectBy(VirtualMachine *vm);
         static unsigned int changePanEffectBy(VirtualMachine *vm);
+        static unsigned int clearEffects(VirtualMachine *vm);
 
         static unsigned int changeVolumeBy(VirtualMachine *vm);
         static unsigned int setVolumeTo(VirtualMachine *vm);
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index ed236c06..bcf2ba15 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -105,6 +105,7 @@ TEST_F(SoundBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_seteffectto", &SoundBlocks::compileSetEffectTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changeeffectby", &SoundBlocks::compileChangeEffectBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changevolumeby", &SoundBlocks::compileChangeVolumeBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_cleareffects", &SoundBlocks::compileClearEffects));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_setvolumeto", &SoundBlocks::compileSetVolumeTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_volume", &SoundBlocks::compileVolume));
 
@@ -715,6 +716,40 @@ TEST_F(SoundBlocksTest, ChangeEffectByImpl)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
+TEST_F(SoundBlocksTest, ClearEffects)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sound_cleareffects");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::clearEffects)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SoundBlocks::compileClearEffects(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(SoundBlocksTest, ClearEffectsImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::clearEffects };
+
+    TargetMock target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+
+    EXPECT_CALL(target, clearSoundEffects());
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}
+
 TEST_F(SoundBlocksTest, ChangeVolumeBy)
 {
     Compiler compiler(&m_engineMock);

From 1596da9fd78743f5d09cd63dd907fe212ef6b110 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 10:31:52 +0200
Subject: [PATCH 69/71] README: Mark sound blocks as finished

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 78dc3387..f4a9efbf 100644
--- a/README.md
+++ b/README.md
@@ -124,7 +124,7 @@ libscratchcpp::Project p("https://scratch.mit.edu/projects/XXXXXX");
 
 - [x] Motion blocks
 - [x] Looks blocks
-- [ ] Sound blocks
+- [x] Sound blocks
 - [x] Event blocks
 - [x] Control blocks
 - [ ] Sensing blocks

From 4342271cf4b6153303f1e682e6acc551fc610ce7 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 10:58:07 +0200
Subject: [PATCH 70/71] fix #537: Move sprite to front when starting dragging

---
 src/scratch/sprite.cpp               | 5 +++++
 test/scratch_classes/sprite_test.cpp | 6 ++++++
 2 files changed, 11 insertions(+)

diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 7697cee7..d711ca7c 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -226,6 +226,11 @@ bool Sprite::dragging() const
 void Sprite::startDragging()
 {
     impl->dragging = true;
+
+    IEngine *eng = engine();
+
+    if (eng)
+        eng->moveSpriteToFront(this);
 }
 
 /*! Stops dragging. */
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index ede233d3..ea79c577 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -400,6 +400,12 @@ TEST(SpriteTest, Dragging)
     sprite.setInterface(&handler);
     ASSERT_FALSE(sprite.dragging());
 
+    EngineMock engine;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, spriteFencingEnabled).WillRepeatedly(Return(false));
+    EXPECT_CALL(engine, requestRedraw).WillRepeatedly(Return());
+
+    EXPECT_CALL(engine, moveSpriteToFront(&sprite));
     sprite.startDragging();
     ASSERT_TRUE(sprite.dragging());
 

From 363bec1b8658a25cb558021f09907bdf3b69f80f Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 31 Aug 2024 11:05:21 +0200
Subject: [PATCH 71/71] Rename sound effect methods

to match with graphic effects
---
 include/scratchcpp/target.h          |  4 ++--
 src/blocks/soundblocks.cpp           |  8 ++++----
 src/scratch/target.cpp               |  6 +++---
 test/blocks/sound_blocks_test.cpp    | 12 ++++++------
 test/mocks/targetmock.h              |  4 ++--
 test/scratch_classes/target_test.cpp | 20 ++++++++++----------
 6 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 163db214..cb8f7c1b 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -89,8 +89,8 @@ class LIBSCRATCHCPP_EXPORT Target
         double volume() const;
         void setVolume(double newVolume);
 
-        virtual double soundEffect(Sound::Effect effect) const;
-        virtual void setSoundEffect(Sound::Effect effect, double value);
+        virtual double soundEffectValue(Sound::Effect effect) const;
+        virtual void setSoundEffectValue(Sound::Effect effect, double value);
 
         virtual void clearSoundEffects();
 
diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index 60baeb10..4eb311fa 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -356,7 +356,7 @@ unsigned int SoundBlocks::stopAllSounds(VirtualMachine *vm)
 unsigned int SoundBlocks::setPitchEffectTo(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
-        target->setSoundEffect(Sound::Effect::Pitch, vm->getInput(0, 1)->toDouble());
+        target->setSoundEffectValue(Sound::Effect::Pitch, vm->getInput(0, 1)->toDouble());
 
     return 1;
 }
@@ -364,7 +364,7 @@ unsigned int SoundBlocks::setPitchEffectTo(VirtualMachine *vm)
 unsigned int SoundBlocks::setPanEffectTo(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
-        target->setSoundEffect(Sound::Effect::Pan, vm->getInput(0, 1)->toDouble());
+        target->setSoundEffectValue(Sound::Effect::Pan, vm->getInput(0, 1)->toDouble());
 
     return 1;
 }
@@ -372,7 +372,7 @@ unsigned int SoundBlocks::setPanEffectTo(VirtualMachine *vm)
 unsigned int SoundBlocks::changePitchEffectBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
-        target->setSoundEffect(Sound::Effect::Pitch, target->soundEffect(Sound::Effect::Pitch) + vm->getInput(0, 1)->toDouble());
+        target->setSoundEffectValue(Sound::Effect::Pitch, target->soundEffectValue(Sound::Effect::Pitch) + vm->getInput(0, 1)->toDouble());
 
     return 1;
 }
@@ -380,7 +380,7 @@ unsigned int SoundBlocks::changePitchEffectBy(VirtualMachine *vm)
 unsigned int SoundBlocks::changePanEffectBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
-        target->setSoundEffect(Sound::Effect::Pan, target->soundEffect(Sound::Effect::Pan) + vm->getInput(0, 1)->toDouble());
+        target->setSoundEffectValue(Sound::Effect::Pan, target->soundEffectValue(Sound::Effect::Pan) + vm->getInput(0, 1)->toDouble());
 
     return 1;
 }
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 181aa36e..1e9f4b46 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -423,7 +423,7 @@ void Target::setVolume(double newVolume)
 }
 
 /*! Returns the value of the given sound effect. */
-double Target::soundEffect(Sound::Effect effect) const
+double Target::soundEffectValue(Sound::Effect effect) const
 {
     auto it = impl->soundEffects.find(effect);
 
@@ -434,7 +434,7 @@ double Target::soundEffect(Sound::Effect effect) const
 }
 
 /*! Sets the value of the given sound effect. */
-void Target::setSoundEffect(Sound::Effect effect, double value)
+void Target::setSoundEffectValue(Sound::Effect effect, double value)
 {
     impl->soundEffects[effect] = value;
 
@@ -450,7 +450,7 @@ void Target::clearSoundEffects()
     std::unordered_map<Sound::Effect, double> effects = impl->soundEffects; // must copy!
 
     for (const auto &[effect, value] : effects)
-        setSoundEffect(effect, 0);
+        setSoundEffectValue(effect, 0);
 
     impl->soundEffects.clear();
 }
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index bcf2ba15..96992550 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -644,12 +644,12 @@ TEST_F(SoundBlocksTest, SetEffectToImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pitch, -20.7));
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pitch, -20.7));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pan, 12.53));
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pan, 12.53));
     vm.reset();
     vm.setBytecode(bytecode2);
     vm.run();
@@ -701,14 +701,14 @@ TEST_F(SoundBlocksTest, ChangeEffectByImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(target, soundEffect(Sound::Effect::Pitch)).WillOnce(Return(56));
-    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pitch, 35.3));
+    EXPECT_CALL(target, soundEffectValue(Sound::Effect::Pitch)).WillOnce(Return(56));
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pitch, 35.3));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(target, soundEffect(Sound::Effect::Pan)).WillOnce(Return(-2.5));
-    EXPECT_CALL(target, setSoundEffect(Sound::Effect::Pan, 10.03));
+    EXPECT_CALL(target, soundEffectValue(Sound::Effect::Pan)).WillOnce(Return(-2.5));
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pan, 10.03));
     vm.reset();
     vm.setBytecode(bytecode2);
     vm.run();
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 416d1ff1..5df18e09 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -17,8 +17,8 @@ class TargetMock : public Target
 
         MOCK_METHOD(void, setLayerOrder, (int), (override));
 
-        MOCK_METHOD(double, soundEffect, (Sound::Effect), (const, override));
-        MOCK_METHOD(void, setSoundEffect, (Sound::Effect, double), (override));
+        MOCK_METHOD(double, soundEffectValue, (Sound::Effect), (const, override));
+        MOCK_METHOD(void, setSoundEffectValue, (Sound::Effect, double), (override));
 
         MOCK_METHOD(void, clearSoundEffects, (), (override));
 
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 7b09d0b7..e71771d2 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -515,8 +515,8 @@ TEST(TargetTest, Volume)
 TEST(TargetTest, SoundEffects)
 {
     Target target;
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 0);
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
 
     auto s1 = std::make_shared<SoundMock>();
     auto s2 = std::make_shared<SoundMock>();
@@ -532,16 +532,16 @@ TEST(TargetTest, SoundEffects)
     EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 12.5));
     EXPECT_CALL(*s2, setEffect(Sound::Effect::Pitch, 12.5));
     EXPECT_CALL(*s3, setEffect(Sound::Effect::Pitch, 12.5));
-    target.setSoundEffect(Sound::Effect::Pitch, 12.5);
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 12.5);
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), 0);
+    target.setSoundEffectValue(Sound::Effect::Pitch, 12.5);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 12.5);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
 
     EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, -56.7));
     EXPECT_CALL(*s2, setEffect(Sound::Effect::Pan, -56.7));
     EXPECT_CALL(*s3, setEffect(Sound::Effect::Pan, -56.7));
-    target.setSoundEffect(Sound::Effect::Pan, -56.7);
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 12.5);
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), -56.7);
+    target.setSoundEffectValue(Sound::Effect::Pan, -56.7);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 12.5);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), -56.7);
 
     auto s4 = std::make_shared<SoundMock>();
     EXPECT_CALL(*s4, setVolume);
@@ -558,8 +558,8 @@ TEST(TargetTest, SoundEffects)
     EXPECT_CALL(*s4, setEffect(Sound::Effect::Pitch, 0));
     EXPECT_CALL(*s4, setEffect(Sound::Effect::Pan, 0));
     target.clearSoundEffects();
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pitch), 0);
-    ASSERT_EQ(target.soundEffect(Sound::Effect::Pan), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
 }
 
 TEST(TargetTest, CurrentCostumeWidth)