Implement looks_seteffectto block

Author: adazem009

src/blocks/looksblocks.cpp

@@ -48,6 +48,7 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "looks_show", &compileShow);
     engine->addCompileFunction(this, "looks_hide", &compileHide);
     engine->addCompileFunction(this, "looks_changeeffectby", &compileChangeEffectBy);
+    engine->addCompileFunction(this, "looks_seteffectto", &compileSetEffectTo);
 }
 
 void LooksBlocks::onInit(IEngine *engine)
@@ -179,6 +180,24 @@ CompilerValue *LooksBlocks::compileChangeEffectBy(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *LooksBlocks::compileSetEffectTo(Compiler *compiler)
+{
+    Field *field = compiler->field("EFFECT");
+
+    if (!field)
+        return nullptr;
+
+    auto index = getEffectIndex(compiler->engine(), field->value().toString());
+
+    if (index != -1) {
+        auto indexValue = compiler->addConstValue(index);
+        auto value = compiler->addInput("VALUE");
+        compiler->addTargetFunctionCall("looks_seteffectto", Compiler::StaticType::Void, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { indexValue, value });
+    }
+
+    return nullptr;
+}
+
 extern "C" void looks_start_stack_timer(ExecutionContext *ctx, double duration)
 {
     ctx->stackTimer()->start(duration);
@@ -238,3 +257,8 @@ extern "C" void looks_changeeffectby(Target *target, double index, double change
     IGraphicsEffect *effect = LooksBlocks::getEffect(target->engine(), index);
     target->setGraphicsEffectValue(effect, target->graphicsEffectValue(effect) + change);
 }
+
+extern "C" void looks_seteffectto(Target *target, double index, double value)
+{
+    target->setGraphicsEffectValue(LooksBlocks::getEffect(target->engine(), index), value);
+}

src/blocks/looksblocks.h

@@ -38,6 +38,7 @@ class LooksBlocks : public IExtension
         static CompilerValue *compileShow(Compiler *compiler);
         static CompilerValue *compileHide(Compiler *compiler);
         static CompilerValue *compileChangeEffectBy(Compiler *compiler);
+        static CompilerValue *compileSetEffectTo(Compiler *compiler);
 
         IEngine *m_engine = nullptr;
         std::unordered_map<std::string, long> m_effectMap;

test/blocks/looks_blocks_test.cpp

@@ -404,3 +404,94 @@ TEST_F(LooksBlocksTest, ChangeEffectBy)
         builder.run();
     }
 }
+
+TEST_F(LooksBlocksTest, SetEffectTo)
+{
+    // Fisheye
+    {
+        auto stage = std::make_shared<Stage>();
+        stage->setEngine(m_engine);
+
+        ScriptBuilder builder(m_extension.get(), m_engine, stage);
+        IGraphicsEffect *effect = ScratchConfiguration::getGraphicsEffect("FISHEYE");
+        ASSERT_TRUE(effect);
+
+        builder.addBlock("looks_seteffectto");
+        builder.addDropdownField("EFFECT", "FISHEYE");
+        builder.addValueInput("VALUE", 45.2);
+        auto block = builder.currentBlock();
+
+        Compiler compiler(m_engine, stage.get());
+        auto code = compiler.compile(block);
+        Script script(stage.get(), block, m_engine);
+        script.setCode(code);
+        Thread thread(stage.get(), m_engine, &script);
+
+        stage->setGraphicsEffectValue(effect, 86.84);
+        thread.run();
+        ASSERT_EQ(std::round(stage->graphicsEffectValue(effect) * 100) / 100, 45.2);
+    }
+
+    // Pixelate
+    {
+        auto stage = std::make_shared<Stage>();
+        stage->setEngine(m_engine);
+
+        ScriptBuilder builder(m_extension.get(), m_engine, stage);
+        IGraphicsEffect *effect = ScratchConfiguration::getGraphicsEffect("PIXELATE");
+        ASSERT_TRUE(effect);
+
+        builder.addBlock("looks_seteffectto");
+        builder.addDropdownField("EFFECT", "PIXELATE");
+        builder.addValueInput("VALUE", 12.05);
+        auto block = builder.currentBlock();
+
+        Compiler compiler(m_engine, stage.get());
+        auto code = compiler.compile(block);
+        Script script(stage.get(), block, m_engine);
+        script.setCode(code);
+        Thread thread(stage.get(), m_engine, &script);
+
+        thread.run();
+        ASSERT_EQ(std::round(stage->graphicsEffectValue(effect) * 100) / 100, 12.05);
+    }
+
+    // Mosaic
+    {
+        auto sprite = std::make_shared<Sprite>();
+        sprite->setEngine(m_engine);
+
+        ScriptBuilder builder(m_extension.get(), m_engine, sprite);
+        IGraphicsEffect *effect = ScratchConfiguration::getGraphicsEffect("MOSAIC");
+        ASSERT_TRUE(effect);
+
+        builder.addBlock("looks_seteffectto");
+        builder.addDropdownField("EFFECT", "MOSAIC");
+        builder.addValueInput("VALUE", -8.06);
+        auto block = builder.currentBlock();
+
+        Compiler compiler(m_engine, sprite.get());
+        auto code = compiler.compile(block);
+        Script script(sprite.get(), block, m_engine);
+        script.setCode(code);
+        Thread thread(sprite.get(), m_engine, &script);
+
+        sprite->setGraphicsEffectValue(effect, 13.12);
+        thread.run();
+        ASSERT_EQ(std::round(sprite->graphicsEffectValue(effect) * 100) / 100, -8.06);
+    }
+
+    // Invalid
+    {
+        auto stage = std::make_shared<Stage>();
+        stage->setEngine(m_engine);
+
+        ScriptBuilder builder(m_extension.get(), m_engine, stage);
+        builder.addBlock("looks_seteffectto");
+        builder.addDropdownField("EFFECT", "INVALID");
+        builder.addValueInput("VALUE", 8.3);
+
+        builder.build();
+        builder.run();
+    }
+}