Implement sound_seteffectto block

Author: adazem009

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())

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);

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);