Skip to content

Commit c9d3037

Browse files
adazem009adazem009
committed
Implement data_hidevariable block
1 parent 2431956 commit c9d3037

File tree

3 files changed

+218
-0
lines changed

3 files changed

+218
-0
lines changed

‎src/blocks/variableblocks.cpp‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,7 @@ void VariableBlocks::registerBlocks(IEngine *engine)
3636
engine->addCompileFunction(this, "data_setvariableto", &compileSetVariableTo);
3737
engine->addCompileFunction(this, "data_changevariableby", &compileChangeVariableBy);
3838
engine->addCompileFunction(this, "data_showvariable", &compileShowVariable);
39+
engine->addCompileFunction(this, "data_hidevariable", &compileHideVariable);
3940

4041
// Monitor names
4142
engine->addMonitorNameFunction(this, "data_variable", &variableMonitorName);
@@ -95,6 +96,19 @@ CompilerValue *VariableBlocks::compileShowVariable(Compiler *compiler)
9596
return nullptr;
9697
}
9798

99+
CompilerValue *VariableBlocks::compileHideVariable(Compiler *compiler)
100+
{
101+
Field *field = compiler->field("VARIABLE");
102+
assert(field);
103+
Variable *var = static_cast<Variable *>(field->valuePtr().get());
104+
assert(var);
105+
106+
CompilerConstant *varPtr = compiler->addConstValue(var);
107+
compiler->addTargetFunctionCall("data_hidevariable", Compiler::StaticType::Void, { Compiler::StaticType::Pointer }, { varPtr });
108+
109+
return nullptr;
110+
}
111+
98112
const std::string &VariableBlocks::variableMonitorName(Block *block)
99113
{
100114
static const std::string empty = "";
@@ -141,3 +155,11 @@ extern "C" void data_showvariable(Target *target, Variable *variable)
141155

142156
monitor->setVisible(true);
143157
}
158+
159+
extern "C" void data_hidevariable(Target *target, Variable *variable)
160+
{
161+
Monitor *monitor = variable->monitor();
162+
163+
if (monitor)
164+
monitor->setVisible(false);
165+
}

‎src/blocks/variableblocks.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ class VariableBlocks : public IExtension
2323
static CompilerValue *compileSetVariableTo(Compiler *compiler);
2424
static CompilerValue *compileChangeVariableBy(Compiler *compiler);
2525
static CompilerValue *compileShowVariable(Compiler *compiler);
26+
static CompilerValue *compileHideVariable(Compiler *compiler);
2627

2728
static const std::string &variableMonitorName(Block *block);
2829
static void changeVariableMonitorValue(Block *block, const Value &newValue);

‎test/blocks/variable_blocks_test.cpp‎

