void ConnectedAdapter::actuate(Eris::Entity* entity, const std::string& action)
{
try {
Atlas::Objects::Entity::Anonymous what;
what->setId(entity->getId());
// what->setObjtype("obj");
Atlas::Objects::Operation::RootOperation actionOp;
actionOp->setObjtype("op");
actionOp->setArgs1(what);
std::list<std::string> actionParents;
actionParents.push_back(action);
actionOp->setParents(actionParents);
Atlas::Objects::Operation::RootOperation actuateOp;
actuateOp->setObjtype("op");
actuateOp->setArgs1(actionOp);
std::list<std::string> actuateParents;
actuateParents.push_back("actuate");
actuateOp->setParents(actuateParents);
actuateOp->setFrom(mAvatar.getEntity()->getId());
S_LOG_INFO("Actuating entity with id " << entity->getId() << ", named " << entity->getName() << " with action '" << action << "'.");
mConnection.send(actuateOp);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on actuating." << ex);
}
}
void EntityEditor::removeGoal(const std::string& id)
{
Eris::Account* account = EmberServices::getSingleton().getServerService().getAccount();
Atlas::Message::MapType goalElement;
goalElement["id"] = id;
//By not defining anything else than the id we're telling the server to remove it.
Atlas::Objects::Entity::Anonymous thought;
thought->setAttr("goal", goalElement);
Atlas::Objects::Operation::RootOperation thinkOp;
thinkOp->setArgs1(thought);
std::list<std::string> parents;
parents.emplace_back("think");
thinkOp->setParents(parents);
thinkOp->setTo(mEntity.getId());
//By setting it TO an entity and FROM our avatar we'll make the server deliver it as
//if it came from the entity itself (the server rewrites the FROM to be of the entity).
thinkOp->setFrom(mWorld.getAvatar()->getEmberEntity().getId());
Eris::Connection* connection = account->getConnection();
connection->send(thinkOp);
}
int main()
{
ClientConnection * cc = new ClientConnection();
delete cc;
// Try all the method calls when not connected
cc = new ClientConnection();
cc->login("username", "password");
cc->create("player", "username", "password");
cc->wait();
{
Atlas::Objects::Operation::RootOperation op;
cc->send(op);
}
cc->pop();
cc->pending();
delete cc;
TestClientConnection * tcc = new TestClientConnection();
{
Atlas::Objects::Root obj;
Atlas::Objects::Operation::RootOperation op;
tcc->test_operation(op);
tcc->test_errorArrived(op);
tcc->test_infoArrived(op);
tcc->test_objectArrived(op);
Anonymous op_arg;
op->setArgs1(op_arg);
tcc->test_infoArrived(op);
op->setFrom("1");
tcc->test_infoArrived(op);
op->setParents(std::list<std::string>());
tcc->test_operation(op);
tcc->test_objectArrived(op);
Info i;
tcc->test_objectArrived(i);
Error e;
tcc->test_objectArrived(e);
tcc->test_objectArrived(obj);
obj->setParents(std::list<std::string>());
tcc->test_objectArrived(obj);
}
return 0;
}
void EntityEditor::addKnowledge(const std::string& predicate, const std::string& subject, const std::string& knowledge)
{
Eris::Account* account = EmberServices::getSingleton().getServerService().getAccount();
Atlas::Objects::Entity::Anonymous thought;
thought->setAttr("predicate", predicate);
thought->setAttr("subject", subject);
thought->setAttr("object", knowledge);
Atlas::Objects::Operation::RootOperation thinkOp;
thinkOp->setArgs1(thought);
std::list<std::string> parents;
parents.emplace_back("think");
thinkOp->setParents(parents);
thinkOp->setTo(mEntity.getId());
//By setting it TO an entity and FROM our avatar we'll make the server deliver it as
//if it came from the entity itself (the server rewrites the FROM to be of the entity).
thinkOp->setFrom(mWorld.getAvatar()->getEmberEntity().getId());
Eris::Connection* connection = account->getConnection();
connection->send(thinkOp);
}
void EntityImporterBase::sendMinds()
{
if (!mResolvedMindMapping.empty()) {
S_LOG_INFO("Sending minds.");
for (auto mind : mResolvedMindMapping) {
Atlas::Message::MapType message;
mind.second->addToMessage(message);
Atlas::Message::Element thoughtsElem = message["thoughts"];
Atlas::Message::ListType thoughtArgs;
if (thoughtsElem.isList()) {
Atlas::Message::ListType thoughtList = thoughtsElem.List();
for (auto& thought : thoughtList) {
//If the thought is a list of things the entity owns, we should adjust it with the new entity ids.
if (thought.isMap()) {
auto& thoughtMap = thought.Map();
if (thoughtMap.count("things") > 0) {
auto& thingsElement = thoughtMap.find("things")->second;
if (thingsElement.isMap()) {
for (auto& thingI : thingsElement.asMap()) {
if (thingI.second.isList()) {
Atlas::Message::ListType newList;
for (auto& thingId : thingI.second.asList()) {
if (thingId.isString()) {
const auto& entityIdLookupI = mEntityIdMap.find(thingId.asString());
//Check if the owned entity has been created with a new id. If so, replace the data.
if (entityIdLookupI != mEntityIdMap.end()) {
newList.push_back(entityIdLookupI->second);
} else {
newList.push_back(thingId);
}
} else {
newList.push_back(thingId);
}
}
thingI.second = newList;
}
}
}
}
if (thoughtMap.count("pending_things") > 0) {
//things that the entity owns, but haven't yet discovered are expressed as a list of entity ids
auto& pendingThingsElement = thoughtMap.find("pending_things")->second;
if (pendingThingsElement.isList()) {
Atlas::Message::ListType newList;
for (auto& thingId : pendingThingsElement.asList()) {
if (thingId.isString()) {
const auto& entityIdLookupI = mEntityIdMap.find(thingId.asString());
//Check if the owned entity has been created with a new id. If so, replace the data.
if (entityIdLookupI != mEntityIdMap.end()) {
newList.push_back(entityIdLookupI->second);
} else {
newList.push_back(thingId);
}
} else {
newList.push_back(thingId);
}
}
pendingThingsElement = newList;
}
}
if (thoughtMap.count("object") > 0) {
auto& objectElement = thoughtMap.find("object")->second;
if (objectElement.isString()) {
std::string& objectString = objectElement.String();
//Other entities are referred to using the syntax "'$eid:...'".
//For example, the entity with id 2 would be "'$eid:2'".
auto pos = objectString.find("$eid:");
if (pos != std::string::npos) {
auto quotePos = objectString.find('\'', pos);
if (quotePos != std::string::npos) {
auto id = objectString.substr(pos + 5, quotePos - pos - 5);
auto I = mEntityIdMap.find(id);
if (I != mEntityIdMap.end()) {
objectString.replace(pos + 5, quotePos - 7, I->second);
}
}
}
}
}
}
thoughtArgs.push_back(thought);
}
}
Atlas::Objects::Operation::RootOperation thinkOp;
std::list<std::string> parents;
parents.emplace_back("think");
thinkOp->setParents(parents);
thinkOp->setTo(mind.first);
//By setting it TO an entity and FROM our avatar we'll make the server deliver it as
//if it came from the entity itself (the server rewrites the FROM to be of the entity).
thinkOp->setFrom(mAvatarId);
thinkOp->setSerialno(newSerialNumber());
Atlas::Objects::Operation::Set setOp;
setOp->setArgsAsList(thoughtArgs);
thinkOp->setArgs1(setOp);
mStats.mindsProcessedCount++;
S_LOG_VERBOSE("Restoring mind of " << mind.first);
mThoughtOpsInTransit++;
sigc::slot<void, const Operation&> slot = sigc::mem_fun(*this, &EntityImporterBase::operationThinkResult);
sendAndAwaitResponse(thinkOp, slot);
EventProgress.emit();
}
mResolvedMindMapping.clear();
} else {
complete();
}
}