Skip to content

Add support for reading variables using the sensing_of block #377

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Dec 17, 2023
Merged

Add support for reading variables using the sensing_of block #377

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
41 changes: 38 additions & 3 deletions src/blocks/sensingblocks.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@
#include <scratchcpp/sprite.h>
#include <scratchcpp/stage.h>
#include <scratchcpp/costume.h>
#include <scratchcpp/variable.h>
#include "sensingblocks.h"

#include "../engine/internal/clock.h"
Expand Down Expand Up @@ -141,15 +142,20 @@ void SensingBlocks::compileResetTimer(Compiler *compiler)

void SensingBlocks::compileOf(Compiler *compiler)
{
int option = compiler->field(PROPERTY)->specialValueId();
Field *property = compiler->field(PROPERTY);
assert(property);
int option = property->specialValueId();
Input *input = compiler->input(OBJECT);
assert(input);
BlockFunc f = nullptr;

if (input->type() != Input::Type::ObscuredShadow) {
assert(input->pointsToDropdownMenu());
std::string value = input->selectedMenuItem();

int index = compiler->engine()->findTarget(value);
IEngine *engine = compiler->engine();
assert(engine);
int index = engine->findTarget(value);

switch (option) {
case XPosition:
Expand Down Expand Up @@ -188,8 +194,18 @@ void SensingBlocks::compileOf(Compiler *compiler)
f = &backdropNameOfStageByIndex;
break;

default:
default: {
// Variable
Target *target = engine->targetAt(index);
auto varIndex = target->findVariable(property->value().toString());

if (varIndex == -1)
compiler->addInstruction(vm::OP_NULL);
else
compiler->addInstruction(vm::OP_READ_VAR, { compiler->variableIndex(target->variableAt(varIndex)) });

break;
}
}

if (f)
Expand Down Expand Up @@ -233,6 +249,8 @@ void SensingBlocks::compileOf(Compiler *compiler)
break;

default:
f = &variableOfTarget;
compiler->addConstValue(property->value().toString());
break;
}

Expand Down Expand Up @@ -571,6 +589,23 @@ unsigned int SensingBlocks::volumeOfTargetByIndex(VirtualMachine *vm)
return 0;
}

unsigned int SensingBlocks::variableOfTarget(VirtualMachine *vm)
{
Target *target = vm->engine()->targetAt(vm->engine()->findTarget(vm->getInput(1, 2)->toString()));

if (target) {
auto varIndex = target->findVariable(vm->getInput(0, 2)->toString());

if (varIndex == -1)
vm->replaceReturnValue(0, 2);
else
vm->replaceReturnValue(target->variableAt(varIndex)->value(), 2);
} else
vm->replaceReturnValue(0, 2);

return 1;
}

unsigned int SensingBlocks::backdropNumberOfStage(VirtualMachine *vm)
{
Target *target = vm->engine()->targetAt(vm->engine()->findTarget(vm->getInput(0, 1)->toString()));
Expand Down
1 change: 1 addition & 0 deletions src/blocks/sensingblocks.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -93,6 +93,7 @@ class SensingBlocks : public IBlockSection
static unsigned int sizeOfSpriteByIndex(VirtualMachine *vm);
static unsigned int volumeOfTarget(VirtualMachine *vm);
static unsigned int volumeOfTargetByIndex(VirtualMachine *vm);
static unsigned int variableOfTarget(VirtualMachine *vm);
static unsigned int backdropNumberOfStage(VirtualMachine *vm);
static unsigned int backdropNumberOfStageByIndex(VirtualMachine *vm);
static unsigned int backdropNameOfStage(VirtualMachine *vm);
Expand Down
141 changes: 138 additions & 3 deletions test/blocks/sensing_blocks_test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@
#include <scratchcpp/sprite.h>
#include <scratchcpp/stage.h>
#include <scratchcpp/costume.h>
#include <scratchcpp/variable.h>
#include <enginemock.h>
#include <timermock.h>
#include <clockmock.h>
Expand Down Expand Up @@ -706,10 +707,35 @@ TEST_F(SensingBlocksTest, Of)
addDropdownField(block20, "PROPERTY", SensingBlocks::PROPERTY, "backdrop name", SensingBlocks::BackdropName);
addDropdownInput(block20, "OBJECT", SensingBlocks::OBJECT, "", createNullBlock("ad"));

// [some variable] of (Stage)
auto block21 = std::make_shared<Block>("ae", "sensing_of");
addDropdownField(block21, "PROPERTY", SensingBlocks::PROPERTY, "some variable", static_cast<SensingBlocks::FieldValues>(-1));
addDropdownInput(block21, "OBJECT", SensingBlocks::OBJECT, "_stage_");

// [some invalid variable] of (Stage)
auto block22 = std::make_shared<Block>("af", "sensing_of");
addDropdownField(block22, "PROPERTY", SensingBlocks::PROPERTY, "some invalid variable", static_cast<SensingBlocks::FieldValues>(-1));
addDropdownInput(block22, "OBJECT", SensingBlocks::OBJECT, "_stage_");

// [some variable] of (Sprite2)
auto block23 = std::make_shared<Block>("ag", "sensing_of");
addDropdownField(block23, "PROPERTY", SensingBlocks::PROPERTY, "some variable", static_cast<SensingBlocks::FieldValues>(-1));
addDropdownInput(block23, "OBJECT", SensingBlocks::OBJECT, "Sprite2");

// [some invalid variable] of (Sprite2)
auto block24 = std::make_shared<Block>("ah", "sensing_of");
addDropdownField(block24, "PROPERTY", SensingBlocks::PROPERTY, "some invalid variable", static_cast<SensingBlocks::FieldValues>(-1));
addDropdownInput(block24, "OBJECT", SensingBlocks::OBJECT, "Sprite2");

// [some variable] of (null block)
auto block25 = std::make_shared<Block>("ai", "sensing_of");
addDropdownField(block25, "PROPERTY", SensingBlocks::PROPERTY, "some variable", static_cast<SensingBlocks::FieldValues>(-1));
addDropdownInput(block25, "OBJECT", SensingBlocks::OBJECT, "", createNullBlock("aj"));

compiler.init();

EXPECT_CALL(m_engineMock, findTarget("Sprite2")).Times(7).WillRepeatedly(Return(6));
EXPECT_CALL(m_engineMock, findTarget("_stage_")).Times(3).WillRepeatedly(Return(0));
EXPECT_CALL(m_engineMock, findTarget("Sprite2")).Times(9).WillRepeatedly(Return(6));
EXPECT_CALL(m_engineMock, findTarget("_stage_")).Times(5).WillRepeatedly(Return(0));

EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::xPositionOfSpriteByIndex)).WillOnce(Return(0));
compiler.setBlock(block1);
Expand Down Expand Up @@ -791,6 +817,34 @@ TEST_F(SensingBlocksTest, Of)
compiler.setBlock(block20);
SensingBlocks::compileOf(&compiler);

