Merge pull request #322 from scratchcpp/volume_blocks

Implement volume blocks

Author: adazem009

include/scratchcpp/target.h

@@ -68,8 +68,8 @@ class LIBSCRATCHCPP_EXPORT Target
         int layerOrder() const;
         void setLayerOrder(int newLayerOrder);
 
-        int volume() const;
-        void setVolume(int newVolume);
+        double volume() const;
+        void setVolume(double newVolume);
 
         IEngine *engine() const;
         void setEngine(IEngine *engine);

src/blocks/soundblocks.cpp

@@ -1,5 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/target.h>
+
 #include "soundblocks.h"
 
 using namespace libscratchcpp;
@@ -11,4 +15,54 @@ std::string SoundBlocks::name() const
 
 void SoundBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
+    engine->addCompileFunction(this, "sound_changevolumeby", &compileChangeVolumeBy);
+    engine->addCompileFunction(this, "sound_setvolumeto", &compileSetVolumeTo);
+    engine->addCompileFunction(this, "sound_volume", &compileVolume);
+
+    // Inputs
+    engine->addInput(this, "VOLUME", VOLUME);
+}
+
+void SoundBlocks::compileChangeVolumeBy(Compiler *compiler)
+{
+    compiler->addInput(VOLUME);
+    compiler->addFunctionCall(&changeVolumeBy);
+}
+
+void SoundBlocks::compileSetVolumeTo(Compiler *compiler)
+{
+    compiler->addInput(VOLUME);
+    compiler->addFunctionCall(&setVolumeTo);
+}
+
+void SoundBlocks::compileVolume(Compiler *compiler)
+{
+    compiler->addFunctionCall(&volume);
+}
+
+unsigned int SoundBlocks::changeVolumeBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setVolume(target->volume() + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::setVolumeTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setVolume(vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::volume(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        vm->addReturnValue(target->volume());
+    else
+        vm->addReturnValue(0);
+
+    return 0;
 }

src/blocks/soundblocks.h

@@ -11,9 +11,32 @@ namespace libscratchcpp
 class SoundBlocks : public IBlockSection
 {
     public:
+        enum Inputs
+        {
+            VOLUME
+        };
+
+        enum Fields
+        {
+
+        };
+
+        enum FieldValues
+        {
+
+        };
+
         std::string name() const override;
 
         void registerBlocks(IEngine *engine) override;
+
+        static void compileChangeVolumeBy(Compiler *compiler);
+        static void compileSetVolumeTo(Compiler *compiler);
+        static void compileVolume(Compiler *compiler);
+
+        static unsigned int changeVolumeBy(VirtualMachine *vm);
+        static unsigned int setVolumeTo(VirtualMachine *vm);
+        static unsigned int volume(VirtualMachine *vm);
 };
 
 } // namespace libscratchcpp

src/scratch/target.cpp

@@ -338,15 +338,20 @@ void Target::setLayerOrder(int newLayerOrder)
 }
 
 /*! Returns the volume. */
-int Target::volume() const
+double Target::volume() const
 {
     return impl->volume;
 }
 
 /*! Sets the volume. */
-void Target::setVolume(int newVolume)
-{
-    impl->volume = newVolume;
+void Target::setVolume(double newVolume)
+{
+    if (newVolume >= 100)
+        impl->volume = 100;
+    else if (newVolume <= 0)
+        impl->volume = 0;
+    else
+        impl->volume = newVolume;
 }
 
 /*! Returns the engine. */

src/scratch/target_p.h

@@ -30,7 +30,7 @@ struct TargetPrivate
         std::vector<std::shared_ptr<Costume>> costumes;
         std::vector<std::shared_ptr<Sound>> sounds;
         int layerOrder = 0;
-        int volume = 100;
+        double volume = 100;
 };
 
 } // namespace libscratchcpp

test/blocks/CMakeLists.txt

@@ -141,3 +141,19 @@ target_link_libraries(
 )
 
 gtest_discover_tests(looks_blocks_test)
+
+# sound_blocks_test
+add_executable(
+  sound_blocks_test
+  sound_blocks_test.cpp
+)
+
+target_link_libraries(
+  sound_blocks_test
+  GTest::gtest_main
+  GTest::gmock_main
+  scratchcpp
+  scratchcpp_mocks
+)
+
+gtest_discover_tests(sound_blocks_test)

test/blocks/sound_blocks_test.cpp

