Merge pull request #180 from scratchcpp/top_level_reporter_blocks

Add API for top level reporter blocks

Author: adazem009

include/scratchcpp/block.h

@@ -12,6 +12,7 @@ class IEngine;
 class Target;
 class Input;
 class Field;
+class InputValue;
 class BlockPrivate;
 
 /*! \brief The Block class represents a Scratch block. */
@@ -68,6 +69,11 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
 
         BlockPrototype *mutationPrototype();
 
+        bool isTopLevelReporter() const;
+        void setIsTopLevelReporter(bool isTopLevelReporter);
+
+        InputValue *topLevelReporterInfo();
+
     private:
         spimpl::unique_impl_ptr<BlockPrivate> impl;
 };

src/internal/scratch3reader.cpp

@@ -79,11 +79,22 @@ bool Scratch3Reader::load()
             auto blocks = jsonTarget["blocks"];
             for (json::iterator it = blocks.begin(); it != blocks.end(); ++it) {
                 auto blockInfo = it.value();
+
                 if (blockInfo.is_array()) {
-                    // TODO: Find out what these "array" blocks that look like input values are for
-                    // Let's ignore them for now...
+                    // This is a top level reporter block for a variable/list
+                    READER_STEP(step, "target -> block -> top level reporter info");
+                    auto block = std::make_shared<Block>(it.key(), "");
+                    block->setIsTopLevelReporter(true);
+                    InputValue *reporterInfo = block->topLevelReporterInfo();
+
+                    reporterInfo->setValue(jsonToValue(blockInfo[1]));
+                    reporterInfo->setValueId(jsonToValue(blockInfo[2]).toString());
+                    reporterInfo->setType(static_cast<InputValue::Type>(blockInfo[0]));
+
+                    target->addBlock(block);
                     continue;
                 }
+
                 READER_STEP(step, "target -> block -> opcode");
                 auto block = std::make_shared<Block>(it.key(), blockInfo["opcode"]);
                 std::string nextId;

src/scratch/block.cpp

@@ -58,6 +58,41 @@ BlockPrototype *Block::mutationPrototype()
     return &impl->mutationPrototype;
 }
 
+/*! Returns true if this is a top level reporter block for a variable or a list. */
+bool Block::isTopLevelReporter() const
+{
+    return impl->isTopLevelReporter;
+}
+
+/*!
+ * Sets whether this block is a top level reporter block for a variable or a list.
+ * \note Setting this to true will allow the use topLevelReporterInfo().
+ */
+void Block::setIsTopLevelReporter(bool isTopLevelReporter)
+{
+    impl->isTopLevelReporter = isTopLevelReporter;
+
+    if (isTopLevelReporter && !impl->topLevelReporterInfo)
+        impl->topLevelReporterInfo = std::make_unique<InputValue>(InputValue::Type::Variable);
+    else if (impl->topLevelReporterInfo) {
+        impl->topLevelReporterInfo.reset();
+        impl->topLevelReporterInfo = nullptr;
+    }
+}
+
+/*!
+ * Returns the information about this top level reporter block (if this is a top level reporter block).
+ * \note This function will return nullptr if this isn't a top level reporter block. Use setIsTopLevelReporter(true)
+ * before using this function.
+ */
+InputValue *Block::topLevelReporterInfo()
+{
+    if (impl->topLevelReporterInfo)
+        return impl->topLevelReporterInfo.get();
+    else
+        return nullptr;
+}
+
 /*! Returns the next block. */
 std::shared_ptr<Block> Block::next() const
 {

src/scratch/block_p.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <scratchcpp/blockprototype.h>
+#include <scratchcpp/inputvalue.h>
 
 namespace libscratchcpp
 {
@@ -33,6 +34,8 @@ struct BlockPrivate
         Target *target = nullptr;
         BlockPrototype mutationPrototype;
         bool mutationHasNext = true;
+        bool isTopLevelReporter = false;
+        std::unique_ptr<InputValue> topLevelReporterInfo = nullptr;
 };
 
 } // namespace libscratchcpp

test/load_project/load_project_test.cpp

@@ -10,6 +10,7 @@
 #include <scratchcpp/costume.h>
 #include <scratchcpp/sound.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/inputvalue.h>
 
 #include "../common.h"
 
@@ -124,17 +125,20 @@ TEST(LoadProjectTest, LoadTestProject)
         // Sprite1: blocks
         ASSERT_EQ(sprite1->greenFlagBlocks().size(), 1);
         ASSERT_TRUE(sprite1->greenFlagBlocks()[0]);
