void BaseMindMapEntityintegration::test_MemMapreadEntity_changeloc()
{
MemEntity * tlve = new MemEntity("0", 0);
tlve->m_contains = new LocatedEntitySet;
m_mind->m_map.m_entities[0] = tlve;
MemEntity * e2 = new MemEntity("2", 2);
e2->m_contains = new LocatedEntitySet;
e2->m_location.m_loc = tlve;
tlve->m_contains->insert(e2);
m_mind->m_map.m_entities[2] = e2;
MemEntity * e3 = new MemEntity("3", 3);
e3->m_contains = new LocatedEntitySet;
e3->m_location.m_loc = e2;
e2->m_contains->insert(e3);
m_mind->m_map.m_entities[3] = e3;
ASSERT_EQUAL(m_mind->m_map.m_entities.size(), 4u);
Anonymous data;
data->setLoc(tlve->getId());
// Read in entity data that changes the LOC of e3 from e2 to TLVE
m_mind->m_map.readEntity(e3, data);
ASSERT_EQUAL(e3->m_location.m_loc, tlve)
ASSERT_TRUE(e2->m_contains->find(e3) == e2->m_contains->end());
ASSERT_TRUE(tlve->m_contains->find(e3) != tlve->m_contains->end());
}
void Admintest::test_SetOperation_obj_IG()
{
Account_SetOperation_called = 0;
long cid = m_id_counter++;
Entity * c = new Entity(compose("%1", cid), cid);
m_account->m_charactersDict.insert(std::make_pair(cid, c));
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId(c->getId());
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(Account_SetOperation_called, m_account);
// The operation returned would have come from Account::SetOperation
// but that is stubbed out
ASSERT_EQUAL(res.size(), 0u);
delete c;
}
void Admintest::test_LogoutOperation_other_but_unconnected()
{
Account_LogoutOperation_called = 0;
m_account->m_connection = 0;
long cid = m_id_counter++;
std::string cid_str = String::compose("%1", cid);
Account * ac2 = new Admin(0,
"f3332c00-5d2b-45c1-8cf4-3429bdf2845f",
"c0e095f0-575c-477c-bafd-2055d6958d4d",
cid_str, cid);
m_server->addObject(ac2);
ASSERT_EQUAL(m_server->getObject(cid_str), ac2);
Atlas::Objects::Operation::Logout op;
OpVector res;
Anonymous arg;
arg->setId(cid_str);
op->setArgs1(arg);
m_account->LogoutOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
ASSERT_NULL(Account_LogoutOperation_called);
delete ac2;
}
void World::LookOperation(const Operation & op, OpVector & res)
{
// We must be the top level entity
assert(m_location.m_parent == nullptr);
// We must contains something, or where the hell did the look come from?
assert(m_contains != nullptr);
//The top level entity is a little special, since its properties can be inspected by all entities, although it's children can not.
//First check if there's a movement domain. If so we'll handle Look ops just like usually. However, if not we'll send the properties sans the "contains" property.
auto from = BaseWorld::instance().getEntity(op->getFrom());
if (!from) {
log(ERROR, String::compose("Look op has invalid from %1. %2", op->getFrom(), describeEntity()));
return;
}
Domain* domain = nullptr;
if (m_location.m_parent) {
domain = m_location.m_parent->getDomain();
}
if (domain) {
generateSightOp(*from, op, res);
} else {
Sight s;
Anonymous sarg;
addToEntity(sarg);
//Hide all contents of the root entity.
sarg->removeAttr("contains");
s->setArgs1(sarg);
s->setTo(op->getFrom());
res.push_back(s);
}
}
void Admintest::test_GetOperation_obj_IG()
{
long cid = m_id_counter++;
std::string cid_str = String::compose("%1", cid);
Entity * to = new Entity(cid_str, cid);
m_server->m_world.addEntity(to);
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId(cid_str);
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
const Operation & reply = res.front();
ASSERT_EQUAL(reply->getClassNo(),
Atlas::Objects::Operation::INFO_NO);
ASSERT_EQUAL(reply->getArgs().size(), 1u);
const Root & reply_arg = reply->getArgs().front();
ASSERT_TRUE(!reply_arg->isDefaultId());
ASSERT_EQUAL(reply_arg->getId(), to->getId());
delete to;
}
void Admintest::test_GetOperation_rule_found()
{
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("class");
arg->setId("root");
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
const Operation & reply = res.front();
ASSERT_EQUAL(reply->getClassNo(),
Atlas::Objects::Operation::INFO_NO);
ASSERT_EQUAL(reply->getArgs().size(), 1u);
const Root & reply_arg = reply->getArgs().front();
ASSERT_TRUE(!reply_arg->isDefaultId());
ASSERT_EQUAL(reply_arg->getId(), "root");
}
bool EntityImporterBase::getRule(const std::string & id, OpVector & res)
{
auto I = mPersistedRules.find(id);
if (I == mPersistedRules.end()) {
S_LOG_WARNING("Could not find rule with id " << id << ".");
return false;
}
auto definition = I->second;
m_state = RULE_WALKING;
std::list<std::string> children;
extractChildren(definition, children);
RuleStackEntry entry = { id, definition, children };
mRuleStack.push_back(entry);
Get get;
Anonymous arg;
arg->setId(id);
get->setArgs1(arg);
// get->setObjtype("op");
get->setSerialno(newSerialNumber());
res.push_back(get);
Anonymous get_arg;
get_arg->setId(id);
get_arg->setObjtype("obj");
return true;
}
// check() empty description
void PropertyRuleHandlertest::test_check_fail()
{
Anonymous description;
description->setParents(std::list<std::string>(1, "foo"));
int ret = rh->check(description);
assert(ret == -1);
}
void Admintest::test_addToEntity_tree()
{
Anonymous data;
m_account->addToEntity(data);
ASSERT_TRUE(data->hasAttr("character_types"));
ASSERT_EQUAL(data->getAttr("character_types"), ListType());
}
// check() description with op_definition objtype
void PropertyRuleHandlertest::test_check_pass()
{
Anonymous description;
description->setObjtype("type");
description->setParents(std::list<std::string>(1, "foo"));
int ret = rh->check(description);
assert(ret == 0);
}
void InventoryDomain::processVisibilityForMovedEntity(const LocatedEntity& moved_entity, const Location& old_loc, OpVector & res)
{
if (m_entity.m_contains) {
std::vector<LocatedEntity*> visibleEntities;
std::unordered_set<int> outfitted;
LocatedEntity* rightHandWieldedEntity = nullptr;
const OutfitProperty* outfitProperty = m_entity.getPropertyClass<OutfitProperty>("outfit");
if (outfitProperty) {
for (auto& entry : outfitProperty->data()) {
outfitted.insert(entry.second->getIntId());
}
}
const EntityProperty* rightHandWieldProperty = m_entity.getPropertyClass<EntityProperty>("right_hand_wield");
if (rightHandWieldProperty) {
rightHandWieldedEntity = rightHandWieldProperty->data().get();
}
for (auto childEntity : *m_entity.m_contains) {
if (childEntity == rightHandWieldedEntity) {
visibleEntities.push_back(childEntity);
} else if (outfitted.find(childEntity->getIntId()) != outfitted.end()) {
visibleEntities.push_back(childEntity);
}
}
std::set<std::string> newVisibleEntities;
for (auto visibleEntity : visibleEntities) {
if (m_lastVisibleEntities.find(visibleEntity->getId()) == m_lastVisibleEntities.end()) {
Anonymous ent;
ent->setId(visibleEntity->getId());
ent->setStamp(visibleEntity->getSeq());
Appearance d;
d->setArgs1(ent);
res.push_back(d);
} else {
m_lastVisibleEntities.erase(visibleEntity->getId());
}
newVisibleEntities.insert(visibleEntity->getId());
}
for (auto entityId : m_lastVisibleEntities) {
Anonymous ent;
ent->setId(entityId);
Disappearance d;
d->setArgs1(ent);
res.push_back(d);
}
m_lastVisibleEntities = std::move(newVisibleEntities);
}
}
void PropertyRuleHandlertest::test_install_noparent()
{
Anonymous description;
description->setObjtype("type");
std::string dependent, reason;
int ret = rh->install("new_int_type", "int", description, dependent, reason);
assert(ret == 0);
}
void CreatorClient::del(const std::string & id)
{
Delete op;
Anonymous ent;
ent->setId(id);
op->setArgs1(ent);
op->setFrom(getId());
op->setTo(id);
return send(op);
}
LocatedEntity * CharacterClient::look(const std::string & id)
{
Look op;
if (!id.empty()) {
Anonymous ent;
ent->setId(id);
op->setArgs1(ent);
}
op->setFrom(getId());
return sendLook(op);
}
void Playertest::test_addToEntity()
{
Player::playableTypes.insert("settler");
Anonymous data;
m_account->addToEntity(data);
ASSERT_TRUE(data->hasAttr("character_types"));
ASSERT_EQUAL(data->getAttr("character_types"), ListType(1, "settler"));
}
void RuleTraversalTask::getRule(const std::string & id, OpVector & res)
{
Get get;
Anonymous arg;
arg->setId(id);
get->setArgs1(arg);
get->setObjtype("op");
get->setSerialno(newSerialNo());
mSerial = get->getSerialno();
res.push_back(get);
}
static void lookAtEntity(ClientConnection& con, const std::string & eid,
const std::string & loc)
{
Look l;
l->setFrom(con.getCharacterId());
Anonymous lookEnt;
lookEnt->setId(eid);
l->setArgs1(lookEnt);
int serial = con.send(l);
verbose( std::cout << "Waiting for In-game look response on connection "
<< con.getAccount() << std::endl << std::flush; );
void World::clearWorld(OpVector & res) {
log(INFO, "Clearing world; deleting all entities.");
OpVector ignoredRes;
auto& baseWorld = BaseWorld::instance();
if (m_contains) {
while (!m_contains->empty()) {
auto& entity = *m_contains->begin();
if (entity->isPerceptive()) {
//Send a sight of a delete op to the entity so that it knows it has been deleted.
Delete delOp;
delOp->setTo(entity->getId());
Anonymous delArg;
delArg->setId(entity->getId());
delOp->setArgs1(delArg);
Sight sToEntity;
sToEntity->setArgs1(delOp);
sToEntity->setTo(entity->getId());
entity->operation(sToEntity, ignoredRes);
}
baseWorld.delEntity(entity.get());
}
}
//Remove all properties except for "id"
auto propIter = m_properties.begin();
while(propIter != m_properties.end())
{
if (propIter->first != "id") {
auto prop = propIter->second;
prop->remove(this, propIter->first);
delete prop;
m_properties.erase(propIter++);
} else {
++propIter;
}
}
CalendarProperty* calProp = new CalendarProperty();
calProp->install(this, "calendar");
m_properties["calendar"] = calProp;
delete m_contains;
m_contains = nullptr;
log(INFO, "World cleared of all entities.");
}
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);
}
}
void PropertyRuleHandlertest::test_install_exists()
{
PropertyManager::instance()->installFactory("existing_int_type",
Root(),
new PropertyFactory<Property<int>>);
Anonymous description;
description->setObjtype("type");
std::string dependent, reason;
int ret = rh->install("existing_int_type", "int", description, dependent, reason);
assert(ret == 0);
}
void Juncture::LoginOperation(const Operation & op, OpVector & res)
{
log(INFO, "Juncture got login");
const std::vector<Root> & args = op->getArgs();
if (args.empty()) {
error(op, "No argument to connect op", res, getId());
return;
}
const Root & arg = args.front();
Element username_attr;
if (arg->copyAttr("username", username_attr) != 0 || !username_attr.isString()) {
error(op, "Argument to connect op has no username", res, getId());
return;
}
const std::string & username = username_attr.String();
Element password_attr;
if (arg->copyAttr("password", password_attr) != 0 || !password_attr.isString()) {
error(op, "Argument to connect op has no password", res, getId());
return;
}
const std::string & password = password_attr.String();
if (m_peer == 0) {
error(op, "Juncture not connected", res, getId());
return;
}
assert(m_socket == 0);
if (m_peer->getAuthState() != PEER_INIT) {
error(op, "Juncture not ready", res, getId());
return;
}
Anonymous account;
account->setAttr("username", username);
account->setAttr("password", password);
Login l;
l->setArgs1(account);
if (!op->isDefaultSerialno()) {
l->setSerialno(op->getSerialno());
}
// Send the login op
m_peer->send(l);
m_peer->setAuthState(PEER_AUTHENTICATING);
}
void Admintest::test_SetOperation_no_id()
{
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Playertest::test_characterError_playable()
{
Player::playableTypes.insert("settler");
Atlas::Objects::Operation::Create op;
Anonymous description;
description->setName("13e45264-e512-411b-9f8a-2e5cb6327c87");
description->setParents(std::list<std::string>(1, "settler"));
OpVector res;
int result = m_account->characterError(op, description, res);
ASSERT_EQUAL(result, 0);
ASSERT_EQUAL(res.size(), 0u);
}
void Admintest::test_GetOperation_unknown()
{
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("unknownobjtype");
arg->setId("1741");
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Playertest::test_characterError_no_name()
{
Player::playableTypes.insert("settler");
Atlas::Objects::Operation::Create op;
Anonymous description;
description->setParents(std::list<std::string>(1, "settler"));
OpVector res;
int result = m_account->characterError(op, description, res);
ASSERT_NOT_EQUAL(result, 0);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Admintest::test_GetOperation_obj_unconnected()
{
m_account->m_connection = 0;
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId("9287");
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 0u);
}
void Admintest::test_SetOperation_unknown()
{
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("unimportant_unknown_string");
arg->setId("root");
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void EntityBuildertest::test_sequence2()
{
Anonymous attributes;
assert(EntityBuilder::instance() != 0);
// Create a normal Entity
LocatedEntity * test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes, BaseWorld::instance());
assert(test_ent != 0);
// Create an entity specifying an attrbute
attributes->setAttr("funky", "true");
test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes, BaseWorld::instance());
assert(test_ent != 0);
// Create an entity causing VELOCITY to be set
attributes = Anonymous();
attributes->setVelocity(std::vector<double>(3, 1.5));
LocatedEntity_merge_action = SET_VELOCITY;
test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes, BaseWorld::instance());
assert(test_ent != 0);
LocatedEntity_merge_action = DO_NOTHING;
// Create an entity causing VELOCITY to be set for no obvious reason
attributes = Anonymous();
LocatedEntity_merge_action = SET_VELOCITY;
test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes, BaseWorld::instance());
assert(test_ent != 0);
LocatedEntity_merge_action = DO_NOTHING;
// Create an entity specifying a LOC
attributes = Anonymous();
attributes->setLoc("1");
test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes, BaseWorld::instance());
assert(test_ent != 0);
}
void Admintest::test_LogoutOperation_unknown()
{
long cid = m_id_counter++;
Operation op;
OpVector res;
Anonymous arg;
arg->setId(String::compose("%1", cid));
op->setArgs1(arg);
m_account->LogoutOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Admintest::test_LogoutOperation_self()
{
Account_LogoutOperation_called = 0;
Operation op;
OpVector res;
Anonymous arg;
arg->setId(m_account->getId());
op->setArgs1(arg);
m_account->LogoutOperation(op, res);
ASSERT_EQUAL(res.size(), 0u);
ASSERT_EQUAL(Account_LogoutOperation_called, m_account);
}
