void EntityImporterBase::operation(const Operation & op)
{
//std::cout << "Got op ==================" << std::endl;
//debug_dump(op, std::cout);
if (m_state == CANCEL) {
m_state = CANCELLED;
return;
}
if (m_state == CANCELLED) {
return;
}
OpVector res;
if (op->getClassNo() == Atlas::Objects::Operation::INFO_NO) {
infoArrived(op, res);
} else if (op->getClassNo() == Atlas::Objects::Operation::ERROR_NO) {
errorArrived(op, res);
} else if (op->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
sightArrived(op, res);
}
for (auto& resOp : res) {
sendOperation(resOp);
}
}
HandlerResult TerrainModProperty::operation(LocatedEntity * ent,
const Operation & op,
OpVector & res)
{
if (op->getClassNo() == Atlas::Objects::Operation::DELETE_NO) {
return delete_handler(ent, op, res);
} else if (op->getClassNo() == Atlas::Objects::Operation::MOVE_NO) {
return move_handler(ent, op, res);
}
return OPERATION_IGNORED;
}
void TrustedConnectionCreatorintegration::test_external_op_puppet()
{
// Dispatching a Talk external op from the creator, to the creator should
// result in it being passed directly to the normal op dispatch,
// shortcutting the world.
m_creator->m_externalMind = new ExternalMind(*m_creator);
m_creator->m_externalMind->linkUp(m_connection);
Entity * other = new Entity(compose("%1", m_id_counter), m_id_counter++);
other->setType(m_creatorType);
m_server->m_world.addEntity(other);
Atlas::Objects::Operation::Talk op;
op->setFrom(m_creator->getId());
op->setTo(other->getId());
m_connection->externalOperation(op, *m_connection);
// Operation should be via world dispatch, as if it was from the Entity
// we are puppeting.
ASSERT_TRUE(m_BaseWorld_message_called.isValid());
ASSERT_EQUAL(m_BaseWorld_message_called->getClassNo(),
Atlas::Objects::Operation::TALK_NO);
ASSERT_TRUE(!m_BaseWorld_message_called->isDefaultTo());
ASSERT_EQUAL(m_BaseWorld_message_called->getTo(), other->getId());
ASSERT_NOT_NULL(m_BaseWorld_message_called_from);
ASSERT_EQUAL(m_BaseWorld_message_called_from, other);
}
void Juncture::OtherOperation(const Operation & op, OpVector & res)
{
const int op_type = op->getClassNo();
if (op_type == Atlas::Objects::Operation::CONNECT_NO) {
return customConnectOperation(op, res);
}
}
void Admin::OtherOperation(const Operation & op, OpVector & res)
{
const int op_type = op->getClassNo();
if (op_type == Atlas::Objects::Operation::MONITOR_NO) {
return customMonitorOperation(op, res);
}
}
void Entity::operation(const Operation & op, OpVector & res)
{
if (m_script != 0 &&
m_script->operation(op->getParents().front(), op, res) != 0) {
return;
}
auto J = m_delegates.equal_range(op->getClassNo());
HandlerResult hr = OPERATION_IGNORED;
for (;J.first != J.second; ++J.first) {
HandlerResult hr_call = callDelegate(J.first->second, op, res);
//We'll record the most blocking of the different results only.
if (hr != OPERATION_BLOCKED) {
if (hr_call != OPERATION_IGNORED) {
hr = hr_call;
}
}
// How to access the property? We need a non-const pointer to call
// operation, but to get this easily we need to force instantiation
// from the type dict, making properties way less efficient.
// Making the operation() method const strongly limits the usefulness
// of delegates, but if we fetch the pointer the hard way, we then
// require the method to handle instantiation on demand.
//
// Can we make a clean way to handle the property in the general case
// handle instantiation itself? Making it responsible for copying
// itself on instantiation would be faster than the
// get/set/PropertyManager currently required in in modProperty.
}
//If the operation was blocked we shouldn't send it on to the entity.
if (hr == OPERATION_BLOCKED) {
return;
}
return callOperation(op, res);
}
void EntityImporterBase::operation(const Operation & op)
{
if (m_state == CANCEL) {
m_state = CANCELLED;
return;
}
if (m_state == CANCELLED) {
return;
}
OpVector res;
if (op->getClassNo() == Atlas::Objects::Operation::INFO_NO) {
infoArrived(op, res);
} else if (op->getClassNo() == Atlas::Objects::Operation::ERROR_NO) {
errorArrived(op, res);
} else if (op->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
sightArrived(op, res);
}
for (auto& op : res) {
sendOperation(op);
}
}
void Juncture::operation(const Operation & op, OpVector & res)
{
const OpNo op_no = op->getClassNo();
switch (op_no) {
case Atlas::Objects::Operation::LOGIN_NO:
LoginOperation(op, res);
break;
case OP_INVALID:
break;
default:
OtherOperation(op, res);
break;
}
}
void WaitForDeletionTask::operation(const Operation & op, OpVector & res)
{
if (op->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
if (!op->getArgs().empty()) {
auto& innerOp = op->getArgs().front();
if (innerOp->getClassNo() == Atlas::Objects::Operation::DELETE_NO) {
auto deleteOp = Atlas::Objects::smart_dynamic_cast<Operation>(innerOp);
if (!deleteOp->getArgs().empty()) {
auto args = deleteOp->getArgs().front();
if (args->getId() == m_entityId) {
m_complete = true;
}
}
}
}
}
}
void RuleTraversalTask::operation(const Operation & op, OpVector & res)
{
if (!op->isDefaultRefno() && op->getRefno() == mSerial) {
if (op->getClassNo() == Atlas::Objects::Operation::INFO_NO) {
if (!op->getArgs().empty()) {
const auto& arg = op->getArgs().front();
if (arg.isValid()) {
bool result = mVisitor(arg);
if (result) {
Element childrenElement;
if (arg->copyAttr("children", childrenElement) == 0 && childrenElement.isList() && !childrenElement.List().empty()) {
const ListType& childrenList = childrenElement.asList();
mStack.emplace_back();
for (auto& childElement : childrenList) {
if (childElement.isString()) {
mStack.back().children.push_back(childElement.String());
}
}
mStack.back().currentChildIterator = mStack.back().children.begin();
getRule(*mStack.back().currentChildIterator, res);
return;
} else {
while (!mStack.empty()) {
StackEntry& stackEntry = mStack.back();
stackEntry.currentChildIterator++;
if (stackEntry.currentChildIterator == stackEntry.children.end()) {
mStack.pop_back();
} else {
getRule(*stackEntry.currentChildIterator, res);
return;
}
}
m_complete = true;
}
} else {
m_complete = true;
}
}
}
}
}
}
/// \brief Execute an operation sent by a connected peer
///
/// \param op The operation to be executed
/// \param res The result set of replies
void Peer::operation(const Operation &op, OpVector &res)
{
if (!op->isDefaultRefno()) {
replied.emit(op);
}
const OpNo op_no = op->getClassNo();
switch (op_no) {
case Atlas::Objects::Operation::INFO_NO:
{
// If we receive an Info op while we are not yet authenticated, it
// can only be the result of an authentication request.
if (m_state == PEER_AUTHENTICATING) {
const std::vector<Root> & args = op->getArgs();
if (args.empty()) {
return;
}
const Root & arg = args.front();
if (!arg->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
return;
}
// Response to a Login op
m_accountId = arg->getId();
if (!arg->getParents().empty()) {
m_accountType = arg->getParents().front();
}
m_state = PEER_AUTHENTICATED;
} else if (m_state == PEER_AUTHENTICATED) {
// If we received an Info op while authenticated, it is a
// response to a teleport request.
peerTeleportResponse(op, res);
}
}
break;
case Atlas::Objects::Operation::ERROR_NO:
{
m_state = PEER_FAILED;
}
break;
}
}
void ConnectionCharacterintegration::test_external_op()
{
// Dispatching a Talk external op from the character should result in
// it being passed on to the world.
m_character->linkExternal(m_connection);
Atlas::Objects::Operation::Talk op;
op->setFrom(m_character->getId());
m_connection->externalOperation(op, *m_connection);
// BaseWorld::message should have been called from Enitty::sendWorld
// with the Talk operation, modified to have TO set to the character.
ASSERT_TRUE(m_BaseWorld_message_called.isValid());
ASSERT_EQUAL(m_BaseWorld_message_called->getClassNo(),
Atlas::Objects::Operation::TALK_NO);
ASSERT_TRUE(!m_BaseWorld_message_called->isDefaultTo());
ASSERT_EQUAL(m_BaseWorld_message_called->getTo(), m_character->getId());
ASSERT_NOT_NULL(m_BaseWorld_message_called_from);
ASSERT_EQUAL(m_BaseWorld_message_called_from, m_character);
}
void ConnectionCharacterintegration::test_connect_up()
{
// Dispatching an external op from the character should cause it to
// get connected up with an external mind
RootOperation op;
op->setFrom(m_character->getId());
ASSERT_NULL(m_character->m_externalMind);
m_connection->externalOperation(op, *m_connection);
ASSERT_NOT_NULL(m_character->m_externalMind);
ExternalMind * em =
dynamic_cast<ExternalMind*>(m_character->m_externalMind);
ASSERT_NOT_NULL(em);
ASSERT_TRUE(em->isLinked());
ASSERT_TRUE(em->isLinkedTo(m_connection));
ASSERT_TRUE(m_Link_send_sent.isValid());
ASSERT_EQUAL(m_Link_send_sent->getClassNo(),
Atlas::Objects::Operation::INFO_NO);
ASSERT_EQUAL(m_logEvent_logged, TAKE_CHAR);
}
void TrustedConnectionCreatorintegration::test_external_op_override()
{
// Dispatching a Talk external op from the creator should result in
// it being passed on to the world, exactly as if this was a Character
// except that we assume that Creator was set up linked.
m_creator->m_externalMind = new ExternalMind(*m_creator);
m_creator->m_externalMind->linkUp(m_connection);
Atlas::Objects::Operation::Talk op;
op->setFrom(m_creator->getId());
op->setTo(m_creator->getId());
m_connection->externalOperation(op, *m_connection);
// The operation should have been passed to Entity::callOperation for
// dispatch, completely unfiltered.
ASSERT_TRUE(m_Entity_callOperation_called.isValid());
ASSERT_EQUAL(m_Entity_callOperation_called->getClassNo(),
Atlas::Objects::Operation::TALK_NO);
ASSERT_TRUE(!m_Entity_callOperation_called->isDefaultTo());
ASSERT_EQUAL(m_Entity_callOperation_called->getTo(), m_creator->getId());
}
void TrustedConnectionCreatorintegration::test_external_op()
{
// Dispatching a Talk external op from the creator should result in
// it being passed on to the world, exactly as if this was a Character
// except that we assume that Creator was set up linked.
m_creator->m_externalMind = new ExternalMind(*m_creator);
m_creator->m_externalMind->linkUp(m_connection);
Atlas::Objects::Operation::Talk op;
op->setFrom(m_creator->getId());
m_connection->externalOperation(op, *m_connection);
// BaseWorld::message should have been called from Enitty::sendWorld
// with the Talk operation, modified to have TO set to the character.
ASSERT_TRUE(m_BaseWorld_message_called.isValid());
ASSERT_EQUAL(m_BaseWorld_message_called->getClassNo(),
Atlas::Objects::Operation::TALK_NO);
ASSERT_TRUE(!m_BaseWorld_message_called->isDefaultTo());
ASSERT_EQUAL(m_BaseWorld_message_called->getTo(), m_creator->getId());
ASSERT_NOT_NULL(m_BaseWorld_message_called_from);
ASSERT_EQUAL(m_BaseWorld_message_called_from, m_creator);
}
void Link::send(const Operation & op) const
{
stub_link_send_op = op->getClassNo();
++stub_link_send_count;
}
void Account::operation(const Operation & op, OpVector & res)
{
if (op->getClassNo() == Atlas::Objects::Operation::LOGOUT_NO) {
this->LogoutOperation(op, res);
}
}
void Flusher::operation(const Operation & op, OpVector & res)
{
shared_ptr<ObjectContext> flush_context = m_context.lock();
if (!flush_context) {
m_complete = true;
return;
}
if (op->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
// We have a sight op, check if its the sight of an entity we
// want to delete.
const std::vector<Root> & args = op->getArgs();
if (args.empty()) {
std::cerr << "Got empty sight" << std::endl << std::flush;
return;
}
const Root & arg = args.front();
assert(arg.isValid());
RootEntity sight_ent = smart_dynamic_cast<RootEntity>(arg);
if (!sight_ent.isValid()) {
return;
}
if (!sight_ent->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "Got sight no ID" << std::endl << std::flush;
return;
}
if (!sight_ent->hasAttrFlag(Atlas::Objects::PARENTS_FLAG)) {
std::cerr << "Got sight no PARENTS" << std::endl << std::flush;
return;
}
if (sight_ent->getParents().empty() ||
sight_ent->getParents().front() != type) {
return;
}
const std::string & id = sight_ent->getId();
std::cout << "Deleting: " << type << "(" << id << ")"
<< std::endl << std::flush;
// Send a delete to the entity we have seen.
Delete d;
Anonymous dmap;
dmap->setId(id);
d->setArgs1(dmap);
flush_context->setFromContext(d);
d->setTo(id);
res.push_back(d);
// Send a tick for a short time in the future so that
// we can look again once this entity is definitly gone.
Tick t;
Anonymous tick_arg;
tick_arg->setName("flusher");
flush_context->setFromContext(t);
t->setTo(t->getFrom());
t->setFutureSeconds(0.1);
t->setArgs1(tick_arg);
res.push_back(t);
} else if (op->getParents().front() == "tick") {
// We have a tick op, check if its the one we sent ourselves
// to schedule the next look.
if (op->getArgs().empty() ||
op->getArgs().front()->getName() != "flusher") {
std::cout << "Not for us" << std::endl << std::flush;
return;
}
// Send another look by type.
Look l;
Anonymous lmap;
lmap->setParents(std::list<std::string>(1, type));
l->setArgs1(lmap);
flush_context->setFromContext(l);
res.push_back(l);
} else if (op->getParents().front() == "unseen") {
// We have an unseen op, which signals our last look returned
// no results.
m_complete = true;
}
}
virtual void message(const Operation & op, Entity & ent) {
stub_baseworld_receieved_op = op->getClassNo();
}
/// \brief Find and call the handler for an operation
///
/// @param op The operation to be processed.
/// @param res The result of the operation is returned here.
void Entity::callOperation(const Operation & op, OpVector & res)
{
auto op_no = op->getClassNo();
OP_SWITCH(op, op_no, res,)
}