void EntityEditor::operationGetGoalInfoResult(const Atlas::Objects::Operation::RootOperation& op)
{
//What we receive here has been relayed from the mind of the entity. That means that this op
//is potentially unsafe, as it could be of any type (Set, Logout etc.), all depending on what the
//mind client decided to send (i.e. someone might want to try to hack). We should therefore treat it
//very carefully.
if (op->getClassNo() == Atlas::Objects::Operation::ROOT_OPERATION_NO) {
//An empty root operation signals a timeout; we never got any answer from the entity.
return;
}
//Since we'll just be iterating over the args we only need to do an extra check that what we got is a
//"info" operation.
if (op->getClassNo() != Atlas::Objects::Operation::INFO_NO) {
S_LOG_WARNING("Got goal info operation with wrong type.");
return;
}
if (!op->getArgs().empty()) {
auto goalInfos = op->getArgsAsList();
for (auto goalInfo : goalInfos) {
EventGotGoalInfo(goalInfo);
}
} else {
S_LOG_VERBOSE("Got goal info op without any goals.");
}
}
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 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 Lobbytest::test_operation_account()
{
Account * tac = new TestAccount();
m_lobby->addAccount(tac);
Atlas::Objects::Operation::RootOperation op;
OpVector res;
op->setTo("2");
m_lobby->operation(op, res);
}
void Lobbytest::test_operation_connected_other()
{
Account * tac = new TestAccount();
tac->m_connection = new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"foo", "3", 3);
m_lobby->addAccount(tac);
Atlas::Objects::Operation::RootOperation op;
OpVector res;
op->setTo("2");
m_lobby->operation(op, res);
}
void LocatedEntity::broadcast(const Atlas::Objects::Operation::RootOperation& op, OpVector& res, Visibility visibility) const
{
std::set<const LocatedEntity*> receivers;
collectObservers(receivers);
for (auto& entity : receivers) {
if (visibility == Visibility::PRIVATE) {
//Only send private ops to admins
if (!entity->hasFlags(entity_admin)) {
continue;
}
} else if (visibility == Visibility::PROTECTED) {
//Protected ops also goes to the entity itself
if (!entity->hasFlags(entity_admin) &&
entity->getIntId() != getIntId()) {
continue;
}
}
auto newOp = op.copy();
newOp->setTo(entity->getId());
newOp->setFrom(getId());
res.push_back(newOp);
}
}
void SoundEntity::Entity_Action(const Atlas::Objects::Operation::RootOperation& act)
{
const std::list<std::string> &p = act->getParents();
std::list<std::string>::const_iterator I = p.begin();
if (I != p.end()) {
const std::string& name = *I;
playAction(name);
}
}
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 EmberEntity::onAction(const Atlas::Objects::Operation::RootOperation& act)
{
const std::list<std::string> &p = act->getParents();
std::list<std::string>::const_iterator I = p.begin();
if (I != p.end()) {
const std::string& name = *I;
std::string message = getName() + " performs a " + name + ".";
ConsoleBackend::getSingletonPtr()->pushMessage(message, "info");
S_LOG_VERBOSE("Entity: " << this->getId() << " (" << this->getName() << ") action: " << name);
}
Entity::onAction(act);
}
void EmberEntity::onSoundAction(const Atlas::Objects::Operation::RootOperation & op)
{
//We'll just catch the call and write something to both the log and the console, and then pass it on.
const std::list<std::string> &p = op->getParents();
std::list<std::string>::const_iterator I = p.begin();
if (I != p.end()) {
const std::string& name = *I;
std::string message = getName() + " emits a " + name + ".";
ConsoleBackend::getSingletonPtr()->pushMessage(message, "info");
S_LOG_VERBOSE("Entity: " << this->getId() << " (" << this->getName() << ") sound action: " << name);
}
Eris::Entity::onSoundAction(op);
}
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.emplace_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.emplace_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;
thinkOp->setParent("think");
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();
}
}
int main()
{
TestWorld world;
CommServer server;
{
Peer * p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
delete p;
}
{
Peer * p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::RootOperation op;
OpVector res;
p->operation(op, res);
delete p;
}
{
// Test the setting of authentiaction states
Peer * p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
assert(p->getAuthState() == PEER_INIT);
p->setAuthState(PEER_AUTHENTICATED);
assert(p->getAuthState() == PEER_AUTHENTICATED);
delete p;
}
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
p->operation(op, res);
}
// Authenticating (no args)
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATING);
Atlas::Objects::Operation::Info op;
OpVector res;
p->operation(op, res);
}
// Authenticating (empty arg)
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATING);
Atlas::Objects::Operation::Info op;
Atlas::Objects::Root arg;
op->setArgs1(arg);
OpVector res;
p->operation(op, res);
}
// Authenticating (full arg)
{
TestPeer *p = new TestPeer(*(CommSocket*)0, *(ServerRouting*)0, "addr", "1", 1);
p->setAuthState(PEER_AUTHENTICATING);
Atlas::Objects::Operation::Info op;
Atlas::Objects::Root arg;
arg->setId("2");
std::list<std::string> parents;
parents.push_back("server");
arg->setParents(parents);
op->setArgs1(arg);
OpVector res;
p->operation(op, res);
assert(p->getAccountType() == "server");
}
// Authenticated (no args)
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Atlas::Objects::Operation::Info op;
OpVector res;
p->operation(op, res);
}
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Error op;
OpVector res;
p->operation(op, res);
}
// Not authenticated
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Entity e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == -1);
}
// Authenticated
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
}
// Re-teleport same entity
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
ret = p->teleportEntity(&e);
assert(ret != 0);
}
// Character (no mind)
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
}
// Character (externl mind, unconnected)
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("3", 3);
e.m_externalMind = new ExternalMind(e);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
}
// Character (externl mind, connected)
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("3", 3);
ExternalMind * mind = new ExternalMind(e);
mind->linkUp((Link*)23);
e.m_externalMind = mind;
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 2);
}
// No arg
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
p->peerTeleportResponse(op, res);
}
// Empty arg, no refno
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
p->peerTeleportResponse(op, res);
}
// Empty arg, made up refno, not CommPeer
{
TestCommClient *peerConn = new TestCommClient(*(CommServer*)0, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
}
// Empty arg, made up refno
{
CommPeer *peerConn = new CommPeer(*(CommServer*)0, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
}
// Empty arg, refno that matches earlier teleport, not in world
{
CommPeer *peerConn = new CommPeer(server, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("23", 23);
int ret = p->teleportEntity(&e);
assert(ret == 0);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
}
// Empty arg, refno that matches earlier teleport, in world
{
CommPeer *peerConn = new CommPeer(server, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("23", 23);
int ret = p->teleportEntity(&e);
assert(ret == 0);
world.test_addEntity(&e, 23);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
world.test_delEntity(23);
}
// Empty arg, refno that matches earlier teleport, with mind
{
CommPeer *peerConn = new CommPeer(server, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("23", 23);
ExternalMind * mind = new ExternalMind(e);
mind->linkUp((Link*)23);
e.m_externalMind = mind;
int ret = p->teleportEntity(&e);
assert(ret == 0);
world.test_addEntity(&e, 23);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
world.test_delEntity(23);
}
// No teleports to clear
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->cleanTeleports();
}
// One teleport to clear
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("23", 23);
int ret = p->teleportEntity(&e);
assert(ret == 0);
p->cleanTeleports();
}
return 0;
}
int main()
{
CommServer comm_server;
{
new TestCommClient(comm_server);
}
{
new TestCommClient(comm_server, 0);
}
{
TestCommClient * cs = new TestCommClient(comm_server);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setEncoder();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->setup(0);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_negotiate();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs));
cs->test_setNegotiateState(Atlas::Negotiate::SUCCEEDED);
cs->test_negotiate();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setNegotiateState(Atlas::Negotiate::FAILED);
cs->test_negotiate();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnectTime(0);
cs->test_idle(0);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs));
cs->test_setNegotiateState(Atlas::Negotiate::SUCCEEDED);
cs->test_negotiate();
cs->test_setConnectTime(0);
cs->test_idle(0);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnectTime(0);
cs->test_idle(20);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->read();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setEncoder();
cs->read();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
Atlas::Objects::Operation::RootOperation op;
cs->send(op);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_openSocket();
Atlas::Objects::Operation::RootOperation op;
cs->send(op);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_openSocket();
cs->test_setEncoder();
Atlas::Objects::Operation::RootOperation op;
cs->send(op);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs));
Atlas::Objects::Operation::RootOperation op;
cs->test_operation(op);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs, 1));
Atlas::Objects::Operation::RootOperation op;
cs->test_operation(op);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs, 1));
Atlas::Objects::Operation::RootOperation op;
op->setSerialno(23);
cs->test_operation(op);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs, 1));
cs->dispatch();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
cs->test_setConnection(new TestLink(*cs, 1));
cs->test_setupQueue();
cs->dispatch();
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
Atlas::Objects::Entity::RootEntity ent;
cs->test_objectArrived(ent);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
Atlas::Objects::Entity::RootEntity ent;
ent->setParents(std::list<std::string>());
cs->test_objectArrived(ent);
delete cs;
}
{
TestCommClient * cs = new TestCommClient(comm_server);
Atlas::Objects::Operation::RootOperation op;
cs->test_objectArrived(op);
delete cs;
}
return 0;
}
int CommClient::send(const Atlas::Objects::Operation::RootOperation & op)
{
stub_connection_send_op = op->getClassNo();
++stub_connection_send_count;
return 0;
}