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 }