void ClientConnection::processAnonymousGet(const Get& get)
{
const std::vector<Root>& args = get->getArgs();
if (args.empty())
{
Info serverInfo;
RootEntity svObj;
Atlas::Message::ListType prs;
prs.push_back("server");
svObj->setParentsAsList(prs);
svObj->setName("Bob's StubServer");
svObj->setAttr("server", "stubserver");
svObj->setAttr("ruleset", "stub-world");
svObj->setAttr("uptime", 666.0);
svObj->setAttr("clients", 42);
serverInfo->setArgs1(svObj);
send(serverInfo);
} else {
std::string typeName = args.front()->getId();
if (m_server->m_types.count(typeName))
{
Info typeInfo;
typeInfo->setArgs1(m_server->m_types[typeName]);
typeInfo->setRefno(get->getSerialno());
send(typeInfo);
} else
sendError("unknown type " + typeName, get);
}
}
void Property<IdList>::add(const std::string & s, const RootEntity & ent) const
{
if (!m_data.empty()) {
ListType list;
idListasObject(m_data, list);
ent->setAttr(s, list);
}
}
void ServerRouting::addToEntity(const RootEntity & ent) const
{
ent->setObjtype("obj");
ent->setAttr("server", "cyphesis");
ent->setAttr("ruleset", m_svrRuleset);
ent->setName(m_svrName);
ent->setParents(std::list<std::string>(1, "server"));
ent->setAttr("clients", m_numClients);
ent->setAttr("uptime", m_world.upTime());
ent->setAttr("builddate", std::string(consts::buildTime)+", "+std::string(consts::buildDate));
ent->setAttr("buildid", consts::buildId);
ent->setAttr("version", std::string(consts::version));
if (restricted_flag) {
ent->setAttr("restricted", "true");
}
ent->setAttr("entities", (long)m_world.getEntities().size());
// We could add all sorts of stats here, but I don't know exactly what yet.
}
void ServerRouting::addToEntity(const RootEntity & ent) const
{
ent->setObjtype("obj");
ent->setAttr("server", "cyphesis");
ent->setAttr("ruleset", m_svrRuleset);
ent->setName(m_svrName);
ent->setParent("server");
ent->setAttr("clients", m_numClients);
ent->setAttr("uptime", m_world.upTime());
ent->setAttr("buildid", consts::buildId);
ent->setAttr("version", std::string(consts::version));
if (restricted_flag) {
ent->setAttr("restricted", "true");
}
ent->setAttr("entities", (long)m_world.getEntities().size());
ent->setAttr("assets", Atlas::Message::ListType{"file://" + assets_directory});
// We could add all sorts of stats here, but I don't know exactly what yet.
}
void EntityImporterBase::sendResolvedEntityReferences()
{
if (!mEntitiesWithReferenceAttributes.empty()) {
for (auto entryI : mEntitiesWithReferenceAttributes) {
const auto& persistedEntityId = entryI.first;
const auto& referenceEntries = entryI.second;
auto createdEntityI = mEntityIdMap.find(persistedEntityId);
if (createdEntityI == mEntityIdMap.end()) {
S_LOG_WARNING("Could not find final server side entity id for persisted entity " << persistedEntityId << " when doing entity ref resolving.");
continue;
}
const auto& createdEntityId = createdEntityI->second;
//This should not fail at this phase, so we're not doing any checks.
auto& persistedEntity = mPersistedEntities.find(persistedEntityId)->second;
RootEntity entity;
for (const auto& referenceEntry : referenceEntries) {
Element element = persistedEntity->getAttr(referenceEntry.propertyName);
resolveEntityReferences(element);
entity->setAttr(referenceEntry.propertyName, element);
}
Set set;
set->setFrom(mAvatarId);
set->setSerialno(newSerialNumber());
set->setTo(createdEntityId);
set->setArgs1(entity);
mSetOpsInTransit++;
sigc::slot<void, const Operation&> slot = sigc::mem_fun(*this, &EntityImporterBase::operationSetResult);
sendAndAwaitResponse(set, slot);
}
} else {
sendMinds();
}
}
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
}