@@ -0,0 +1,236 @@
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
+#include <scratchcpp/target.h>
+#include <enginemock.h>
+
+#include "../common.h"
+#include "blocks/soundblocks.h"
+#include "engine/internal/engine.h"
+
+using namespace libscratchcpp;
+
+using ::testing::Return;
+
+class SoundBlocksTest : public testing::Test
+{
+    public:
+        void SetUp() override
+        {
+            m_section = std::make_unique<SoundBlocks>();
+            m_section->registerBlocks(&m_engine);
+        }
+
+        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 addValueInput(std::shared_ptr<Block> block, const std::string &name, SoundBlocks::Inputs id, const Value &value) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::Shadow);
+            input->setPrimaryValue(value);
+            input->setInputId(id);
+            block->addInput(input);
+        }
+
+        void addObscuredInput(std::shared_ptr<Block> block, const std::string &name, SoundBlocks::Inputs id, std::shared_ptr<Block> valueBlock) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::ObscuredShadow);
+            input->setValueBlock(valueBlock);
+            input->setInputId(id);
+            block->addInput(input);
+        }
+
+        std::shared_ptr<Input> addNullInput(std::shared_ptr<Block> block, const std::string &name, SoundBlocks::Inputs id) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::Shadow);
+            input->setInputId(id);
+            block->addInput(input);
+
+            return input;
+        }
+
+        void addDropdownInput(std::shared_ptr<Block> block, const std::string &name, SoundBlocks::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<SoundBlocks::Fields>(-1), selectedValue, static_cast<SoundBlocks::FieldValues>(-1));
+            }
+        }
+
+        void addDropdownField(std::shared_ptr<Block> block, const std::string &name, SoundBlocks::Fields id, const std::string &value, SoundBlocks::FieldValues valueId) const
+        {
+            auto field = std::make_shared<Field>(name, value);
+            field->setFieldId(id);
+            field->setSpecialValueId(valueId);
+            block->addField(field);
+        }
+
+        std::unique_ptr<IBlockSection> m_section;
+        Engine m_engine;
+        EngineMock m_engineMock;
+};
+
+TEST_F(SoundBlocksTest, Name)
+{
+    ASSERT_EQ(m_section->name(), "Sound");
+}
+
+TEST_F(SoundBlocksTest, CategoryVisible)
+{
+    ASSERT_TRUE(m_section->categoryVisible());
+}
+
+TEST_F(SoundBlocksTest, RegisterBlocks)
+{
+    // Blocks
+    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));
+
+    // Inputs
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VOLUME", SoundBlocks::VOLUME));
+
+    m_section->registerBlocks(&m_engineMock);
+}
+
+TEST_F(SoundBlocksTest, ChangeVolumeBy)
+{
+    Compiler compiler(&m_engineMock);
+
+    // change volume by (53.05)
+    auto block1 = std::make_shared<Block>("a", "sound_changevolumeby");
+    addValueInput(block1, "VOLUME", SoundBlocks::VOLUME, 53.05);
+
+    // change volume by (-2.13)
+    auto block2 = std::make_shared<Block>("b", "sound_changevolumeby");
+    addValueInput(block2, "VOLUME", SoundBlocks::VOLUME, -2.13);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::changeVolumeBy)).Times(2).WillRepeatedly(Return(0));
+
+    compiler.init();
+
+    compiler.setBlock(block1);
+    SoundBlocks::compileChangeVolumeBy(&compiler);
+
+    compiler.setBlock(block2);
+    SoundBlocks::compileChangeVolumeBy(&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, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 53.05, -2.13 }));
+}
+
+TEST_F(SoundBlocksTest, ChangeVolumeByImpl)
+{
+    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 BlockFunc functions[] = { &SoundBlocks::changeVolumeBy };
+    static Value constValues[] = { 53.05, -2.13 };
+
+    Target target;
+    target.setVolume(42.4);
+
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode1);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(std::round(target.volume() * 100) / 100, 95.45);
+
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(std::round(target.volume() * 100) / 100, 93.32);
+}
+
+TEST_F(SoundBlocksTest, SetVolumeTo)
+{
+    Compiler compiler(&m_engineMock);
+
+    // set volume to (43.409) %
+    auto block = std::make_shared<Block>("a", "sound_setvolumeto");
+    addValueInput(block, "VOLUME", SoundBlocks::VOLUME, 43.409);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::setVolumeTo)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SoundBlocks::compileSetVolumeTo(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0].toDouble(), 43.409);
+}
+
+TEST_F(SoundBlocksTest, SetVolumeToImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::setVolumeTo };
+    static Value constValues[] = { 43.409 };
+
+    Target target;
+    target.setVolume(42.4);
+
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.volume(), 43.409);
+}
+
+TEST_F(SoundBlocksTest, Volume)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sound_volume");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::volume)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SoundBlocks::compileVolume(&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, VolumeImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::volume };
+
+    Target target;
+    target.setVolume(42.4);
+
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 42.4);
+}