Implement control_delete_this_clone block

Author: adazem009

src/blocks/controlblocks.cpp

@@ -32,6 +32,7 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "control_wait_until", &compileWaitUntil);
     engine->addCompileFunction(this, "control_start_as_clone", &compileStartAsClone);
     engine->addCompileFunction(this, "control_create_clone_of", &compileCreateClone);
+    engine->addCompileFunction(this, "control_delete_this_clone", &compileDeleteThisClone);
 
     // Inputs
     engine->addInput(this, "SUBSTACK", SUBSTACK);
@@ -187,6 +188,11 @@ void ControlBlocks::compileCreateClone(Compiler *compiler)
     }
 }
 
+void ControlBlocks::compileDeleteThisClone(Compiler *compiler)
+{
+    compiler->addFunctionCall(&deleteThisClone);
+}
+
 unsigned int ControlBlocks::stopAll(VirtualMachine *vm)
 {
     vm->engine()->stop();
@@ -267,3 +273,15 @@ unsigned int ControlBlocks::createCloneOfMyself(VirtualMachine *vm)
 
     return 0;
 }
+
+unsigned int ControlBlocks::deleteThisClone(VirtualMachine *vm)
+{
+    Target *target = vm->target();
+
+    if (target) {
+        vm->engine()->stopTarget(target, nullptr);
+        target->~Target();
+    }
+
+    return 0;
+}

src/blocks/controlblocks.h

@@ -56,6 +56,7 @@ class ControlBlocks : public IBlockSection
         static void compileWaitUntil(Compiler *compiler);
         static void compileStartAsClone(Compiler *compiler);
         static void compileCreateClone(Compiler *compiler);
+        static void compileDeleteThisClone(Compiler *compiler);
 
         static unsigned int stopAll(VirtualMachine *vm);
         static unsigned int stopOtherScriptsInSprite(VirtualMachine *vm);
@@ -65,6 +66,7 @@ class ControlBlocks : public IBlockSection
         static unsigned int createClone(VirtualMachine *vm);
         static unsigned int createCloneByIndex(VirtualMachine *vm);
         static unsigned int createCloneOfMyself(VirtualMachine *vm);
+        static unsigned int deleteThisClone(VirtualMachine *vm);
 
         static inline std::unordered_map<VirtualMachine *, std::pair<std::chrono::steady_clock::time_point, int>> m_timeMap;
 };

test/blocks/control_blocks_test.cpp

@@ -14,6 +14,8 @@
 using namespace libscratchcpp;
 
 using ::testing::Return;
+using ::testing::_;
+using ::testing::SaveArg;
 
 class ControlBlocksTest : public testing::Test
 {
@@ -153,6 +155,7 @@ TEST_F(ControlBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_wait_until", &ControlBlocks::compileWaitUntil)).Times(1);
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_start_as_clone", &ControlBlocks::compileStartAsClone)).Times(1);
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_create_clone_of", &ControlBlocks::compileCreateClone)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_delete_this_clone", &ControlBlocks::compileDeleteThisClone)).Times(1);
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SUBSTACK", ControlBlocks::SUBSTACK));
@@ -938,3 +941,47 @@ TEST_F(ControlBlocksTest, StartAsClone)
     EXPECT_CALL(m_engineMock, addCloneInitScript(block)).Times(1);
     ControlBlocks::compileStartAsClone(&compiler);
 }
+
+TEST_F(ControlBlocksTest, DeleteThisClone)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = createControlBlock("a", "control_delete_this_clone");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&ControlBlocks::deleteThisClone)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    ControlBlocks::compileDeleteThisClone(&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());
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(ControlBlocksTest, DeleteThisCloneImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &ControlBlocks::deleteThisClone };
+
+    Sprite sprite;
+    sprite.setEngine(&m_engineMock);
+
+    Sprite *clone;
+    EXPECT_CALL(m_engineMock, initClone(_)).WillOnce(SaveArg<0>(&clone));
+    sprite.clone();
+    ASSERT_TRUE(clone);
+
+    VirtualMachine vm(clone, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+
+    EXPECT_CALL(m_engineMock, stopTarget(clone, nullptr)).Times(1);
+
+    vm.setBytecode(bytecode);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_TRUE(sprite.children().empty());
+}