void Interactive::disappearanceArrived(const Operation & op)
{
if (m_accountId.empty()) {
return;
}
if (m_accountId != op->getTo()) {
// This is an IG op we are monitoring
return;
}
if (op->getArgs().empty()) {
return;
}
RootEntity ent = smart_dynamic_cast<RootEntity>(op->getArgs().front());
if (!ent.isValid()) {
std::cerr << "Got Disappearance of non-entity" << std::endl << std::flush;
return;
}
if (!ent->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "Got Disappearance of non-string ID" << std::endl << std::flush;
return;
}
const std::string & id = ent->getId();
std::cout << "Disappearance(id: " << id << ")";
if (!ent->hasAttrFlag(Atlas::Objects::Entity::LOC_FLAG)) {
std::cout << std::endl << std::flush;
return;
}
const std::string & loc = ent->getLoc();
std::cout << " in " << loc << std::endl;
if (loc == "lobby") {
std::cout << id << " has logged out." << std::endl;
}
std::cout << std::flush;
}
LocatedEntity * CreatorClient::handleMakeResponse(const RootOperation & op,
double create_time)
{
if (op->getArgs().empty()) {
std::cerr << "Arg of reply to make has no args"
<< std::endl << std::flush;
return NULL;
}
RootEntity created = smart_dynamic_cast<RootEntity>(op->getArgs().front());
if (!created.isValid()) {
std::cerr << "Created argument is not an entity"
<< std::endl << std::flush;
return NULL;
}
if (!created->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "Created entity has no id"
<< std::endl << std::flush;
return NULL;
}
const std::string & created_id = created->getId();
if (created->getParents().empty()) {
std::cerr << "Created entity " << created_id << " has no type"
<< std::endl << std::flush;
return NULL;
}
const std::string & created_type = created->getParents().front();
std::cout << "Created: " << created_type << "(" << created_id << ")"
<< std::endl << std::flush;
LocatedEntity * obj = m_map.updateAdd(created, create_time);
return obj;
}
void Connection::handleServerInfo(const RootOperation& op)
{
RootEntity svr = smart_dynamic_cast<RootEntity>(op->getArgs().front());
if (!svr.isValid()) {
error() << "server INFO argument object is broken";
return;
}
m_info.processServer(svr);
GotServerInfo.emit();
}
LocatedEntity * CharacterClient::sendLook(const Operation & op)
{
OpVector result;
if (sendAndWaitReply(op, result) != 0) {
std::cerr << "No reply to look" << std::endl << std::flush;
return NULL;
}
assert(!result.empty());
const Operation & res = result.front();
if (!res.isValid()) {
std::cerr << "NULL reply to look" << std::endl << std::flush;
return NULL;
}
const std::string & resparent = res->getParent();
if (resparent == "unseen") {
return NULL;
}
if (resparent != "sight") {
std::cerr << "Reply to look is " << resparent << " not sight" << std::endl << std::flush;
return NULL;
}
if (res->getArgs().empty()) {
std::cerr << "Reply to look has no args" << std::endl << std::flush;
return NULL;
}
RootEntity seen = smart_dynamic_cast<RootEntity>(res->getArgs().front());
if (!seen.isValid()) {
std::cerr << "Sight arg is not an entity" << std::endl << std::flush;
return NULL;
}
if (!seen->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "Looked at entity has no id" << std::endl << std::flush;
return NULL;
}
const std::string & sight_id = seen->getId();
if (seen->hasAttrFlag(Atlas::Objects::PARENT_FLAG)) {
std::cout << "Seen: " << seen->getParent()
<< "(" << sight_id << ")" << std::endl << std::flush;
} else {
std::cout << "Seen: " << sight_id << std::endl << std::flush;
}
LocatedEntity * obj = m_map.updateAdd(seen, res->getSeconds());
return obj;
}
void ServerAccount::createObject(const std::string & type_str,
const Root & arg,
const Operation & op,
OpVector & res)
{
// Format of the Create ops that are received by this function should
// have the entity to be created as the first argument. If the entity
// being created is a character associated with an account, an additional
// argument should specify the possess key that will be used by the client
// to claim ownership of the entity being created.
if (arg->getObjtype() != "obj") {
// Return error to peer
error(op, "Only creation of entities by peer server is permitted",
res, getId());
return;
}
RootEntity ent = smart_dynamic_cast<RootEntity>(arg);
if(!ent.isValid()) {
log(ERROR, "Character creation arg is malformed");
return;
}
// If we have a possess key (entity has a mind)
TeleportAuthenticator * tele_auth = 0;
std::string possess_key;
const std::vector<Root> & args = op->getArgs();
if (args.size() == 2) {
const Root & arg2 = args.back();
Element key;
if(arg2->copyAttr("possess_key", key) == 0 && key.isString()) {
possess_key = key.String();
tele_auth = TeleportAuthenticator::instance();
} else {
log(ERROR, "Entity has mind but no possess key found");
return;
}
}
debug( std::cout << "ServerAccount creating a " << type_str << " object"
<< std::endl << std::flush; );
HandlerResult TerrainModProperty::move_handler(LocatedEntity * e,
const Operation & op,
OpVector & res)
{
// FIXME Force instantiation of a class property?
// Check the validity of the operation.
const std::vector<Root> & args = op->getArgs();
if (args.empty()) {
return OPERATION_IGNORED;
}
RootEntity ent = Atlas::Objects::smart_dynamic_cast<RootEntity>(args.front());
if (!ent.isValid()) {
return OPERATION_IGNORED;
}
if (e->getId() != ent->getId()) {
return OPERATION_IGNORED;
}
// Update the modifier
move(e);
return OPERATION_IGNORED;
}
void AccountConnectionintegration::test_account_creation()
{
// Basic player account creation
{
ASSERT_NOT_NULL(m_connection);
ASSERT_TRUE(m_connection->objects().empty());
Create op;
Anonymous create_arg;
create_arg->setParents(std::list<std::string>(1, "player"));
create_arg->setAttr("username", "39d409ec");
create_arg->setAttr("password", "6a6e71bab281");
op->setArgs1(create_arg);
ASSERT_TRUE(test_sent_ops.empty());
// Send the operation to create the account
m_connection->externalOperation(op, *m_connection);
// There should be a response op
ASSERT_TRUE(!test_sent_ops.empty());
ASSERT_EQUAL(test_sent_ops.size(), 1u);
// and the account creation should have created an object bound
// to this connection.
ASSERT_TRUE(!m_connection->objects().empty());
// Check the response is an info indicating successful account
// creation.
const Operation & reply = test_sent_ops.front();
ASSERT_EQUAL(reply->getClassNo(), Atlas::Objects::Operation::INFO_NO);
// The Info response should have an argument describing the created
// account
const std::vector<Root> & reply_args = reply->getArgs();
ASSERT_TRUE(!reply_args.empty());
RootEntity account = smart_dynamic_cast<RootEntity>(reply_args.front());
ASSERT_TRUE(account.isValid());
// The account ID should be provided
ASSERT_TRUE(!account->isDefaultId());
const std::string account_id = account->getId();
ASSERT_TRUE(!account_id.empty());
// Check the account has been registered in the server object
Router * account_router_ptr = m_server->getObject(account_id);
ASSERT_NOT_NULL(account_router_ptr);
// Check the account has been logged into the lobby
const AccountDict & lobby_dict = m_server->m_lobby.getAccounts();
AccountDict::const_iterator I = lobby_dict.find(account_id);
ASSERT_TRUE(I != lobby_dict.end());
Account * account_ptr = I->second;
ASSERT_EQUAL(account_router_ptr, account_ptr);
// Basic login as now been established by account creation
// Set up some other account details
create_arg->setAttr("username", "89cae312");
create_arg->setAttr("password", "d730b8bd2d6c");
// and try an additional account creation, which should fail.
// Multiple logins are ok, but there is no reason to allow multiple
// account creations.
test_sent_ops.clear();
m_connection->externalOperation(op, *m_connection);
ASSERT_TRUE(!test_sent_ops.empty());
ASSERT_EQUAL(test_sent_ops.size(), 1u);
const Operation & error_reply = test_sent_ops.front();
ASSERT_EQUAL(error_reply->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
Player::playableTypes.insert(test_valid_character_type);
Anonymous character_arg;
character_arg->setParents(std::list<std::string>(1, test_valid_character_type));
character_arg->setName("938862f2-4db2-4e8e-b944-7b0935e569db");
Create character_op;
character_op->setArgs1(character_arg);
character_op->setFrom(account_id);
test_sent_ops.clear();
m_connection->externalOperation(character_op, *m_connection);
// FIXME the above went through Account::externalOperation, so there
// is no reply in res. The reply has gone directly to the Link::send
// method. Add a way of checking, once there are better stubs.
ASSERT_TRUE(!test_sent_ops.empty());
ASSERT_EQUAL(test_sent_ops.size(), 2u);
const Operation & create_reply = test_sent_ops.front();
ASSERT_EQUAL(create_reply->getClassNo(),
Atlas::Objects::Operation::INFO_NO);
// TODO Character creation etc?
// TODO Lobby interaction?
// TODO Logout ?
}
}
void Commander::dispatch(const RootOperation& op)
{
Appearance appear = smart_dynamic_cast<Appearance>(op);
if (appear.isValid()) {
assert(op->hasAttr("for"));
Agent* ag = m_server->findAgentForEntity(op->getAttr("for").asString());
if (ag) {
ag->setEntityVisible(op->getTo(), true);
} else {
// doesn't exist yet, mark as visible if / when the agent is created
Agent::setEntityVisibleForFutureAgent(op->getTo(), op->getAttr("for").asString());
}
}
Disappearance disap = smart_dynamic_cast<Disappearance>(op);
if (disap.isValid()) {
assert(op->hasAttr("for"));
Agent* ag = m_server->findAgentForEntity(op->getAttr("for").asString());
if (ag) ag->setEntityVisible(op->getTo(), false);
}
Create cr = smart_dynamic_cast<Create>(op);
if (cr.isValid()) {
std::vector<Root> args(op->getArgs());
assert(!args.empty());
RootEntity ent = smart_dynamic_cast<RootEntity>(args.front());
assert(ent.isValid());
static int idCounter = 900;
char buf[32];
snprintf(buf, 32, "_created_%d", ++idCounter);
std::string id(buf);
ent->setId(id);
std::string loc = ent->getLoc();
assert(m_server->m_world.count(loc));
StringList children(m_server->m_world[loc]->getContains());
children.push_back(id);
m_server->m_world[loc]->setContains(children);
m_server->m_world[id] = ent;
Create bcr(cr);
bcr->setArgs1(ent);
Agent::broadcastSight(bcr);
}
Delete del = smart_dynamic_cast<Delete>(op);
if (del.isValid()) {
std::vector<Root> args(op->getArgs());
assert(!args.empty());
std::string id = args.front()->getId();
assert(m_server->m_world.count(id));
m_server->m_world.erase(id);
Agent::broadcastSight(op);
}
Move mv = smart_dynamic_cast<Move>(op);
if (mv.isValid()) {
RootEntity ent = m_server->getEntity(op->getTo());
std::vector<Root> args(op->getArgs());
if (args.front()->hasAttr("loc")) {
std::string newLocId = args.front()->getAttr("loc").asString();
RootEntity oldLoc = m_server->getEntity(ent->getLoc()),
newLoc = m_server->getEntity(newLocId);
ent->setLoc(newLocId);
// modify stamps?
oldLoc->modifyContains().remove(ent->getId());
newLoc->modifyContains().push_back(ent->getId());
}
if (args.front()->hasAttr("pos"))
ent->setPosAsList(args.front()->getAttr("pos").asList());
// handle velocity changes
Agent::broadcastSight(op);
return;
}
Sound snd = smart_dynamic_cast<Sound>(op);
if (snd.isValid()) {
std::vector<Root> args(op->getArgs());
assert(!args.empty());
if (snd->hasAttr("broadcast")) {
Agent::broadcastSound(smart_dynamic_cast<RootOperation>(args.front()));
}
}
Sight st = smart_dynamic_cast<Sight>(op);
if (st.isValid()) {
if (st->hasAttr("broadcast")) {
std::vector<Root> args(op->getArgs());
assert(!args.empty());
Agent::broadcastSight(smart_dynamic_cast<RootOperation>(args.front()));
}
}
Set s = smart_dynamic_cast<Set>(op);
if (s.isValid()) {
std::vector<Root> args(op->getArgs());
for (unsigned int A=0; A < args.size(); ++A) {
std::string eid = args[A]->getId();
RootEntity entity = m_server->getEntity(eid);
Root::const_iterator I = args[A]->begin();
for (; I != args[A]->end(); ++I) {
if ((I->first == "id") || (I->first == "parents") || (I->first == "objtype")) {
continue;
}
assert(I->first != "loc");
entity->setAttr(I->first, I->second);
}
}
Agent::broadcastSight(s);
}
Action act = smart_dynamic_cast<Action>(op);
if (act.isValid()) {
std::vector<Root> args(op->getArgs());
if (act->getParents().front() == "command") {
std::string cid = args[0]->getAttr("cid").asString();
if (cid == "socket-shutdown") {
std::string acc = args[0]->getAttr("acc").asString();
ClientConnection* cc = m_server->getConnectionForAccount(acc);
assert(cc);
cc->shutdown();
} else if (cid == "add-many-objects") {
m_server->addManyObjects(args[0]->getAttr("acc").asString());
} else if (cid == "set-world-time") {
/* double t = */ args[0]->getAttr("seconds").asFloat();
} else {
std::cerr << "unknown command " << cid << std::endl;
}
} // of command action case
} // of action case
}
void AccountConnectionintegration::test_account_creation()
{
// Basic player account creation
{
ASSERT_NOT_NULL(m_connection);
ASSERT_TRUE(m_connection->objects().empty());
Create op;
Anonymous create_arg;
create_arg->setParent("player");
create_arg->setAttr("username", "39d409ec");
create_arg->setAttr("password", "6a6e71bab281");
op->setArgs1(create_arg);
ASSERT_TRUE(test_sent_ops.empty());
// Send the operation to create the account
m_connection->externalOperation(op, *m_connection);
// There should be a response op
ASSERT_TRUE(!test_sent_ops.empty());
ASSERT_EQUAL(test_sent_ops.size(), 1u);
// and the account creation should have created an object bound
// to this connection.
ASSERT_TRUE(!m_connection->objects().empty());
// Check the response is an info indicating successful account
// creation.
const Operation & reply = test_sent_ops.front();
ASSERT_EQUAL(reply->getClassNo(), Atlas::Objects::Operation::INFO_NO);
// The Info response should have an argument describing the created
// account
const std::vector<Root> & reply_args = reply->getArgs();
ASSERT_TRUE(!reply_args.empty());
RootEntity account = smart_dynamic_cast<RootEntity>(reply_args.front());
ASSERT_TRUE(account.isValid());
// The account ID should be provided
ASSERT_TRUE(!account->isDefaultId());
const std::string account_id = account->getId();
ASSERT_TRUE(!account_id.empty());
// Check the account has been registered in the server object
Router * account_router_ptr = m_server->getObject(account_id);
ASSERT_NOT_NULL(account_router_ptr);
// Check the account has been logged into the lobby
const auto & lobby_dict = m_server->m_lobby.getAccounts();
auto I = lobby_dict.find(account_id);
ASSERT_TRUE(I != lobby_dict.end());
auto account_ptr = I->second;
ASSERT_EQUAL(account_router_ptr, account_ptr);
// Basic login as now been established by account creation
// Set up some other account details
create_arg->setAttr("username", "89cae312");
create_arg->setAttr("password", "d730b8bd2d6c");
// and try an additional account creation, which should fail.
// Multiple logins are ok, but there is no reason to allow multiple
// account creations.
test_sent_ops.clear();
m_connection->externalOperation(op, *m_connection);
ASSERT_TRUE(!test_sent_ops.empty());
ASSERT_EQUAL(test_sent_ops.size(), 1u);
const Operation & error_reply = test_sent_ops.front();
ASSERT_EQUAL(error_reply->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
// TODO Character creation etc?
// TODO Lobby interaction?
// TODO Logout ?
}
}
LocatedEntity * CreatorClient::make(const RootEntity & entity)
{
Create op;
op->setArgs1(entity);
op->setFrom(getId());
op->setTo(getId());
OpVector result;
if (sendAndWaitReply(op, result) != 0) {
std::cerr << "No reply to make" << std::endl << std::flush;
return NULL;
}
assert(!result.empty());
const Operation & res = result.front();
if (!res.isValid()) {
std::cerr << "NULL reply to make" << std::endl << std::flush;
return NULL;
}
if (res->getClassNo() != Atlas::Objects::Operation::SIGHT_NO) {
std::cerr << "Reply to make isn't sight" << std::endl << std::flush;
return NULL;
}
if (res->getArgs().empty()) {
std::cerr << "Reply to make has no args" << std::endl << std::flush;
return NULL;
}
RootOperation arg = smart_dynamic_cast<RootOperation>(res->getArgs().front());
if (!arg.isValid()) {
std::cerr << "Arg of reply to make is not an operation"
<< std::endl << std::flush;
return NULL;
}
if (arg->getClassNo() != Atlas::Objects::Operation::CREATE_NO) {
std::cerr << "Reply to make isn't sight of create"
<< std::endl << std::flush;
return NULL;
}
if (arg->getArgs().empty()) {
std::cerr << "Arg of reply to make has no args"
<< std::endl << std::flush;
return NULL;
}
RootEntity created = smart_dynamic_cast<RootEntity>(arg->getArgs().front());
if (!created.isValid()) {
std::cerr << "Created argument is not an entity"
<< std::endl << std::flush;
return NULL;
}
if (!created->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "Created entity has no id"
<< std::endl << std::flush;
return NULL;
}
const std::string & created_id = created->getId();
if (created->getParents().empty()) {
std::cerr << "Created entity " << created_id << " has no type"
<< std::endl << std::flush;
return NULL;
}
const std::string & created_type = created->getParents().front();
std::cout << "Created: " << created_type << "(" << created_id << ")"
<< std::endl << std::flush;
LocatedEntity * obj = m_map.updateAdd(created, res->getSeconds());
return obj;
}