Lines changed: 195 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -359,3 +359,198 @@ TEST_F(VariableBlocksTest, ShowVariable_Local_FromClone)
359359
ASSERT_FALSE(clone->variableAt(0)->monitor());
360360
ASSERT_FALSE(clone->variableAt(1)->monitor());
361361
}
362+
363+
TEST_F(VariableBlocksTest, HideVariable_Global_Existent)
364+
{
365+
auto stage = std::make_shared<Stage>();
366+
auto var1 = std::make_shared<Variable>("a", "var1", 835.21);
367+
stage->addVariable(var1);
368+
auto var2 = std::make_shared<Variable>("b", "var2", "Hello world");
369+
stage->addVariable(var2);
370+
371+
auto monitor1 = std::make_shared<Monitor>("monitor", "data_variable");
372+
monitor1->block()->addField(std::make_shared<Field>("VARIABLE", var1->name(), var1));
373+
monitor1->setVisible(true);
374+
375+
auto monitor2 = std::make_shared<Monitor>("monitor", "data_variable");
376+
monitor2->block()->addField(std::make_shared<Field>("VARIABLE", var2->name(), var2));
377+
monitor2->setVisible(false);
378+
379+
m_engine->setMonitors({ monitor1, monitor2 });
380+
var1->setMonitor(monitor1.get());
381+
var2->setMonitor(monitor2.get());
382+
383+
m_engine->setTargets({ stage });
384+
385+
ScriptBuilder builder1(m_extension.get(), m_engine, stage);
386+
builder1.addBlock("data_hidevariable");
387+
builder1.addEntityField("VARIABLE", var1);
388+
389+
ScriptBuilder builder2(m_extension.get(), m_engine, stage);
390+
builder2.addBlock("data_hidevariable");
391+
builder2.addEntityField("VARIABLE", var2);
392+
393+
ScriptBuilder::buildMultiple({ &builder1, &builder2 });
394+
395+
builder1.run();
396+
ASSERT_FALSE(monitor1->visible());
397+
ASSERT_FALSE(monitor2->visible());
398+
399+
builder2.run();
400+
ASSERT_FALSE(monitor1->visible());
401+
ASSERT_FALSE(monitor2->visible());
402+
}
403+
404+
TEST_F(VariableBlocksTest, HideVariable_Global_Nonexistent)
405+
{
406+
auto stage = std::make_shared<Stage>();
407+
auto var1 = std::make_shared<Variable>("a", "var1", 835.21);
408+
stage->addVariable(var1);
409+
auto var2 = std::make_shared<Variable>("b", "var2", "Hello world");
410+
stage->addVariable(var2);
411+
412+
m_engine->setTargets({ stage });
413+
414+
ScriptBuilder builder1(m_extension.get(), m_engine, stage);
415+
builder1.addBlock("data_hidevariable");
416+
builder1.addEntityField("VARIABLE", var1);
417+
418+
ScriptBuilder builder2(m_extension.get(), m_engine, stage);
419+
builder2.addBlock("data_hidevariable");
420+
builder2.addEntityField("VARIABLE", var2);
421+
422+
ScriptBuilder::buildMultiple({ &builder1, &builder2 });
423+
424+
// Missing monitors should NOT be created
425+
builder1.run();
426+
ASSERT_FALSE(var1->monitor());
427+
428+
builder2.run();
429+
ASSERT_FALSE(var2->monitor());
430+
}
431+
432+
TEST_F(VariableBlocksTest, HideVariable_Local_Existent)
433+
{
434+
auto stage = std::make_shared<Stage>();
435+
auto sprite = std::make_shared<Sprite>();
436+
437+
auto var1 = std::make_shared<Variable>("a", "var1", 835.21);
438+
sprite->addVariable(var1);
439+
auto var2 = std::make_shared<Variable>("b", "var2", "Hello world");
440+
sprite->addVariable(var2);
441+
442+
auto monitor1 = std::make_shared<Monitor>("monitor", "data_variable");
443+
monitor1->block()->addField(std::make_shared<Field>("VARIABLE", var1->name(), var1));
444+
monitor1->setVisible(true);
445+
446+
auto monitor2 = std::make_shared<Monitor>("monitor", "data_variable");
447+
monitor2->block()->addField(std::make_shared<Field>("VARIABLE", var2->name(), var2));
448+
monitor2->setVisible(false);
449+
450+
m_engine->setMonitors({ monitor1, monitor2 });
451+
var1->setMonitor(monitor1.get());
452+
var2->setMonitor(monitor2.get());
453+
454+
m_engine->setTargets({ stage, sprite });
455+
456+
ScriptBuilder builder1(m_extension.get(), m_engine, sprite);
457+
builder1.addBlock("data_hidevariable");
458+
builder1.addEntityField("VARIABLE", var1);
459+
460+
ScriptBuilder builder2(m_extension.get(), m_engine, sprite);
461+
builder2.addBlock("data_hidevariable");
462+
builder2.addEntityField("VARIABLE", var2);
463+
464+
ScriptBuilder::buildMultiple({ &builder1, &builder2 });
465+
466+
builder1.run();
467+
ASSERT_FALSE(monitor1->visible());
468+
ASSERT_FALSE(monitor2->visible());
469+
470+
builder2.run();
471+
ASSERT_FALSE(monitor1->visible());
472+
ASSERT_FALSE(monitor2->visible());
473+
}
474+
475+
TEST_F(VariableBlocksTest, HideVariable_Local_Nonexistent)
476+
{
477+
auto stage = std::make_shared<Stage>();
478+
auto sprite = std::make_shared<Sprite>();
479+
480+
auto var1 = std::make_shared<Variable>("a", "var1", 835.21);
481+
sprite->addVariable(var1);
482+
auto var2 = std::make_shared<Variable>("b", "var2", "Hello world");
483+
sprite->addVariable(var2);
484+
485+
m_engine->setTargets({ stage, sprite });
486+
487+
ScriptBuilder builder1(m_extension.get(), m_engine, sprite);
488+
builder1.addBlock("data_hidevariable");
489+
builder1.addEntityField("VARIABLE", var1);
490+
491+
ScriptBuilder builder2(m_extension.get(), m_engine, sprite);
492+
builder2.addBlock("data_hidevariable");
493+
builder2.addEntityField("VARIABLE", var2);
494+
495+
ScriptBuilder::buildMultiple({ &builder1, &builder2 });
496+
m_engine->run();
497+
498+
// Missing monitors should NOT be created
499+
builder1.run();
500+
ASSERT_FALSE(var1->monitor());
501+
502+
builder2.run();
503+
ASSERT_FALSE(var2->monitor());
504+
}
505+
506+
TEST_F(VariableBlocksTest, HideVariable_Local_FromClone)
507+
{
508+
auto stage = std::make_shared<Stage>();
509+
auto sprite = std::make_shared<Sprite>();
510+
511+
auto var1 = std::make_shared<Variable>("a", "var1", 835.21);
512+
sprite->addVariable(var1);
513+
auto var2 = std::make_shared<Variable>("b", "var2", "Hello world");
514+
sprite->addVariable(var2);
515+
516+
auto monitor1 = std::make_shared<Monitor>("monitor", "data_variable");
517+
monitor1->block()->addField(std::make_shared<Field>("VARIABLE", var1->name(), var1));
518+
monitor1->setVisible(true);
519+
520+
auto monitor2 = std::make_shared<Monitor>("monitor", "data_variable");
521+
monitor2->block()->addField(std::make_shared<Field>("VARIABLE", var2->name(), var2));
522+
monitor2->setVisible(false);
523+
524+
m_engine->setMonitors({ monitor1, monitor2 });
525+
var1->setMonitor(monitor1.get());
526+
var2->setMonitor(monitor2.get());
527+
528+
sprite->setEngine(m_engine);
529+
auto clone = sprite->clone();
530+
531+
m_engine->setTargets({ stage, sprite, clone });
532+
533+
ScriptBuilder builder1(m_extension.get(), m_engine, clone);
534+
builder1.addBlock("data_hidevariable");
535+
builder1.addEntityField("VARIABLE", var1);
536+
Block *hat1 = builder1.currentBlock()->parent();
537+
538+
ScriptBuilder builder2(m_extension.get(), m_engine, clone);
539+
builder2.addBlock("data_hidevariable");
540+
builder2.addEntityField("VARIABLE", var2);
541+
Block *hat2 = builder2.currentBlock()->parent();
542+
543+
ScriptBuilder::buildMultiple({ &builder1, &builder2 });
544+
545+
// The clone root variables should be used
546+
builder1.run();
547+
ASSERT_FALSE(monitor1->visible());
548+
ASSERT_FALSE(monitor2->visible());
549+
550+
builder2.run();
551+
ASSERT_FALSE(monitor1->visible());
552+
ASSERT_FALSE(monitor2->visible());
553+
554+
ASSERT_FALSE(clone->variableAt(0)->monitor());
555+
ASSERT_FALSE(clone->variableAt(1)->monitor());
556+
}

0 commit comments

Comments
 (0)