int buzzvm_swarm_select(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get the id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Get the result of the condition check */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
uint8_t in = buzzvm_stack_at(vm, 1)->i.value;
/* Update the swarm, if known */
if(buzzdict_exists(vm->swarms, &id)) {
/* Store membership */
buzzdict_set(vm->swarms, &id, &in);
/* Send update */
buzzoutmsg_queue_append_swarm_joinleave(
vm->outmsgs,
in ? BUZZMSG_SWARM_JOIN : BUZZMSG_SWARM_LEAVE,
id);
/* Return */
return buzzvm_ret0(vm);
}
else {
vm->state = BUZZVM_STATE_ERROR;
vm->error = BUZZVM_ERROR_SWARM;
return BUZZVM_STATE_ERROR;
}
}
int buzzvm_vstig_setonconflictlost(struct buzzvm_s* vm) {
buzzvm_lnum_assert(vm, 1);
/* Get vstig id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Look for virtual stigmergy */
buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Virtual stigmergy found */
/* Get closure */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE);
/* Clone the closure */
if((*vs)->onconflictlost) free((*vs)->onconflictlost);
(*vs)->onconflictlost = buzzobj_clone(buzzvm_stack_at(vm, 1));
}
else {
/* No virtual stigmergy found, just push false */
/* If this happens, its a bug */
buzzvm_pushnil(vm);
fprintf(stderr, "[BUG] [ROBOT %u] Can't find virtual stigmergy %u\n", vm->robot, id);
}
/* Return the value found */
return buzzvm_ret0(vm);
}
int buzzvm_swarm_others(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get the id of the current swarm */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id1 = buzzvm_stack_at(vm, 1)->i.value;
/* Get the swarm entry */
uint8_t* x = buzzdict_get(vm->swarms, &id1, uint8_t);
if(!x) {
vm->state = BUZZVM_STATE_ERROR;
vm->error = BUZZVM_ERROR_SWARM;
return BUZZVM_STATE_ERROR;
}
/* Get the id of the new swarm to create */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
uint16_t id2 = buzzvm_stack_at(vm, 1)->i.value;
/* Add a new entry for the swarm */
uint8_t v = *x ? 0 : 1;
buzzdict_set(vm->swarms, &id2, &v);
/* Send update, if necessary */
if(v)
buzzoutmsg_queue_append_swarm_joinleave(
vm->outmsgs, BUZZMSG_SWARM_JOIN, id2);
/* Create a table to return */
make_table(vm, id2);
/* Return */
return buzzvm_ret1(vm);
}
int buzzneighbors_broadcast(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 2);
/* Get value id argument */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_STRING);
/* Get value argument */
buzzvm_lload(vm, 2);
/* Queue a message with (value_id, value) */
buzzoutmsg_queue_append_broadcast(
vm,
buzzvm_stack_at(vm, 2),
buzzvm_stack_at(vm, 1));
return buzzvm_ret0(vm);
}
static int BuzzGoTo(buzzvm_t vm) {
/* Push the vector components */
buzzvm_lload(vm, 1);
buzzvm_lload(vm, 2);
/* Create a new vector with that */
CVector2 cDir(buzzvm_stack_at(vm, 2)->f.value,
buzzvm_stack_at(vm, 1)->f.value);
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
reinterpret_cast<CBuzzControllerEFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetWheelSpeedsFromVector(cDir);
return buzzvm_ret0(vm);
}
int buzzvstig_put(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 2);
/* Get vstig id */
id_get();
/* Get key */
buzzvm_lload(vm, 1);
buzzobj_t k = buzzvm_stack_at(vm, 1);
/* Get value */
buzzvm_lload(vm, 2);
buzzobj_t v = buzzvm_stack_at(vm, 1);
/* Look for virtual stigmergy */
const buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Look for the element */
const buzzvstig_elem_t* x = buzzvstig_fetch(*vs, &k);
if(x) {
/* Element found */
if(v->o.type != BUZZTYPE_NIL) {
/* New value is not nil, update the existing element */
(*x)->data = v;
++((*x)->timestamp);
(*x)->robot = vm->robot;
/* Append a PUT message to the out message queue */
buzzoutmsg_queue_append_vstig(vm, BUZZMSG_VSTIG_PUT, id, k, *x);
}
else {
/* New value is nil, must delete the existing element */
/* Make a new element with nil as value to update neighbors */
buzzvstig_elem_t y = buzzvstig_elem_new(
buzzobj_new(BUZZTYPE_NIL), // nil value
(*x)->timestamp + 1, // new timestamp
vm->robot); // robot id
/* Append a PUT message to the out message queue with nil in it */
buzzoutmsg_queue_append_vstig(vm, BUZZMSG_VSTIG_PUT, id, k, y);
/* Delete the existing element */
buzzvstig_remove(*vs, &k);
}
}
else if(v->o.type != BUZZTYPE_NIL) {
/* Element not found and new value is not nil, store it */
buzzvstig_elem_t y = buzzvstig_elem_new(v, 1, vm->robot);
buzzvstig_store(*vs, &k, &y);
/* Append a PUT message to the out message queue */
buzzoutmsg_queue_append_vstig(vm, BUZZMSG_VSTIG_PUT, id, k, y);
}
}
/* Return */
return buzzvm_ret0(vm);
}
int buzzneighbors_listen(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 2);
/* Get value id argument */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_STRING);
/* Get listener argument */
buzzvm_lload(vm, 2);
buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE);
/* Install listener */
buzzdict_set(
vm->listeners,
&buzzvm_stack_at(vm, 2)->s.value.sid,
&buzzvm_stack_at(vm, 1));
return buzzvm_ret0(vm);
}
// proper way to send loooong 1D array
int BuzzSetMap(buzzvm_t vm){
/* Make sure one parameter has been passed */
buzzvm_lnum_assert(vm, 1);
/* Get the parameter */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE); // matrix
/* Get the table */
buzzobj_t t = buzzvm_stack_at(vm, 1);
/* Copy the values into a vector */
std::vector<float> mat;
for(int32_t i = 0; i < buzzdict_size(t->t.value); ++i) {
/* Duplicate the table */
buzzvm_dup(vm);
/* Push the index */
buzzvm_pushi(vm, i);
/* Get the value */
buzzvm_tget(vm);
/* Store it in the vector (assume all values are float, no mistake...) */
mat.push_back((float)buzzvm_stack_at(vm, 1)->f.value);
/* Get rid of the value, now useless */
buzzvm_pop(vm);
}
/* Get a pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Copy data into the controller */
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetMapParams(mat, Sqrt(buzzdict_size(t->t.value)));
/* Done with the function */
return buzzvm_ret0(vm);
}
int buzzvm_swarm_id(struct buzzvm_s* vm) {
/* Is the swarm stack empty? */
if(buzzdarray_isempty(vm->swarmstack)) {
/* Yes, no swarm to push, push nil instead */
buzzvm_pushnil(vm);
}
else {
/* Take the stack top by default */
uint16_t stackpos = 1;
/* Do we have an argument? */
if(buzzvm_lnum(vm) > 1) {
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
stackpos = buzzvm_stack_at(vm, 1)->i.value;
}
/* Limit stackpos value to avoid out-of-bounds operations */
if(stackpos > buzzdarray_size(vm->swarmstack))
stackpos = buzzdarray_size(vm->swarmstack);
/* Push the swarm id located at stackpos */
buzzvm_pushi(vm,
buzzdarray_get(
vm->swarmstack,
buzzdarray_size(vm->swarmstack) - stackpos,
uint16_t));
}
/* Return the value */
return buzzvm_ret1(vm);
}
int buzzvstig_create(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get vstig id */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
buzzvm_pop(vm);
/* Look for virtual stigmergy */
const buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Found, destroy it */
buzzdict_remove(vm->vstigs, &id);
}
/* Create a new virtual stigmergy */
buzzvstig_t nvs = buzzvstig_new();
buzzdict_set(vm->vstigs, &id, &nvs);
/* Create a table */
buzzvm_pusht(vm);
/* Add data and methods */
buzzvm_dup(vm);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id", 1));
buzzvm_pushi(vm, id);
buzzvm_tput(vm);
function_register(foreach);
function_register(size);
function_register(put);
function_register(get);
function_register(onconflict);
function_register(onconflictlost);
/* Return the table */
return buzzvm_ret1(vm);
}
int BuzzSetWheelsFb(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 2);
/* Push speeds */
buzzvm_lload(vm, 1); /* Left speed */
buzzvm_lload(vm, 2); /* Right speed */
buzzvm_type_assert(vm, 2, BUZZTYPE_FLOAT);
buzzvm_type_assert(vm, 1, BUZZTYPE_FLOAT);
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
reinterpret_cast<CBuzzControllerEFootBot*>(
buzzvm_stack_at(vm, 1)->u.value)->
SetWheels(buzzvm_stack_at(vm, 3)->f.value, /* Left speed */
buzzvm_stack_at(vm, 2)->f.value /* Right speed */
);
return buzzvm_ret0(vm);
}
int BuzzSetLEDsFb(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 3);
/* Push the color components */
buzzvm_lload(vm, 1);
buzzvm_lload(vm, 2);
buzzvm_lload(vm, 3);
buzzvm_type_assert(vm, 3, BUZZTYPE_INT);
buzzvm_type_assert(vm, 2, BUZZTYPE_INT);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
/* Create a new color with that */
CColor cColor(buzzvm_stack_at(vm, 3)->i.value,
buzzvm_stack_at(vm, 2)->i.value,
buzzvm_stack_at(vm, 1)->i.value);
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
reinterpret_cast<CBuzzControllerEFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetLEDs(cColor);
return buzzvm_ret0(vm);
}
int buzzneighbors_ignore(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get value id argument */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_STRING);
/* Remove listener */
buzzdict_remove(
vm->listeners,
&(buzzvm_stack_at(vm, 1)->s.value.sid));
return buzzvm_ret0(vm);
}
int buzzvm_vstig_get(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get vstig id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Get key */
buzzvm_lload(vm, 1);
buzzobj_t k = buzzvm_stack_at(vm, 1);
/* Look for virtual stigmergy */
buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Virtual stigmergy found */
/* Look for key and push result */
buzzvstig_elem_t* e = buzzvstig_fetch(*vs, &k);
if(e) {
/* Key found */
buzzvm_push(vm, (*e)->data);
/* Append the message to the out message queue */
buzzoutmsg_queue_append_vstig(vm->outmsgs, BUZZMSG_VSTIG_QUERY, id, k, *e);
}
else {
/* Key not found, add a new one containing nil */
buzzvm_pushnil(vm);
buzzvstig_elem_t x =
buzzvstig_elem_new(buzzvm_stack_at(vm, 1),
1, vm->robot);
/* Append the message to the out message queue */
buzzoutmsg_queue_append_vstig(vm->outmsgs, BUZZMSG_VSTIG_QUERY, id, k, x);
}
}
else {
/* No virtual stigmergy found, just push false */
/* If this happens, its a bug */
buzzvm_pushnil(vm);
fprintf(stderr, "[BUG] [ROBOT %u] Can't find virtual stigmergy %u\n", vm->robot, id);
}
/* Return the value found */
return buzzvm_ret1(vm);
}
static int BuzzRotate(buzzvm_t vm) {
/* Push the yaw angle */
buzzvm_lload(vm, 1);
/* Create a new angle with that */
CRadians cYaw(buzzvm_stack_at(vm, 1)->f.value);
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
reinterpret_cast<CBuzzControllerSpiri*>(buzzvm_stack_at(vm, 1)->u.value)->SetYaw(cYaw);
return buzzvm_ret0(vm);
}
int buzzvm_swarm_exec(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get the id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Get the swarm entry */
uint8_t* x = buzzdict_get(vm->swarms, &id, uint8_t);
if(!x) {
vm->state = BUZZVM_STATE_ERROR;
vm->error = BUZZVM_ERROR_SWARM;
return BUZZVM_STATE_ERROR;
}
/* Check whether the robot is in the swarm */
if(*x) {
/* Get the closure */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE);
buzzobj_t c = buzzvm_stack_at(vm, 1);
/* Get rid of the current call structure */
if(buzzvm_ret0(vm) != BUZZVM_STATE_READY) return vm->state;
/* Save the current stack depth */
uint32_t stacks = buzzdarray_size(vm->stacks);
/* Push the current swarm in the stack */
buzzdarray_push(vm->swarmstack, &id);
/* Call the closure */
buzzvm_push(vm, c);
int32_t numargs = 0;
buzzvm_pushi(vm, numargs);
buzzvm_calls(vm);
do if(buzzvm_step(vm) != BUZZVM_STATE_READY) return vm->state;
while(stacks < buzzdarray_size(vm->stacks));
return vm->state;
}
else {
/* Get rid of the current call structure */
return buzzvm_ret0(vm);
}
}
int BuzzSetArgosMap(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_STRING);
std::string text = buzzvm_stack_at(vm, 1)->s.value.str;
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
//printf("Value: %s", buzzvm_stack_at(vm, 1)->s.value.str);
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetArgosMap(text);
return buzzvm_ret0(vm);
}
int BuzzShowCoordinateSystem(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 5);
buzzvm_lload(vm, 1);
buzzvm_lload(vm, 2);
buzzvm_lload(vm, 3);
buzzvm_lload(vm, 4);
buzzvm_lload(vm, 5);
buzzvm_type_assert(vm, 5, BUZZTYPE_INT);
buzzvm_type_assert(vm, 4, BUZZTYPE_INT);
buzzvm_type_assert(vm, 3, BUZZTYPE_INT);
buzzvm_type_assert(vm, 2, BUZZTYPE_INT);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetArgosCoordinateIDs(
buzzvm_stack_at(vm, 6)->i.value,
buzzvm_stack_at(vm, 5)->i.value,
buzzvm_stack_at(vm, 4)->i.value,
buzzvm_stack_at(vm, 3)->i.value,
buzzvm_stack_at(vm, 2)->i.value);
return buzzvm_ret0(vm);
}
int BuzzRemoveCS(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
int id = buzzvm_stack_at(vm, 1)->i.value;
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->RemoveCS(id);
return buzzvm_ret0(vm);
}
static int BuzzGoToP(buzzvm_t vm) {
/* Push the vector components */
buzzvm_lload(vm, 1);
buzzvm_lload(vm, 2);
/* Create a new vector with that */
buzzobj_t tLinSpeed = buzzvm_stack_at(vm, 2);
buzzobj_t tAngSpeed = buzzvm_stack_at(vm, 1);
Real fLinSpeed = 0.0, fAngSpeed = 0.0;
if(tLinSpeed->o.type == BUZZTYPE_INT) fLinSpeed = tLinSpeed->i.value;
else if(tLinSpeed->o.type == BUZZTYPE_FLOAT) fLinSpeed = tLinSpeed->f.value;
else {
buzzvm_seterror(vm,
BUZZVM_ERROR_TYPE,
"gotop(linspeed,angspeed): expected %s, got %s in first argument",
buzztype_desc[BUZZTYPE_FLOAT],
buzztype_desc[tLinSpeed->o.type]
);
return vm->state;
}
if(tAngSpeed->o.type == BUZZTYPE_INT) fAngSpeed = tAngSpeed->i.value;
else if(tAngSpeed->o.type == BUZZTYPE_FLOAT) fAngSpeed = tAngSpeed->f.value;
else {
buzzvm_seterror(vm,
BUZZVM_ERROR_TYPE,
"gotop(linspeed,angspeed): expected %s, got %s in second argument",
buzztype_desc[BUZZTYPE_FLOAT],
buzztype_desc[tAngSpeed->o.type]
);
return vm->state;
}
CVector2 cDir(fLinSpeed, CRadians(fAngSpeed));
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetWheelSpeedsFromVector(cDir);
return buzzvm_ret0(vm);
}
int buzzvm_vstig_put(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 2);
/* Get vstig id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Get key */
buzzvm_lload(vm, 1);
buzzobj_t k = buzzvm_stack_at(vm, 1);
/* Get value */
buzzvm_lload(vm, 2);
buzzobj_t v = buzzvm_stack_at(vm, 1);
/* Look for virtual stigmergy */
buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Look for the element */
buzzvstig_elem_t* x = buzzvstig_fetch(*vs, &k);
if(x) {
/* Element found, update it */
(*x)->data = v;
++((*x)->timestamp);
(*x)->robot = vm->robot;
/* Append a PUT message to the out message queue */
buzzoutmsg_queue_append_vstig(vm->outmsgs, BUZZMSG_VSTIG_PUT, id, k, *x);
}
else {
/* Element not found, create a new one */
buzzvstig_elem_t y = buzzvstig_elem_new(v, 1, vm->robot);
buzzvstig_store(*vs, &k, &y);
/* Append a PUT message to the out message queue */
buzzoutmsg_queue_append_vstig(vm->outmsgs, BUZZMSG_VSTIG_PUT, id, k, y);
}
}
/* Return */
return buzzvm_ret0(vm);
}
static int BuzzGoToC(buzzvm_t vm) {
/* Push the vector components */
buzzvm_lload(vm, 1);
buzzvm_lload(vm, 2);
/* Create a new vector with that */
buzzobj_t tX = buzzvm_stack_at(vm, 2);
buzzobj_t tY = buzzvm_stack_at(vm, 1);
CVector2 cDir;
if(tX->o.type == BUZZTYPE_INT) cDir.SetX(tX->i.value);
else if(tX->o.type == BUZZTYPE_FLOAT) cDir.SetX(tX->f.value);
else {
buzzvm_seterror(vm,
BUZZVM_ERROR_TYPE,
"gotoc(x,y): expected %s, got %s in first argument",
buzztype_desc[BUZZTYPE_FLOAT],
buzztype_desc[tX->o.type]
);
return vm->state;
}
if(tY->o.type == BUZZTYPE_INT) cDir.SetY(tY->i.value);
else if(tY->o.type == BUZZTYPE_FLOAT) cDir.SetY(tY->f.value);
else {
buzzvm_seterror(vm,
BUZZVM_ERROR_TYPE,
"gotoc(x,y): expected %s, got %s in second argument",
buzztype_desc[BUZZTYPE_FLOAT],
buzztype_desc[tY->o.type]
);
return vm->state;
}
/* Get pointer to the controller */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
/* Call function */
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetWheelSpeedsFromVector(cDir);
return buzzvm_ret0(vm);
}
int BuzzShowBorderRobots(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE);
buzzobj_t t = buzzvm_stack_at(vm, 1);
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
std::vector<float> v;
buzzdict_foreach(t->t.value, di_read_elem, &v);
reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->m_border_robot_ids = v;
return buzzvm_ret0(vm);
}
int buzzvm_swarm_create(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get the id */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Add a new entry if necessary */
if(!buzzdict_exists(vm->swarms, &id)) {
uint8_t v = 0;
buzzdict_set(vm->swarms, &id, &v);
}
/* Create a table to return */
make_table(vm, id);
/* Return */
return buzzvm_ret1(vm);
}
int buzzvm_vstig_create(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get vstig id */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_INT);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
buzzvm_pop(vm);
/* Look for virtual stigmergy */
buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs)
/* Found, destroy it */
buzzdict_remove(vm->vstigs, &id);
/* Create a new virtual stigmergy */
buzzvstig_t nvs = buzzvstig_new();
buzzdict_set(vm->vstigs, &id, &nvs);
/* Create a table and add data and methods */
buzzobj_t t = buzzheap_newobj(vm->heap, BUZZTYPE_TABLE);
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "size"));
buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_size));
buzzvm_tput(vm);
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "put"));
buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_put));
buzzvm_tput(vm);
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "get"));
buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_get));
buzzvm_tput(vm);
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "onconflict"));
buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_setonconflict));
buzzvm_tput(vm);
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "onconflictlost"));
buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_setonconflictlost));
buzzvm_tput(vm);
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_pushi(vm, id);
buzzvm_tput(vm);
/* Push the table on the stack */
buzzvm_push(vm, t);
/* Return */
return buzzvm_ret1(vm);
}
int buzzneighbors_kin(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 0);
/* Initialize the swarm id to 'unknown' */
int32_t swarmid = -1;
/* If the swarm stack is not empty, look for the swarm id */
if(!buzzdarray_isempty(vm->swarmstack)) {
/* Get position in swarm stack */
uint16_t sstackpos = 1;
if(buzzdarray_size(vm->lsyms->syms) > 1)
sstackpos = buzzdarray_get(vm->lsyms->syms, 1, buzzobj_t)->i.value;
/* Get swarm id */
if(sstackpos <= buzzdarray_size(vm->swarmstack))
swarmid = buzzdarray_get(vm->swarmstack,
buzzdarray_size(vm->swarmstack) - sstackpos,
uint16_t);
}
/* Get the self table */
buzzvm_lload(vm, 0);
buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE);
/* Get the data table */
buzzvm_pushs(vm, buzzvm_string_register(vm, "data", 1));
buzzvm_tget(vm);
buzzobj_t data = buzzvm_stack_at(vm, 1);
/* Create a new table as return value */
buzzobj_t t;
vm->state = make_table(vm, &t);
if(vm->state != BUZZVM_STATE_READY) return vm->state;
/* If data is available, filter it */
if(data->o.type == BUZZTYPE_TABLE) {
/* Create a new data table */
buzzobj_t kindata = buzzheap_newobj(vm->heap, BUZZTYPE_TABLE);
/* Filter the neighbors in data and add them to kindata */
struct neighbor_filter_s fdata = { .vm = vm, .swarm_id = swarmid, .result = kindata->t.value };
buzzdict_foreach(data->t.value, neighbor_filter_kin, &fdata);
/* Add kindata as the "data" field in t */
buzzvm_push(vm, t);
buzzvm_pushs(vm, buzzvm_string_register(vm, "data", 1));
buzzvm_push(vm, kindata);
buzzvm_tput(vm);
}
/* Return the table */
buzzvm_push(vm, t);
return buzzvm_ret1(vm);
}
int BuzzDebugPrint(buzzvm_t vm) {
/* Get pointer to controller user data */
buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1));
buzzvm_gload(vm);
buzzvm_type_assert(vm, 1, BUZZTYPE_USERDATA);
CBuzzController& cContr = *reinterpret_cast<CBuzzController*>(buzzvm_stack_at(vm, 1)->u.value);
/* Fill message */
std::ostringstream oss;
for(UInt32 i = 1; i < buzzdarray_size(vm->lsyms->syms); ++i) {
buzzvm_lload(vm, i);
buzzobj_t o = buzzvm_stack_at(vm, 1);
buzzvm_pop(vm);
switch(o->o.type) {
case BUZZTYPE_NIL:
oss << "[nil]";
break;
case BUZZTYPE_INT:
oss << o->i.value;
break;
case BUZZTYPE_FLOAT:
oss << o->f.value;
break;
case BUZZTYPE_TABLE:
oss << "[table with " << (buzzdict_size(o->t.value)) << " elems]";
break;
case BUZZTYPE_CLOSURE:
if(o->c.value.isnative)
oss << "[n-closure @" << o->c.value.ref << "]";
else
oss << "[c-closure @" << o->c.value.ref << "]";
break;
case BUZZTYPE_STRING:
oss << o->s.value.str;
break;
case BUZZTYPE_USERDATA:
oss << "[userdata @" << o->u.value << "]";
break;
default:
break;
}
}
cContr.GetARGoSDebugInfo().Msg = oss.str();
return buzzvm_ret0(vm);
}
int buzzvm_swarm_in(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 0);
/* Get the id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Get the swarm entry */
uint8_t* x = buzzdict_get(vm->swarms, &id, uint8_t);
if(!x) {
vm->state = BUZZVM_STATE_ERROR;
vm->error = BUZZVM_ERROR_SWARM;
return BUZZVM_STATE_ERROR;
}
/* Push the return value */
buzzvm_pushi(vm, *x);
/* Return */
return buzzvm_ret1(vm);
}
int buzzvstig_foreach(struct buzzvm_s* vm) {
/* Make sure you got one argument */
buzzvm_lnum_assert(vm, 1);
/* Get vstig id */
id_get();
/* Look for virtual stigmergy */
const buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Virtual stigmergy found */
/* Get closure */
buzzvm_lload(vm, 1);
buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE);
buzzobj_t c = buzzvm_stack_at(vm, 1);
/* Go through the elements and apply the closure */
struct buzzvstig_foreach_params p = { .vm = vm, .fun = c };
buzzdict_foreach((*vs)->data, buzzvstig_foreach_entry, &p);
}
/* Return */
return buzzvm_ret0(vm);
}
int buzzvm_vstig_size(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 0);
/* Get vstig id */
buzzvm_lload(vm, 0);
buzzvm_pushs(vm, buzzvm_string_register(vm, "id"));
buzzvm_tget(vm);
uint16_t id = buzzvm_stack_at(vm, 1)->i.value;
/* Look for virtual stigmergy */
buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Virtual stigmergy found, return its size */
buzzvm_pushi(vm, buzzdict_size((*vs)->data));
}
else {
/* Virtual stigmergy not found, return 0 */
buzzvm_pushi(vm, 0);
}
/* Return */
return buzzvm_ret1(vm);
}