Implement looks_switchcostumeto block

Author: adazem009

src/blocks/looksblocks.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/costume.h>
 
@@ -23,11 +24,13 @@ 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_switchcostumeto", &compileSwitchCostumeTo);
     engine->addCompileFunction(this, "looks_costumenumbername", &compileCostumeNumberName);
 
     // Inputs
     engine->addInput(this, "CHANGE", CHANGE);
     engine->addInput(this, "SIZE", SIZE);
+    engine->addInput(this, "COSTUME", COSTUME);
 
     // Fields
     engine->addField(this, "NUMBER_NAME", NUMBER_NAME);
@@ -64,6 +67,43 @@ void LooksBlocks::compileSize(Compiler *compiler)
     compiler->addFunctionCall(&size);
 }
 
+void LooksBlocks::compileSwitchCostumeTo(Compiler *compiler)
+{
+    Target *target = compiler->target();
+
+    if (!target)
+        return;
+
+    Input *input = compiler->input(COSTUME);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string value = input->selectedMenuItem();
+        int index = target->findCostume(value);
+
+        if (index == -1) {
+            if (value == "next costume")
+                compiler->addFunctionCall(&nextCostume);
+            else if (value == "previous costume")
+                compiler->addFunctionCall(&previousCostume);
+            else {
+                Value v(value);
+
+                if (v.type() == Value::Type::Integer) {
+                    compiler->addConstValue(v.toLong() - 1);
+                    compiler->addFunctionCall(&switchCostumeToByIndex);
+                }
+            }
+        } else {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&switchCostumeToByIndex);
+        }
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&switchCostumeTo);
+    }
+}
+
 void LooksBlocks::compileCostumeNumberName(Compiler *compiler)
 {
     int option = compiler->field(NUMBER_NAME)->specialValueId();
@@ -131,6 +171,70 @@ unsigned int LooksBlocks::size(VirtualMachine *vm)
     return 0;
 }
 
+void LooksBlocks::setCostumeByIndex(Target *target, long index)
+{
+    // TODO: Remove this (#248)
+    std::size_t costumeCount = target->costumes().size();
+    if (index < 0 || index >= costumeCount) {
+        if (index < 0)
+            index = std::fmod(costumeCount + std::fmod(index, -costumeCount), costumeCount);
+        else
+            index = std::fmod(index, costumeCount);
+    }
+
+    target->setCurrentCostume(index + 1);
+}
+
+unsigned int LooksBlocks::switchCostumeToByIndex(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        setCostumeByIndex(target, vm->getInput(0, 1)->toLong());
+
+    return 1;
+}
+
+unsigned int LooksBlocks::switchCostumeTo(VirtualMachine *vm)
+{
+    Target *target = vm->target();
+
+    if (!target)
+        return 1;
+
+    const Value *name = vm->getInput(0, 1);
+    std::string nameStr = name->toString();
+    int index = target->findCostume(nameStr);
+
+    if (index == -1) {
+        if (nameStr == "next costume")
+            nextCostume(vm);
+        else if (nameStr == "previous costume")
+            previousCostume(vm);
+        else {
+            if (name->type() == Value::Type::Integer)
+                setCostumeByIndex(target, name->toLong() - 1);
+        }
+    } else
+        setCostumeByIndex(target, index);
+
+    return 1;
+}
+
+unsigned int LooksBlocks::nextCostume(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        setCostumeByIndex(target, target->currentCostume());
+
+    return 0;
+}
+
+unsigned int LooksBlocks::previousCostume(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        setCostumeByIndex(target, target->currentCostume() - 2);
+
+    return 0;
+}
+
 unsigned int LooksBlocks::costumeNumber(VirtualMachine *vm)
 {
     if (Target *target = vm->target())

src/blocks/looksblocks.h

@@ -7,14 +7,17 @@
 namespace libscratchcpp
 {
 
+class Target;
+
 /*! \brief The LooksBlocks class contains the implementation of looks blocks. */
 class LooksBlocks : public IBlockSection
 {
     public:
         enum Inputs
         {
             CHANGE,
-            SIZE
+            SIZE,
+            COSTUME
         };
 
         enum Fields
@@ -37,13 +40,21 @@ class LooksBlocks : public IBlockSection
         static void compileChangeSizeBy(Compiler *compiler);
         static void compileSetSizeTo(Compiler *compiler);
         static void compileSize(Compiler *compiler);
+        static void compileSwitchCostumeTo(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 void setCostumeByIndex(Target *target, long index);
+        static unsigned int switchCostumeToByIndex(VirtualMachine *vm);
+        static unsigned int switchCostumeTo(VirtualMachine *vm);
+        static unsigned int nextCostume(VirtualMachine *vm);
+        static unsigned int previousCostume(VirtualMachine *vm);
+
         static unsigned int costumeNumber(VirtualMachine *vm);
         static unsigned int costumeName(VirtualMachine *vm);
 };