+        ASSERT_FALSE(sprite1->greenFlagBlocks()[0]->isTopLevelReporter());
         ASSERT_EQ(sprite1->greenFlagBlocks()[0]->opcode(), "event_whenflagclicked");
         auto block = sprite1->greenFlagBlocks()[0]->next();
         ASSERT_TRUE(block);
         ASSERT_EQ(block->parent(), sprite1->greenFlagBlocks()[0]);
         ASSERT_EQ(block->opcode(), "control_forever");
+        ASSERT_FALSE(block->isTopLevelReporter());
         ASSERT_INPUT(block, "SUBSTACK");
         block = GET_INPUT(block, "SUBSTACK")->valueBlock();
         ASSERT_TRUE(block);
 
         ASSERT_EQ(block->opcode(), "motion_goto");
         ASSERT_INPUT(block, "TO");
+        ASSERT_FALSE(block->isTopLevelReporter());
         auto inputBlock = GET_INPUT(block, "TO")->valueBlock();
         ASSERT_TRUE(inputBlock);
         ASSERT_EQ(inputBlock->opcode(), "motion_goto_menu");
@@ -155,6 +159,7 @@ TEST(LoadProjectTest, LoadTestProject)
         inputBlock = GET_INPUT(block, "VALUE")->valueBlock();
         ASSERT_TRUE(inputBlock);
         ASSERT_EQ(inputBlock->opcode(), "operator_random");
+        ASSERT_FALSE(inputBlock->isTopLevelReporter());
         ASSERT_INPUT(inputBlock, "FROM");
         ASSERT_EQ(GET_INPUT(inputBlock, "FROM")->primaryValue()->value().toInt(), 1);
         ASSERT_INPUT(inputBlock, "TO");
@@ -250,6 +255,47 @@ TEST(LoadProjectTest, LoadTestProject)
     }
 }
 
+TEST(LoadProjectTest, LoadTopLevelReporterProject)
+{
+    int i = 0;
+    for (auto version : scratchVersions) {
+        Project p("top_level_reporter" + fileExtensions[i], version);
+
+        ASSERT_TRUE(p.load());
+
+        auto engine = p.engine();
+        ASSERT_EQ(engine->targets().size(), 2);
+
+        // Sprite1
+        ASSERT_NE(engine->findTarget("Sprite1"), -1);
+        Sprite *sprite1 = dynamic_cast<Sprite *>(engine->targetAt(engine->findTarget("Sprite1")));
+        ASSERT_EQ(sprite1->blocks().size(), 2);
+
+        // Sprite1: blocks
+        auto block1 = sprite1->blockAt(0);
+        ASSERT_TRUE(block1);
+        ASSERT_TRUE(block1->isTopLevelReporter());
+        InputValue *reporterInfo = block1->topLevelReporterInfo();
+        ASSERT_TRUE(reporterInfo);
+        ASSERT_EQ(reporterInfo->type(), InputValue::Type::Variable);
+        ASSERT_EQ(reporterInfo->value(), "var");
+        ASSERT_EQ(reporterInfo->valueId(), "b[Pq/qD6PJ+hpWtz;X`G");
+        ASSERT_EQ(reporterInfo->valuePtr(), sprite1->variableAt(0));
+
+        auto block2 = sprite1->blockAt(1);
+        ASSERT_TRUE(block2);
+        ASSERT_TRUE(block2->isTopLevelReporter());
+        reporterInfo = block2->topLevelReporterInfo();
+        ASSERT_TRUE(reporterInfo);
+        ASSERT_EQ(reporterInfo->type(), InputValue::Type::List);
+        ASSERT_EQ(reporterInfo->value(), "list");
+        ASSERT_EQ(reporterInfo->valueId(), "*BW*~d~DgcZee0q=v*T2");
+        ASSERT_EQ(reporterInfo->valuePtr(), sprite1->listAt(0));
+
+        i++;
+    }
+}
+
 TEST(LoadProjectTest, ProjectTest)
 {
     int i = 0;

test/scratch_classes/block_test.cpp

@@ -241,3 +241,20 @@ TEST_F(BlockTest, MutationPrototype)
     Block block("", "");
     ASSERT_TRUE(block.mutationPrototype());
 }
+
+TEST_F(BlockTest, TopLevelReporter)
+{
+    Block block("", "");
+    ASSERT_FALSE(block.isTopLevelReporter());
+    ASSERT_EQ(block.topLevelReporterInfo(), nullptr);
+
+    for (int i = 0; i < 2; i++) {
+        block.setIsTopLevelReporter(true);
+        ASSERT_TRUE(block.isTopLevelReporter());
+        ASSERT_TRUE(block.topLevelReporterInfo());
+
+        block.setIsTopLevelReporter(false);
+        ASSERT_FALSE(block.isTopLevelReporter());
+        ASSERT_EQ(block.topLevelReporterInfo(), nullptr);
+    }
+}