/// \brief Create a new account on the server
///
/// @param name User name of the new account
/// @param password Password of the new account
Root BaseClient::createSystemAccount()
{
Anonymous player_ent;
player_ent->setAttr("username", create_session_username());
player_ent->setAttr("password", compose("%1%2", ::rand(), ::rand()));
player_ent->setParents(std::list<std::string>(1, "sys"));
Create createAccountOp;
createAccountOp->setArgs1(player_ent);
createAccountOp->setSerialno(m_connection.newSerialNo());
send(createAccountOp);
if (m_connection.wait() != 0) {
std::cerr << "ERROR: Failed to log into server: \""
<< m_connection.errorMessage() << "\""
<< std::endl << std::flush;
return Root(0);
}
const Root & ent = m_connection.getInfoReply();
if (!ent->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "ERROR: Logged in, but account has no id" << std::endl
<< std::flush;
} else {
m_playerId = ent->getId();
// m_playerName = name;
}
return ent;
}
void ClientConnection::processAccountCreate(const Create& cr)
{
const std::vector<Root>& args = cr->getArgs();
if (args.empty()) {
sendError("missing account in create", cr);
return;
}
// check for duplicate username
AtlasAccount acc = smart_dynamic_cast<AtlasAccount>(args.front());
if (!acc.isValid()) {
sendError("malformed account in create", cr);
return;
}
AccountMap::const_iterator A = m_server->findAccountByUsername(acc->getUsername());
if (A != m_server->m_accounts.end()) {
sendError("duplicate account: " + acc->getUsername(), cr);
return;
}
m_account = std::string("_") + acc->getUsername() + "_123";
acc->setId(m_account);
m_server->m_accounts[m_account] = acc;
Info createInfo;
createInfo->setArgs1(acc);
createInfo->setTo(m_account);
createInfo->setRefno(cr->getSerialno());
send(createInfo);
m_server->joinRoom(m_account, "_lobby");
m_server->resetWorld();
}
int main()
{
cout << "\n";
Create create;
Change change;
create.fillPointerBuffer();
cout << "main()---------------------------------" << endl;
//cout << "create.num: " << create.num << endl;
cout << "create.bufferPtr: " << create.bufferPtr << endl;
cout << "change.process(create.bufferPtr, create.size)" << endl;
cout << "---------------------------------------" << endl;
cout << "\n";
change.process(create.bufferPtr, create.size);
cout << "\n";
cout << "main()---------------------------------" << endl;
cout << "create.bufferPtr: " << create.bufferPtr << endl;
cout << "create.size: " << create.size << endl;
cout << "---------------------------------------" << endl;
cout << "\n";
cout << "----------SUMMARY-------------" << endl;
cout << "create.bufferPtr: " << create.bufferPtr << endl;
cout << "create.size: " << create.size << endl;
for (int i=0; i<create.size; i++) {
cout << "create.bufferPtr[" << i << "]: " << create.bufferPtr[i] << endl;
}
cout << "------------------------------" << endl;
cout << "\n";
return 0;
}
void Connectiontest::test_CreateOperation_root_arg()
{
Create op;
OpVector res;
op->setArgs1(Root());
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 0u);
ASSERT_TRUE(Router_error_called);
}
void Connectiontest::test_CreateOperation_empty_arg()
{
Create op;
OpVector res;
restricted_flag = false;
Anonymous op_arg;
op->setArgs1(op_arg);
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 0u);
ASSERT_TRUE(Router_error_called);
}
void Connectiontest::test_CreateOperation_account_by_id()
{
Create op;
OpVector res;
Anonymous op_arg;
op->setArgs1(op_arg);
op_arg->setId("jim");
// Legacy op
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 0u);
ASSERT_TRUE(Router_error_called);
}
void Connectiontest::test_CreateOperation_number_username()
{
Create op;
OpVector res;
Anonymous op_arg;
op->setArgs1(op_arg);
op_arg->setAttr("username", 1);
// Malformed username
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 0u);
ASSERT_TRUE(Router_error_called);
}
void Connectiontest::test_CreateOperation_no_passed()
{
Create op;
OpVector res;
Anonymous op_arg;
op->setArgs1(op_arg);
op_arg->setAttr("username", "jim");
// username, no password
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 0u);
ASSERT_TRUE(Router_error_called);
}
void Connectiontest::test_CreateOperation()
{
Create op;
OpVector res;
Anonymous op_arg;
op->setArgs1(op_arg);
op_arg->setAttr("username", "jim");
op_arg->setAttr("password", "foo");
// valid username and password
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 1u);
}
void Accountintegration::test_CreateOperation()
{
Anonymous op_arg;
op_arg->setParents(std::list<std::string>(1, "game_entity"));
op_arg->setName("Bob");
Create op;
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
}
void Connectiontest::test_CreateOperation_username()
{
Create op;
OpVector res;
Anonymous op_arg;
op->setArgs1(op_arg);
op_arg->setAttr("username", "");
op_arg->setAttr("password", "foo");
// zero length username
m_connection->operation(op, res);
ASSERT_EQUAL(m_connection->m_objects.size(), 0u);
ASSERT_TRUE(Router_clientError_called);
}
void run_operation_checks(TestServerAccount * ac, Entity * chr, WorldRouter & world)
{
// Entity injection test
{
Anonymous ent;
// Add the test attributes
ent->setAttr("objtype", "obj");
ent->setAttr("name", "test_entity");
ent->setParents(std::list<std::string>(1,"thing"));
Create op;
OpVector res;
op->setArgs1(ent);
ac->operation(op, res);
Entity *reply = world.findByName("test_entity");
assert(reply != 0);
}
// Regular create op tests
{
// This is the only op we've overridden
Create op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op_arg->setParents(std::list<std::string>(1, "game_entity"));
ac->operation(op, res);
op_arg->setObjtype("obj");
ac->operation(op, res);
op_arg->setName("Bob");
ac->operation(op, res);
op_arg->setObjtype("class");
ac->operation(op, res);
op_arg->setId("game_entity");
ac->operation(op, res);
op_arg->setId("new_class");
ac->operation(op, res);
op_arg->setParents(std::list<std::string>(1, ""));
ac->operation(op, res);
op_arg->setParents(std::list<std::string>(1, "non_exist"));
ac->operation(op, res);
}
}
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;
}
// FIXME Make this more robust against an info response
if (res->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
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;
}
return handleMakeResponse(arg, res->getSeconds());
} else if (res->getClassNo() == Atlas::Objects::Operation::INFO_NO) {
return handleMakeResponse(res, res->getSeconds());
} else {
std::cerr << "Reply to make isn't sight or info"
<< std::endl << std::flush;
return NULL;
}
}
int AtlasStreamClient::create(const std::string & type,
const std::string & username,
const std::string & password)
{
m_username = username;
Create c;
Anonymous account;
account->setAttr("username", username);
account->setAttr("password", password);
account->setParents(std::list<std::string>(1, type));
c->setArgs1(account);
c->setSerialno(newSerialNo());
send(c);
return waitForLoginResponse();
}
void EntityImporterBase::createEntity(const RootEntity & obj, OpVector & res)
{
++mStats.entitiesProcessedCount;
++mStats.entitiesCreateCount;
EventProgress.emit();
m_state = ENTITY_CREATING;
assert(mTreeStack.size() > 1);
std::deque<StackEntry>::reverse_iterator I = mTreeStack.rbegin();
++I;
assert(I != mTreeStack.rend());
const std::string & loc = I->restored_id;
RootEntity create_arg = obj.copy();
create_arg->removeAttrFlag(Atlas::Objects::Entity::CONTAINS_FLAG);
create_arg->removeAttrFlag(Atlas::Objects::Entity::VELOCITY_FLAG);
create_arg->removeAttrFlag(Atlas::Objects::ID_FLAG);
create_arg->setLoc(loc);
//Remove any attribute which references another entity from the Create op.
//This is because the attribute will at this time with certainty refer to the wrong or a non-existing entity.
//The attribute will later on be set through a Set op in sendResolvedEntityReferences().
auto referenceMapEntryI = mEntitiesWithReferenceAttributes.find(obj->getId());
if (referenceMapEntryI != mEntitiesWithReferenceAttributes.end()) {
for (const auto& attributeName : referenceMapEntryI->second) {
create_arg->removeAttr(attributeName);
}
}
Create create;
create->setArgs1(create_arg);
create->setFrom(mAvatarId);
create->setSerialno(newSerialNumber());
mCreateEntityMapping.insert(std::make_pair(create->getSerialno(), obj->getId()));
res.push_back(create);
}
StoreWatcher::StoreWatcher(StoreWatcherStartParams params) :
Device(params.active),
_store(NULL),
_ctx(params.zctx),
_endpoint(params.endpoint),
logging_endpoint(params.logging_endpoint),
socket(NULL),
logging_sock(NULL),
watcher(params.store_path, true)
{
this->_store = new SimpleDirectoryStore(params.store_path);
this->id = platform::CreateUUID(false);
this->logging_sock = new socket_t(*this->_ctx, ZMQ_PUSH);
this->logging_sock->connect(this->logging_endpoint.c_str());
Create log;
log.set_id(this->id);
Envelope e;
log.add_to_envelope(e);
zeromq::SendEnvelope(*this->logging_sock, e, false, 0);
}
bool HallAction::execute(const QString &input, QStringList* output) {
QString head = Command::ParseHead(input);
if (head == kActionRooms) {
for (auto it : hall_->opens_) {
*output << " * ";
output->last().append(it.first);
if (!it.second->pin().isEmpty()) {
output->last().append(" (** pin required)");
}
}
} else if (head == kActionCreate) {
if (Hall::opens_.size() >= kMaxRoomCount) {
*output << QString("Maximum room count reached: %1").arg(kMaxRoomCount);
} else {
Create* create = new Create;
if (!create->execute(input, output)) {
client_->registerProtocol(create);
} else {
delete create;
}
}
} else if (head == kActionQuit) {
emit client_->closeConnection();
*output << "BYE!";
} else if (head == kActionJoin) {
Join* join = new Join(hall_, client_);
if (!join->execute(input, output)) {
client_->registerProtocol(join);
} else {
delete join;
}
} else {
*output << actionList_;
}
return false;
}
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 ?
}
}
void testValues()
{
Account account;
Login l;
account->setId("al");
account->setAttr("password", std::string("ping"));
l->setArgs1(account);
// assert(l->getArgs()[0]->getLongDescription()=="Later in hierarchy tree objtype changes to 'object' when actual game objects are made.");
// assert(l->getArgs()[0]->getDescription()=="Base class for accounts");
assert(l->getId()=="");
assert(l->getParents().front()=="login");
assert(l->getObjtype()=="op");
// std::cout<<std::endl<<"account.long_description: "
// <<l->getArgs()[0]->getLongDescription()<<std::endl;
{
Atlas::Message::MapType mobj;
Atlas::Message::ListType parents;
parents.push_back(std::string("account"));
mobj["parents"] = parents;
mobj["name"] = std::string("foo");
mobj["objtype"] = std::string("op");
Root obj = Atlas::Objects::Factories::instance()->createObject(mobj);
assert(obj->getClassNo() == Atlas::Objects::Entity::ACCOUNT_NO);
assert(obj->getId() == "");
assert(obj->isDefaultId() == true);
assert(obj->getName() == "foo");
assert(obj->isDefaultName() == false);
assert(obj->getParents().front() == "account");
//should this be true? modify MessageObject2ClassObject if yes
assert(obj->isDefaultParents() == false);
assert(obj->getObjtype() == "op");
assert(obj->isDefaultObjtype() == false); //should this be true?
// assert(obj->getDescription() == "Base class for accounts");
// assert(obj->isDefaultDescription() == true);
}
{
Atlas::Message::MapType mobj;
Root obj = Atlas::Objects::objectDefinitions.find(std::string("account"))->second;
assert(obj->getClassNo() == Atlas::Objects::Entity::ACCOUNT_NO);
assert(obj->getId() == "account");
assert(obj->isDefaultId() == false);
assert(obj->getName() == "");
assert(obj->isDefaultName() == true);
assert(obj->getParents().front() == "admin_entity");
assert(obj->isDefaultParents() == false);
assert(obj->getObjtype() == "class");
assert(obj->isDefaultObjtype() == false);
// assert(obj->getDescription() == "Base class for accounts");
// assert(obj->isDefaultDescription() == false);
}
{
Atlas::Message::MapType mobj;
Root obj = Atlas::Objects::Factories::instance()->createObject(mobj);
assert(obj->getClassNo() == Atlas::Objects::Entity::ANONYMOUS_NO);
assert(obj->getId() == "");
assert(obj->getName() == "");
assert(obj->getParents().size() == 0);
assert(obj->getObjtype() == "obj");
// assert(obj->getDescription() == "");
}
{
Atlas::Message::MapType mobj;
mobj["id"] = std::string("bar");
mobj["name"] = std::string("foo");
Atlas::Message::ListType parents;
parents.push_back(std::string("account"));
mobj["parents"] = parents;
Root obj = Atlas::Objects::Factories::instance()->createObject(mobj);
assert(obj->getClassNo() == Atlas::Objects::Entity::ANONYMOUS_NO);
assert(obj->getId() == "bar");
assert(obj->getName() == "foo");
assert(obj->getParents().front() == "account");
assert(obj->getObjtype() == "obj");
// assert(obj->getDescription() == "");
}
{
Atlas::Message::MapType maccount;
maccount["id"] = std::string("bar");
maccount["name"] = std::string("foo");
Atlas::Message::ListType parents;
parents.push_back(std::string("player"));
maccount["parents"] = parents;
maccount["objtype"] = "obj";
Atlas::Message::MapType mcreate;
mcreate["from"] = std::string("bar");
Atlas::Message::ListType parents2;
parents2.push_back(std::string("create"));
mcreate["parents"] = parents2;
Atlas::Message::ListType args;
args.push_back(maccount);
mcreate["args"] = args;
mcreate["objtype"] = "op";
Create op = Atlas::Objects::smart_dynamic_cast<Create>(Atlas::Objects::Factories::instance()->createObject(mcreate));
assert(op->getClassNo() == Atlas::Objects::Operation::CREATE_NO);
assert(op->instanceOf(Atlas::Objects::Operation::CREATE_NO));
assert(op->instanceOf(Atlas::Objects::Operation::ACTION_NO));
assert(op->instanceOf(Atlas::Objects::ROOT_NO));
assert(!op->instanceOf(Atlas::Objects::Operation::COMBINE_NO));
assert(!op->instanceOf(Atlas::Objects::Entity::ACCOUNT_NO));
assert(op->getFrom() == "bar");
assert(op->getParents().size() == 1);
assert(op->getParents().front() == "create");
assert(op->getObjtype() == "op");
// assert(op->getDescription() ==
// "Create new things from nothing using this operator.");
assert(op->getArgs().size() == 1);
Account op_arg = (Account&)op->getArgs().front();
assert(op_arg->getClassNo() == Atlas::Objects::Entity::PLAYER_NO);
assert(!op_arg->instanceOf(Atlas::Objects::Operation::CREATE_NO));
assert(!op_arg->instanceOf(Atlas::Objects::Operation::ACTION_NO));
assert(op_arg->instanceOf(Atlas::Objects::ROOT_NO));
assert(!op_arg->instanceOf(Atlas::Objects::Operation::COMBINE_NO));
assert(op_arg->instanceOf(Atlas::Objects::Entity::ACCOUNT_NO));
assert(op_arg->instanceOf(Atlas::Objects::Entity::PLAYER_NO));
assert(op_arg->getId() == "bar");
assert(op_arg->getParents().size() == 1);
assert(op_arg->getParents().front() == "player");
assert(op_arg->getObjtype() == "obj");
// assert(op_arg->getDescription() == "Player accounts");
assert(op_arg->getName() == "foo");
#if 0 //tmp
assert(op_arg->hasAttr("password"));
assert(op_arg->getAttr("password").isString());
assert(op_arg->getAttr("password").asString() == "");
#endif
assert(op_arg->hasAttr("name"));
assert(!op_arg->hasAttr("foo"));
assert(!op_arg->hasAttr("pos"));
assert(!op_arg->isDefaultName());
assert(op_arg->isDefaultPos());
}
}
void EntityImporterBase::createEntity(const RootEntity & obj, OpVector & res)
{
++mStats.entitiesProcessedCount;
++mStats.entitiesCreateCount;
EventProgress.emit();
m_state = ENTITY_CREATING;
assert(mTreeStack.size() > 1);
auto I = mTreeStack.rbegin();
++I;
assert(I != mTreeStack.rend());
const std::string & loc = I->restored_id;
RootEntity create_arg = obj.copy();
create_arg->removeAttrFlag(Atlas::Objects::Entity::CONTAINS_FLAG);
create_arg->removeAttrFlag(Atlas::Objects::Entity::VELOCITY_FLAG);
create_arg->removeAttrFlag(Atlas::Objects::ID_FLAG);
create_arg->setLoc(loc);
//Remove any attribute which references another entity from the Create op.
//This is because the attribute will at this time with certainty refer to the wrong or a non-existing entity.
//The attribute will later on be set through a Set op in sendResolvedEntityReferences().
auto referenceMapEntryI = mEntitiesWithReferenceAttributes.find(obj->getId());
if (referenceMapEntryI != mEntitiesWithReferenceAttributes.end()) {
std::set<std::string> resolvedAttributes;
for (const auto& referenceEntry : referenceMapEntryI->second) {
size_t resolvedEntitiesCount = 0;
//Check if all the referenced entities perhaps already have been created.
for (const auto& entityId : referenceEntry.referencedEntities) {
auto resolvedI = mEntityIdMap.find(entityId);
if (resolvedI != mEntityIdMap.end()) {
resolvedEntitiesCount++;
}
}
//If all entities were resolved, we should resolve the property now.
if (resolvedEntitiesCount == referenceEntry.referencedEntities.size()) {
Element element = create_arg->getAttr(referenceEntry.propertyName);
resolveEntityReferences(element);
create_arg->setAttr(referenceEntry.propertyName, element);
resolvedAttributes.insert(referenceEntry.propertyName);
} else {
create_arg->removeAttr(referenceEntry.propertyName);
}
}
//Remove those attributes that were resolved
if (resolvedAttributes.size() == referenceMapEntryI->second.size()) {
//All attributes were resolved, remove the entry completely.
mEntitiesWithReferenceAttributes.erase(referenceMapEntryI);
} else {
//Only remove those entries that were destroyed.
std::vector<ReferencedEntry> copy;
for (auto& referenceEntry : referenceMapEntryI->second) {
if (resolvedAttributes.find(referenceEntry.propertyName) == resolvedAttributes.end()) {
copy.push_back(std::move(referenceEntry));
}
}
referenceMapEntryI->second = std::move(copy);
}
}
Create create;
create->setArgs1(create_arg);
create->setFrom(mAvatarId);
create->setSerialno(newSerialNumber());
mCreateEntityMapping.insert(std::make_pair(create->getSerialno(), obj->getId()));
res.push_back(create);
}
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;
}
int main(int argc, char** argv)
{
string input;
CurrentUserAccounts current_accounts;
AvailableTickets available_tickets;
DailyTransaction daily_transactions;
User current_user;
/* Verify the correct number of arguments provided */
if (argc < 4)
{
cerr << "Usage: ./FrontEnd [current user accounts file] [available tickets file] "
<< "[daily transaction file]" << endl
<< "Example: ./FrontEnd user_accounts avail_tickets daily_transaction" << endl;
return EXIT_FAILURE;
}
/* Start the front end, read the input files and parse the contents */
try
{
cout << "Welcome." << endl;
/* Parse the current user accounts file */
current_accounts = CurrentUserAccounts(argv[1]);
cout << "Current user accounts file read successfully." << endl;
/* Parse the available tickets file */
available_tickets = AvailableTickets(argv[2]);
cout << "Available tickets file read successfully." << endl;
/* Set the filename for the daily transaction file */
daily_transactions = DailyTransaction(argv[3]);
}
catch (Exception& e)
{
cerr << e.mesg() << endl;
return EXIT_FAILURE;
}
cout << "> ";
while(getline(cin, input))
{
cout << endl;
try
{
switch(map_code[input])
{
case _login:
{
Login login = Login(current_user);
cout << "Enter username: "******"Username accepted." << endl;
break;
}
case _logout:
{
Logout logout = Logout(current_user);
current_user.logout();
current_user.reset_sell_status();
cout << "Logout complete." << endl;
/* Write all session transactions to daily transaction file */
daily_transactions.save((Transaction) logout);
daily_transactions.write();
break;
}
case _create:
{
Create create = Create(current_user);
/* Process the username */
cout << "Enter the username to create: ";
get_input(cin, input), cout << endl;
create.process_username(input, current_accounts);
/* Process the user type, save transaction if successful */
cout << "Enter the user type: ";
get_input(cin, input), cout << endl;
create.process_type(input);
daily_transactions.save((Transaction) create);
cout << "User created successfully." << endl;
break;
}
case _delete:
{
Delete __delete = Delete(current_user);
/* Process the username, save transaction if successful */
cout << "Enter the username to delete: ";
get_input(cin, input), cout << endl;
__delete.process_username(input, current_accounts);
daily_transactions.save((Transaction) __delete);
cout << "User deleted successfully." << endl;
break;
}
case _sell:
{
Sell sell = Sell(current_user);
/* Process the event title */
cout << "Enter the event title: ";
get_input(cin, input), cout << endl;
sell.process_title(input);
/* Process sale price */
cout << "Enter the sale price in dollars: ";
get_input(cin, input), cout << endl;
sell.process_price(input);
/* Process the volume, save transaction if successful */
cout << "Enter the number of tickets for sale: ";
get_input(cin, input), cout << endl;
sell.process_volume(input);
/* Record that the user has sold tickets this session */
current_user.tickets_sold();
daily_transactions.save((Transaction) sell);
cout << "Tickets listed for sale successfully." << endl;
break;
}
case _buy:
{
Buy buy = Buy(current_user);
/* Process the event title */
cout << "Enter the event title: ";
get_input(cin, input), cout << endl;
buy.process_title(input, available_tickets);
/* Process the volume */
cout << "Enter the number of tickets to purchase: ";
get_input(cin, input), cout << endl;
buy.process_volume(input);
/* Process the seller */
cout << "Enter the seller's username: "******"Purchase tickets? Please confirm (yes/no): ";
get_input(cin, input), cout << endl;
buy.process_confirmation(input);
daily_transactions.save((Transaction) buy);
cout << "Tickets purchased successfully." << endl;
break;
}
case _refund:
{
Refund refund = Refund(current_user);
/* Process buyer's username */
cout << "Enter the buyer's username: "******"Enter the seller's username: "******"Enter the amount of credit to transfer: ";
get_input(cin, input), cout << endl;
refund.process_credit(input);
/* Add the transaction to the daily transaction file */
daily_transactions.save((Transaction) refund);
cout << "Buyer refunded successfully." << endl;
break;
}
case _addcredit:
{
AddCredit addcredit = AddCredit(current_user);
/* Process amount of credit to add */
cout << "Enter the amount of credit to add: ";
get_input(cin, input), cout << endl;
addcredit.process_credit(input);
/* Process the username if applicable */
addcredit.process_username(current_accounts);
/* Add the transaction to the daily transaction file */
daily_transactions.save((Transaction) addcredit);
cout << "Credit added successfully." << endl;
break;
}
case _quit:
{
/* If the user is not logged in terminate the program */
if (! current_user.get_status())
{
cout << "Goodbye." << endl;
return EXIT_SUCCESS;
}
else
{
throw Exception(INVALID_TRANSACTION);
}
}
default:
{
throw Exception(INVALID_TRANSACTION);
break;
}
}
}
catch (Exception& e)
{
cerr << e.mesg() << endl;
}
// Flush the stream
cout.flush();
cout << "> ";
}
return EXIT_SUCCESS;
}
void Interactive::exec(const std::string & cmd, const std::string & arg)
{
bool reply_expected = true;
reply_flag = false;
error_flag = false;
boost::shared_ptr<ObjectContext> command_context = m_currentContext.lock();
if (!command_context) {
std::cout << "ERROR: Context free" << std::endl << std::flush;
return;
}
if (cmd == "stat") {
Get g;
send(g);
} else if (cmd == "install") {
size_t space = arg.find(' ');
if (space == std::string::npos || space >= (arg.size() - 1)) {
std::cout << "usage: install <type id> <parent id>"
<< std::endl << std::flush;
} else {
Create c;
c->setFrom(m_accountId);
Anonymous ent;
ent->setId(std::string(arg, 0, space));
ent->setObjtype("class");
ent->setParents(std::list<std::string>(1, std::string(arg, space + 1)));
c->setArgs1(ent);
send(c);
}
reply_expected = false;
} else if (cmd == "look") {
Look l;
if (!arg.empty()) {
Anonymous cmap;
cmap->setId(arg);
l->setArgs1(cmap);
}
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
} else if (cmd == "logout") {
Logout l;
l->setFrom(m_accountId);
if (!arg.empty()) {
Anonymous lmap;
lmap->setId(arg);
l->setArgs1(lmap);
reply_expected = false;
}
send(l);
} else if (cmd == "say") {
Talk t;
Anonymous ent;
ent->setAttr("say", arg);
t->setArgs1(ent);
t->setFrom(m_accountId);
send(t);
} else if (cmd == "help" || cmd == "?") {
reply_expected = false;
help();
} else if (cmd == "query") {
Get g;
if (!arg.empty()) {
Anonymous cmap;
if (::isdigit(arg[0])) {
cmap->setObjtype("obj");
} else {
cmap->setObjtype("meta");
}
cmap->setId(arg);
g->setArgs1(cmap);
}
g->setFrom(m_accountId);
send(g);
} else if (cmd == "reload") {
if (arg.empty()) {
reply_expected = false;
std::cout << "reload: Argument required" << std::endl << std::flush;
} else {
Set s;
Anonymous tmap;
tmap->setObjtype("class");
tmap->setId(arg);
s->setArgs1(tmap);
s->setFrom(m_accountId);
send(s);
}
} else if (cmd == "get") {
Get g;
if (!arg.empty()) {
Anonymous cmap;
if (::isdigit(arg[0])) {
cmap->setObjtype("obj");
} else {
cmap->setObjtype("meta");
}
cmap->setId(arg);
g->setArgs1(cmap);
}
g->setFrom(m_accountId);
send(g);
} else if (cmd == "monitor") {
ClientTask * task = new OperationMonitor;
if (runTask(task, arg) == 0) {
Monitor m;
m->setArgs1(Anonymous());
m->setFrom(m_accountId);
send(m);
}
reply_expected = false;
} else if (cmd == "unmonitor") {
OperationMonitor * om = dynamic_cast<OperationMonitor *>(m_currentTask);
if (om != 0) {
Monitor m;
m->setFrom(m_accountId);
send(m);
reply_expected = false;
SystemTime now;
now.update();
time_t monitor_time = now.seconds() - om->startTime();
std::cout << om->count() << " operations monitored in "
<< monitor_time << " seconds = "
<< om->count() / monitor_time
<< " operations per second"
<< std::endl << std::flush;
endTask();
}
} else if (cmd == "connect") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() != 2) {
std::cout << "usage: connect <hostname> <port>"
<< std::endl << std::flush;
reply_expected = false;
} else {
Anonymous cmap;
cmap->setAttr("hostname", args[0]);
cmap->setAttr("port", strtol(args[1].c_str(), 0, 10));
Connect m;
m->setArgs1(cmap);
// No serialno yet
// FIXME add serialno once Juncture context can handle this
command_context->setFromContext(m);
send(m);
}
} else if (cmd == "add_agent") {
std::string agent_type("creator");
if (!arg.empty()) {
agent_type = arg;
}
Create c;
Anonymous cmap;
cmap->setParents(std::list<std::string>(1, agent_type));
cmap->setName("cycmd agent");
cmap->setObjtype("obj");
c->setArgs1(cmap);
c->setSerialno(newSerialNo());
command_context->setFromContext(c);
send(c);
} else if (cmd == "delete") {
if (arg.empty()) {
std::cout << "Please specify the entity to delete" << std::endl << std::flush;
reply_expected = false;
} else {
Delete del;
Anonymous del_arg;
del_arg->setId(arg);
del->setArgs1(del_arg);
command_context->setFromContext(del);
send(del);
reply_expected = false;
}
} else if (cmd == "find_by_name") {
if (arg.empty()) {
std::cout << "Please specify the name to search for" << std::endl << std::flush;
reply_expected = false;
} else {
Look l;
Anonymous lmap;
lmap->setName(arg);
l->setArgs1(lmap);
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
}
} else if (cmd == "find_by_type") {
if (arg.empty()) {
std::cout << "Please specify the type to search for" << std::endl << std::flush;
reply_expected = false;
} else {
Look l;
Anonymous lmap;
lmap->setParents(std::list<std::string>(1, arg));
l->setArgs1(lmap);
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
}
} else if (cmd == "flush") {
if (arg.empty()) {
// FIXME usage
std::cout << "Please specify the type to flush" << std::endl << std::flush;
reply_expected = false;
} else {
ClientTask * task = new Flusher(command_context);
runTask(task, arg);
reply_expected = false;
}
} else if (cmd == "cancel") {
if (endTask() != 0) {
std::cout << "No task currently running" << std::endl << std::flush;
}
} else if (cmd == "dump") {
if (command_context->repr() != "avatar") {
std::cout << "You must have an agent in the world in order to dump the world." << std::endl << std::flush;
} else {
//Extract the avatar id by "misusing" the setFromContext method
Operation op;
command_context->setFromContext(op);
ClientTask * task = new EntityExporter(m_accountId, op->getFrom());
runTask(task, "world.xml");
reply_expected = false;
}
} else if (cmd == "restore") {
if (command_context->repr() != "avatar") {
std::cout << "You must have an agent in the world in order to dump the world." << std::endl << std::flush;
} else {
//Extract the avatar id by "misusing" the setFromContext method
Operation op;
command_context->setFromContext(op);
ClientTask * task = new EntityImporter(m_accountId, op->getFrom());
runTask(task, "world.xml");
reply_expected = false;
}
} else if (cmd == "create") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() < 1) {
std::cout << "usage: create <type> <params> ... "
<< std::endl << std::flush;
} else {
Anonymous cmap;
cmap->setParents(std::list<std::string>(1, args[0]));
cmap->setObjtype("obj");
Create c;
c->setArgs1(cmap);
c->setSerialno(newSerialNo());
command_context->setFromContext(c);
send(c);
}
reply_expected = false;
} else if (cmd == "login") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() != 2) {
std::cout << "usage: login <username> <password>"
<< std::endl << std::flush;
reply_expected = false;
} else {
Anonymous cmap;
cmap->setAttr("username", args[0]);
cmap->setAttr("password", args[1]);
Login m;
m->setArgs1(cmap);
m->setSerialno(newSerialNo());
command_context->setFromContext(m);
send(m);
}
} else {
reply_expected = false;
std::cout << cmd << ": Command not known" << std::endl << std::flush;
}
if (!reply_expected) {
updatePrompt();
return;
}
// Wait for reply
time_t wait_start_time = time(NULL);
while (!reply_flag) {
if (time(NULL) - wait_start_time > 5) {
std::cout << cmd << ": No reply from server" << std::endl << std::flush;
return;
}
if (select(false) != 0) {
return;
}
}
}
/// \brief Teleport an entity to the connected peer
///
/// @param ent The entity to be teleported
/// @return Returns 0 on success and -1 on failure
int Peer::teleportEntity(const Entity * ent)
{
if (m_state != PEER_AUTHENTICATED) {
log(ERROR, "Peer not authenticated yet.");
return -1;
}
long iid = ent->getIntId();
if (m_teleports.find(iid) != m_teleports.end()) {
log(INFO, "Transfer of this entity already in progress");
return -1;
}
struct timeval timeVal;
gettimeofday(&timeVal, NULL);
time_t teleport_time = timeVal.tv_sec;
// Add a teleport state object to identify this teleport request
TeleportState * s = new TeleportState(teleport_time);
if (s == NULL) {
log(ERROR, "Unable to allocate teleport state object");
return -1;
}
// Check if the entity has a mind
const Character * chr = dynamic_cast<const Character *>(ent);
ExternalMind * mind = 0;
if (chr != 0 && chr->m_externalMind != 0) {
mind = dynamic_cast<ExternalMind*>(chr->m_externalMind);
}
Atlas::Objects::Entity::Anonymous atlas_repr;
ent->addToEntity(atlas_repr);
Create op;
op->setFrom(m_accountId);
op->setSerialno(iid);
op->setArgs1(atlas_repr);
if (mind != 0 && mind->isConnected()) {
// Entities with a mind require an additional one-time possess key that
// is used by the client to authenticate a teleport on the destination
// peer
std::string key;
log(INFO, "Entity has a mind. Generating random key");
// FIXME non-random, plus potetial timing attack.
WFMath::MTRand generator;
for(int i=0;i<32;i++) {
char ch = (char)((int)'a' + generator.rand(25));
key += ch;
}
s->setKey(key);
// Add an additional possess key argument
log(INFO, String::compose("Adding possess key %1 to Create op", key));
Anonymous key_arg;
key_arg->setAttr("possess_key", key);
std::vector<Root> & create_args = op->modifyArgs();
create_args.push_back(key_arg);
}
m_commClient.send(op);
log(INFO, "Sent Create op to peer");
// Set it as validated and add to the list of teleports
s->setRequested();
m_teleports[iid] = s;
log(INFO, "Added new teleport state");
return 0;
}
int main(int argc, char* argv[])
{
Create app;
return app.main(argc, argv);
}
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
}
int main()
{
// WorldRouter world;
// Entity & e = world.m_gameWorld;
ServerRouting server(*(BaseWorld*)0, "noruleset", "unittesting",
"1", 1, "2", 2);
CommServer commServer(server);
TestCommClient * tcc = new TestCommClient(commServer);
TestConnection * tc = new TestConnection(*tcc, server, "addr", "3", 3);
Account * ac = tc->testAddAccount("bob", "foo");
assert(ac != 0);
ac = tc->testRemoveAccount(ac);
assert(ac != 0);
tc->removeObject(ac);
assert(tc->numObjects() == 0);
{
Create op;
OpVector res;
tc->operation(op, res);
op->setArgs1(Root());
tc->operation(op, res);
restricted_flag = true;
tc->operation(op, res);
restricted_flag = false;
Anonymous op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("jim");
// Legacy op
tc->operation(op, res);
op_arg->setAttr("username", 1);
// Malformed username
tc->operation(op, res);
op_arg->setAttr("username", "jim");
// username, no password
tc->operation(op, res);
op_arg->setAttr("password", "");
// zero length password
tc->operation(op, res);
op_arg->setAttr("username", "");
op_arg->setAttr("password", "foo");
// zero length username
tc->operation(op, res);
op_arg->setAttr("username", "jim");
// valid username and password
tc->operation(op, res);
assert(tc->numObjects() != 0);
}
{
Login op;
OpVector res;
tc->operation(op, res);
op->setArgs1(Root());
tc->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("bob");
tc->operation(op, res);
op_arg->setAttr("username", 1);
tc->operation(op, res);
op_arg->setAttr("username", "");
tc->operation(op, res);
op_arg->setAttr("username", "bob");
tc->operation(op, res);
op_arg->setAttr("password", "foo");
tc->operation(op, res);
tc->operation(op, res);
}
{
Get op;
OpVector res;
tc->operation(op, res);
Root op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("1");
tc->operation(op, res);
op_arg->setId("game_entity");
tc->operation(op, res);
}
{
Logout op;
OpVector res;
tc->operation(op, res);
op->setSerialno(24);
tc->operation(op, res);
Root op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("-1");
tc->operation(op, res);
op_arg->setId("23");
tc->operation(op, res);
// How to determine the real ID?
const RouterMap rm = tc->getObjects();
RouterMap::const_iterator I = rm.begin();
for (;I != rm.end(); ++I) {
std::string object_id = String::compose("%1", I->first);
std::cout << "ID: " << object_id << std::endl;
op_arg->setId(object_id);
tc->operation(op, res);
}
}
delete tc;
}
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 SpawnerProperty::createNewEntity(LocatedEntity * e, const Operation & op,
OpVector & res, const std::string& locId)
{
Anonymous create_arg;
if (!m_entity.empty()) {
create_arg = smart_dynamic_cast<Anonymous>(
Factories::instance()->createObject(m_entity));
if (!create_arg.isValid()) {
log(ERROR,
"Could not parse 'entity' data on spawner into Entity instance.");
return;
}
} else {
create_arg->setParents(std::list<std::string>(1, m_type));
}
create_arg->setLoc(locId);
WFMath::MTRand& rand = WFMath::MTRand::instance;
if (m_mode_external) {
if (!e->m_location.pos().isValid()) {
log(ERROR,
"Tried to spawn entity for which parent has no valid position.");
return;
}
//randomize position and rotation
float angle = rand.randf(WFMath::numeric_constants<float>::pi() * 2);
//place it between 0 and 2 meters away
float distance = rand.randf(2.0f);
//if we're solid we should make sure it's not within our own radius
if (e->m_location.isSolid() && e->m_location.bBox().isValid()) {
distance += e->m_location.radius();
}
//and finally make sure that it's not beyond the radius for checking
if (m_radius != 0.0f) {
distance = std::min(m_radius, distance);
}
float x = (distance * std::cos(angle));
float y = (distance * std::sin(angle));
::addToEntity(
WFMath::Point<3>(e->m_location.pos()).shift(
WFMath::Vector<3>(x, y, 0)), create_arg->modifyPos());
} else {
//If it's an internal spawner, spawn anywhere within the bounding box.
const BBox bbox = e->m_location.m_bBox;
if (bbox.isValid()) {
float x = rand.rand(bbox.highCorner().x() - bbox.lowCorner().x())
+ bbox.lowCorner().x();
float y = rand.rand(bbox.highCorner().y() - bbox.lowCorner().y())
+ bbox.lowCorner().y();
::addToEntity(WFMath::Point<3>(x, y, 0), create_arg->modifyPos());
} else {
::addToEntity(WFMath::Point<3>::ZERO(), create_arg->modifyPos());
}
}
float rotation = rand.randf(WFMath::numeric_constants<float>::pi() * 2);
WFMath::Quaternion orientation(WFMath::Vector<3>(0, 0, 1), rotation);
create_arg->setAttr("orientation", orientation.toAtlas());
Create create;
create->setTo(e->m_location.m_loc->getId());
create->setArgs1(create_arg);
res.push_back(create);
debug(log(NOTICE, compose("Spawner belonging to entity %1 creating new"
" entity of type %2", e->getId(), m_type))
;);
int main()
{
database_flag = false;
(void)new Domain;
WorldRouter world;
Entity & e = world.m_gameWorld;
ServerRouting server(world, "noruleset", "unittesting",
"1", 1, "2", 2);
CommServer commServer(server);
TestCommClient * tc = new TestCommClient(commServer);
Connection * c = new Connection(*tc, server, "addr", "3", 3);
TestAccount * ac = new TestAccount(c, "user", "password", "4", 4);
Entity * chr;
{
chr = new Entity("5", 5);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
chr->destroy();
}
{
chr = new Character("6", 6);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
chr->destroy();
}
{
chr = new Character("7", 7);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
}
{
Anonymous new_char;
Entity * chr = ac->testAddNewCharacter("thing", new_char,
RootEntity());
assert(chr != 0);
}
ac->getType();
{
MapType emap;
ac->addToMessage(emap);
}
{
RootEntity ent;
ac->addToEntity(ent);
}
{
Create op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op_arg->setParents(std::list<std::string>(1, "game_entity"));
ac->operation(op, res);
op_arg->setName("Bob");
ac->operation(op, res);
}
{
Get op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
Imaginary op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setLoc("2");
ac->operation(op, res);
}
{
Look op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setId("1");
ac->operation(op, res);
op_arg->setId(chr->getId());
ac->operation(op, res);
}
{
Set op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setId("1");
ac->operation(op, res);
op_arg->setId(chr->getId());
ac->operation(op, res);
op_arg->setAttr("guise", "foo");
ac->operation(op, res);
op_arg->setAttr("height", 3.0);
ac->operation(op, res);
BBox newBox(WFMath::Point<3>(-0.5, -0.5, 0.0),
WFMath::Point<3>(-0.5, -0.5, 2.0));
chr->m_location.setBBox(newBox);
op_arg->setAttr("height", 3.0);
ac->operation(op, res);
op_arg->setAttr("tasks", ListType());
ac->operation(op, res);
}
{
Talk op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
op_arg->setLoc("1");
ac->operation(op, res);
}
{
Logout op;
OpVector res;
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
// Move has no meaning
Move op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
Entity e("7", 7);
int ret = ac->connectCharacter(&e);
assert(ret == -1);
}
{
Character e("8", 8);
int ret = ac->connectCharacter(&e);
assert(ret == 0);
}
delete ac;
return 0;
}
