Implement data_variable monitor

Author: adazem009

src/blocks/variableblocks.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/variable.h>
@@ -28,9 +29,16 @@ Rgb VariableBlocks::color() const
 
 void VariableBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
     engine->addCompileFunction(this, "data_variable", &compileVariable);
     engine->addCompileFunction(this, "data_setvariableto", &compileSetVariableTo);
     engine->addCompileFunction(this, "data_changevariableby", &compileChangeVariableBy);
+
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_variable", &variableMonitorName);
+
+    // Monitor change functions
+    engine->addMonitorChangeFunction(this, "data_variable", &changeVariableMonitorValue);
 }
 
 CompilerValue *VariableBlocks::compileVariable(Compiler *compiler)
@@ -70,3 +78,33 @@ CompilerValue *VariableBlocks::compileChangeVariableBy(Compiler *compiler)
 
     return nullptr;
 }
+
+const std::string &VariableBlocks::variableMonitorName(Block *block)
+{
+    static const std::string empty = "";
+
+    auto field = block->fieldAt(block->findField("VARIABLE"));
+
+    if (!field)
+        return empty;
+
+    Variable *var = dynamic_cast<Variable *>(field->valuePtr().get());
+
+    if (var)
+        return var->name();
+    else
+        return empty;
+}
+
+void VariableBlocks::changeVariableMonitorValue(Block *block, const Value &newValue)
+{
+    auto field = block->fieldAt(block->findField("VARIABLE"));
+
+    if (!field)
+        return;
+
+    Variable *var = dynamic_cast<Variable *>(field->valuePtr().get());
+
+    if (var)
+        var->setValue(newValue);
+}

src/blocks/variableblocks.h

@@ -20,6 +20,9 @@ class VariableBlocks : public IExtension
         static CompilerValue *compileVariable(Compiler *compiler);
         static CompilerValue *compileSetVariableTo(Compiler *compiler);
         static CompilerValue *compileChangeVariableBy(Compiler *compiler);
+
+        static const std::string &variableMonitorName(Block *block);
+        static void changeVariableMonitorValue(Block *block, const Value &newValue);
 };
 
 } // namespace libscratchcpp

test/blocks/variable_blocks_test.cpp

@@ -3,6 +3,8 @@
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/monitor.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/test/scriptbuilder.h>
 #include <enginemock.h>
 
@@ -55,6 +57,41 @@ TEST_F(VariableBlocksTest, Variable)
     ASSERT_EQ(Value(values[1]), "Hello world");
 }
 
+TEST_F(VariableBlocksTest, VariableMonitor)
+{
+    auto target = std::make_shared<Sprite>();
+    auto var1 = std::make_shared<Variable>("", "var1", 835.21);
+    target->addVariable(var1);
+    auto var2 = std::make_shared<Variable>("", "var2", "Hello world");
+    target->addVariable(var2);
+
+    auto monitor1 = std::make_shared<Monitor>("monitor", "data_variable");
+    auto monitor2 = std::make_shared<Monitor>("monitor", "data_variable");
+    monitor1->block()->setTarget(target.get());
+    monitor2->block()->setTarget(target.get());
+    m_engine->setMonitors({ monitor1, monitor2 });
+
+    ScriptBuilder builder1(m_extension.get(), m_engine, target);
+    builder1.addBlock(monitor1->block());
+    builder1.addEntityField("VARIABLE", var1);
+
+    ScriptBuilder builder2(m_extension.get(), m_engine, target);
+    builder2.addBlock(monitor2->block());
+    builder2.addEntityField("VARIABLE", var2);
+
+    m_engine->compile();
+    ASSERT_EQ(monitor1->name(), var1->name());
+    ASSERT_EQ(monitor2->name(), var2->name());
+
+    monitor1->changeValue("test");
+    ASSERT_EQ(var1->value().toString(), "test");
+    ASSERT_EQ(var2->value().toString(), "Hello world");
+
+    monitor2->changeValue(-0.25);
+    ASSERT_EQ(var1->value().toString(), "test");
+    ASSERT_EQ(var2->value().toDouble(), -0.25);
+}
+
 TEST_F(VariableBlocksTest, SetVariableTo)
 {
     auto target = std::make_shared<Sprite>();