Stage stage;
auto v1 = std::make_shared<Variable>("var1", "test");
auto v2 = std::make_shared<Variable>("var2", "some variable");
stage.addVariable(v1);
stage.addVariable(v2);
EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
compiler.setBlock(block21);
SensingBlocks::compileOf(&compiler);

EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
compiler.setBlock(block22);
SensingBlocks::compileOf(&compiler);

Sprite sprite;
auto v3 = std::make_shared<Variable>("var3", "some variable");
sprite.addVariable(v3);
EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
compiler.setBlock(block23);
SensingBlocks::compileOf(&compiler);

EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
compiler.setBlock(block24);
SensingBlocks::compileOf(&compiler);

EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTarget)).WillOnce(Return(18));
compiler.setBlock(block25);
SensingBlocks::compileOf(&compiler);

compiler.end();

ASSERT_EQ(
Expand Down Expand Up @@ -867,8 +921,20 @@ TEST_F(SensingBlocksTest, Of)
vm::OP_NULL,
vm::OP_EXEC,
17,
vm::OP_READ_VAR,
0,
vm::OP_NULL,
vm::OP_READ_VAR,
1,
vm::OP_NULL,
vm::OP_CONST,
10,
vm::OP_NULL,
vm::OP_EXEC,
18,
vm::OP_HALT }));
ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0 }));
ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, "some variable" }));
ASSERT_EQ(compiler.variables(), std::vector<Variable *>({ v2.get(), v3.get() }));
}

TEST_F(SensingBlocksTest, XPositionOfSprite)
Expand Down Expand Up @@ -1114,6 +1180,75 @@ TEST_F(SensingBlocksTest, VolumeOfTarget)
ASSERT_EQ(vm.getInput(0, 1)->toDouble(), stage.volume());
}

TEST_F(SensingBlocksTest, VariableOfTarget)
{
static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_HALT };
static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_HALT };
static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
static unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_HALT };
static BlockFunc functions[] = { &SensingBlocks::variableOfTarget };
static Value constValues[] = { "variable", "invalid variable", "Sprite2", "_stage_", "test" };

Sprite sprite;
auto v1 = std::make_shared<Variable>("var1", "variable", 64.13);
sprite.addVariable(v1);

Stage stage;
auto v2 = std::make_shared<Variable>("var2", "test", 98);
auto v3 = std::make_shared<Variable>("var3", "variable", -0.85);
stage.addVariable(v2);
stage.addVariable(v3);

VirtualMachine vm(nullptr, &m_engineMock, nullptr);
vm.setFunctions(functions);
vm.setConstValues(constValues);

EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(6));
EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
vm.setBytecode(bytecode1);
vm.run();

ASSERT_EQ(vm.registerCount(), 1);
ASSERT_EQ(vm.getInput(0, 1)->toDouble(), v1->value().toDouble());

EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(6));
EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
vm.reset();
vm.setBytecode(bytecode2);
vm.run();

ASSERT_EQ(vm.registerCount(), 1);
ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 0);

EXPECT_CALL(m_engineMock, findTarget("_stage_")).WillOnce(Return(0));
EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
vm.reset();
vm.setBytecode(bytecode3);
vm.run();

ASSERT_EQ(vm.registerCount(), 1);
ASSERT_EQ(vm.getInput(0, 1)->toDouble(), v3->value().toDouble());

EXPECT_CALL(m_engineMock, findTarget("_stage_")).WillOnce(Return(0));
EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
vm.reset();
vm.setBytecode(bytecode4);
vm.run();

ASSERT_EQ(vm.registerCount(), 1);
ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 0);

EXPECT_CALL(m_engineMock, findTarget("test")).WillOnce(Return(-1));
EXPECT_CALL(m_engineMock, targetAt(-1)).WillOnce(Return(nullptr));
vm.reset();
vm.setBytecode(bytecode5);
vm.run();

ASSERT_EQ(vm.registerCount(), 1);
ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 0);
}

TEST_F(SensingBlocksTest, BackdropNumberOfStage)
{
static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
Expand Down