Implement looks_costumenumbername block

Author: adazem009

src/blocks/looksblocks.cpp

@@ -3,6 +3,8 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/field.h>
+#include <scratchcpp/costume.h>
 
 #include "looksblocks.h"
 
@@ -21,10 +23,18 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "looks_changesizeby", &compileChangeSizeBy);
     engine->addCompileFunction(this, "looks_setsizeto", &compileSetSizeTo);
     engine->addCompileFunction(this, "looks_size", &compileSize);
+    engine->addCompileFunction(this, "looks_costumenumbername", &compileCostumeNumberName);
 
     // Inputs
     engine->addInput(this, "CHANGE", CHANGE);
     engine->addInput(this, "SIZE", SIZE);
+
+    // Fields
+    engine->addField(this, "NUMBER_NAME", NUMBER_NAME);
+
+    // Field values
+    engine->addFieldValue(this, "number", CostumeNumber);
+    engine->addFieldValue(this, "name", CostumeName);
 }
 
 void LooksBlocks::compileShow(Compiler *compiler)
@@ -54,6 +64,21 @@ void LooksBlocks::compileSize(Compiler *compiler)
     compiler->addFunctionCall(&size);
 }
 
+void LooksBlocks::compileCostumeNumberName(Compiler *compiler)
+{
+    int option = compiler->field(NUMBER_NAME)->specialValueId();
+
+    switch (option) {
+        case CostumeNumber:
+            compiler->addFunctionCall(&costumeNumber);
+            break;
+
+        case CostumeName:
+            compiler->addFunctionCall(&costumeName);
+            break;
+    }
+}
+
 unsigned int LooksBlocks::show(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
@@ -105,3 +130,28 @@ unsigned int LooksBlocks::size(VirtualMachine *vm)
 
     return 0;
 }
+
+unsigned int LooksBlocks::costumeNumber(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        vm->addReturnValue(target->currentCostume());
+    else
+        vm->addReturnValue(0);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::costumeName(VirtualMachine *vm)
+{
+    if (Target *target = vm->target()) {
+        auto costume = target->costumeAt(target->currentCostume() - 1);
+
+        if (costume)
+            vm->addReturnValue(costume->name());
+        else
+            vm->addReturnValue("");
+    } else
+        vm->addReturnValue("");
+
+    return 0;
+}

src/blocks/looksblocks.h

@@ -19,10 +19,13 @@ class LooksBlocks : public IBlockSection
 
         enum Fields
         {
+            NUMBER_NAME
         };
 
         enum FieldValues
         {
+            CostumeNumber,
+            CostumeName
         };
 
         std::string name() const override;
@@ -34,12 +37,15 @@ class LooksBlocks : public IBlockSection
         static void compileChangeSizeBy(Compiler *compiler);
         static void compileSetSizeTo(Compiler *compiler);
         static void compileSize(Compiler *compiler);
+        static void compileCostumeNumberName(Compiler *compiler);
 
         static unsigned int show(VirtualMachine *vm);
         static unsigned int hide(VirtualMachine *vm);
         static unsigned int changeSizeBy(VirtualMachine *vm);
         static unsigned int setSizeTo(VirtualMachine *vm);
         static unsigned int size(VirtualMachine *vm);
+        static unsigned int costumeNumber(VirtualMachine *vm);
+        static unsigned int costumeName(VirtualMachine *vm);
 };
 
 } // namespace libscratchcpp

test/blocks/looks_blocks_test.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/costume.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -97,11 +98,19 @@ TEST_F(LooksBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_changesizeby", &LooksBlocks::compileChangeSizeBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_setsizeto", &LooksBlocks::compileSetSizeTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_size", &LooksBlocks::compileSize));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_costumenumbername", &LooksBlocks::compileCostumeNumberName));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "CHANGE", LooksBlocks::CHANGE));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SIZE", LooksBlocks::SIZE));
 
+    // Fields
+    EXPECT_CALL(m_engineMock, addField(m_section.get(), "NUMBER_NAME", LooksBlocks::NUMBER_NAME));
+
+    // Field values
+    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "number", LooksBlocks::CostumeNumber));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "name", LooksBlocks::CostumeName));
+
     m_section->registerBlocks(&m_engineMock);
 }
 
@@ -296,3 +305,81 @@ TEST_F(LooksBlocksTest, SizeImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.getInput(0, 1)->toDouble(), -51.0684);
 }
+
+TEST_F(LooksBlocksTest, CostumeNumberName)
+{
+    Compiler compiler(&m_engineMock);
+
+    // costume [number]
+    auto block1 = std::make_shared<Block>("a", "looks_costumenumbername");
+    addDropdownField(block1, "NUMBER_NAME", LooksBlocks::NUMBER_NAME, "number", LooksBlocks::CostumeNumber);
+
+    // costume [name]
+    auto block2 = std::make_shared<Block>("b", "looks_costumenumbername");
+    addDropdownField(block2, "NUMBER_NAME", LooksBlocks::NUMBER_NAME, "name", LooksBlocks::CostumeName);
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::costumeNumber)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    LooksBlocks::compileCostumeNumberName(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::costumeName)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    LooksBlocks::compileCostumeNumberName(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(LooksBlocksTest, CostumeNumberNameImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::costumeNumber, &LooksBlocks::costumeName };
+
+    auto c1 = std::make_shared<Costume>("costume1", "c1", "svg");
+    auto c2 = std::make_shared<Costume>("costume2", "c2", "svg");
+    auto c3 = std::make_shared<Costume>("costume3", "c3", "svg");
+
+    Target target;
+    target.addCostume(c1);
+    target.addCostume(c2);
+    target.addCostume(c3);
+
+    VirtualMachine vm(&target, nullptr, nullptr);
+    vm.setFunctions(functions);
+
+    target.setCurrentCostume(2);
+
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 2);
+
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toString(), "costume2");
+
+    target.setCurrentCostume(3);
+
+    vm.reset();
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 3);
+
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toString(), "costume3");
+}