NetworkId const ObjectIdManager::getNewObjectIdInternal()
{
if (numAvailableIds==0)
{
if (m_gotABlock)
FATAL(true,("Out of available object ID's"));
else
FATAL(true,("Requested an object ID before any were received.\n"));
return NetworkId::cms_invalid;
}
FreeListType::iterator i=m_freeList.begin();
DEBUG_FATAL((i==m_freeList.end()),("numAvailableIds was non-zero but freelist was empty."));
NetworkId::NetworkIdType theId=(*i).m_start;
if (++((*i).m_start) > (*i).m_end)
{ // this block is now empty
m_freeList.erase(i);
}
if ((--numAvailableIds+numRequestedIds) < m_minReservedIds)
{
requestMoreObjectIds(m_maxReservedIds - numAvailableIds - numRequestedIds, false);
}
return NetworkId(theId);
}
void get(ReadIterator & source, NetworkId & target)
{
int64 id; // Using int64 instead of NetworkIdType so that we get a compile error if we change it
//source.get(&id,8); // because this line hard-codes the size
get(source, id);
target = NetworkId(id);
}
void ObjectIdManager::addBlock(NetworkId::NetworkIdType start, NetworkId::NetworkIdType end)
{
DEBUG_REPORT_LOG(true,("Adding NetworkId block from %s to %s\n",NetworkId(start).getValueString().c_str(),NetworkId(end).getValueString().c_str()));
m_gotABlock=true;
m_freeList.push_back(FreeListEntry(start,end));
numAvailableIds+=static_cast<int>(end-start+1); // No way this should be more than an int's worth of id's
numRequestedIds-=static_cast<int>(end-start+1);
if (numRequestedIds<0)
numRequestedIds=0; // we may recieve more ID's than we asked for. (This is allowed by design to avoid fragmentation issues.)
if (m_freeList.size() == 1)
{
GameServer::getInstance().onReceivedFirstNetworkIdBlock();
}
}
const bool CharacterCreationTracker::getStartLocation(const std::string & name, std::string & planetName, Vector & coordinates, NetworkId & cellId) const
{
const StartingLocationData * const sld = StartingLocationManager::findLocationByName (name);
if (sld)
{
planetName = sld->planet;
coordinates.x = sld->x;
coordinates.z = sld->z;
cellId = NetworkId (sld->cellId);
return true;
}
REPORT_LOG(true, ("The start location \"%s\" could not be found in StartingLocationManager", name.c_str()));
return false;
}
std::string CellPermissions::PermissionObject::getName() const
{
std::string nameString;
// Depending on the original format, we may need to convert the permission string
switch ( m_originalPermissionFormat )
{
case PF_CHARACTER_NAME:
{
const NetworkId playerNetworkId = NetworkId( m_permissionString );
// Try to convert the network ID to an actual player name
// NOTE: We grab the full name so that capitalization is correct
const std::string fullName = NameManager::getInstance().getPlayerFullName( playerNetworkId );
// Parse the first name from the full name
size_t curpos = 0;
std::string firstName;
if ( Unicode::getFirstToken( fullName, curpos, curpos, firstName ) )
{
nameString = firstName;
}
}
break;
case PF_GUILD_NAME:
{
const int guildId = atoi( m_permissionString.c_str() );
// Try to convert the guildId to an actual guild name
if ( guildId != 0 )
{
// Prefix with "Guild: " for legacy reasons
nameString = "Guild:" + GuildInterface::getGuildAbbrev( guildId );
}
}
break;
case PF_NUMERIC_VALUE:
case PF_UNKNOWN_STRING:
default:
// Just return the stored string for these cases
nameString = m_permissionString;
break;
}
return nameString;
}
int bufferViewHint = _bufferViewHint;
reset();
if (!Client::bufferViewManager())
return;
const QList<BufferViewConfig *> bufferViewConfigs = Client::bufferViewManager()->bufferViewConfigs();
foreach(BufferViewConfig *bufferViewConfig, bufferViewConfigs) {
addBufferView(bufferViewConfig);
}
_ignoreWidgetChanges = true;
// load network selector
ui.networkSelector->clear();
ui.networkSelector->addItem(tr("All"));
ui.networkSelector->setItemData(0, qVariantFromValue<NetworkId>(NetworkId()));
const Network *net;
foreach(NetworkId netId, Client::networkIds()) {
net = Client::network(netId);
ui.networkSelector->addItem(net->networkName());
ui.networkSelector->setItemData(ui.networkSelector->count() - 1, qVariantFromValue<NetworkId>(net->networkId()));
}
_ignoreWidgetChanges = false;
if (!useBufferViewHint || !selectBufferViewById(bufferViewHint))
ui.bufferViewList->setCurrentRow(0);
}
void BufferViewSettingsPage::save()
{
jstring JNICALL ScriptMethodsChatNamespace::packOutOfBandProsePackage(JNIEnv * env, jobject self, jstring target, jint position, jobject stringId, jlong objActor, jlong objTarget, jlong objOther, jobject nameIdActor, jobject nameIdTarget, jobject nameIdOther, jstring nameActor, jstring nameTarget, jstring nameOther, jint digitInteger, jfloat digitFloat, jboolean complexGrammar)
{
UNREF(env);
UNREF(self);
if (!stringId)
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage attempt to pack prose package with null stringId"));
return 0;
}
Unicode::String t;
if (target)
{
JavaStringParam jt(target);
if(! JavaLibrary::convert(jt, t))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert target string"));
return 0;
}
}
ProsePackage pp (complexGrammar);
if (!ScriptConversion::convert (stringId, pp.stringId))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert StringId"));
return 0;
}
pp.actor.id = NetworkId(objActor);
if (objActor && pp.actor.id == NetworkId::cms_invalid)
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert actor id"));
return 0;
}
pp.target.id = NetworkId(objTarget);
if (objTarget && pp.target.id == NetworkId::cms_invalid)
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert target id"));
return 0;
}
pp.other.id = NetworkId(objOther);
if (objOther && pp.other.id == NetworkId::cms_invalid)
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert other id"));
return 0;
}
if (nameIdActor)
{
if (!ScriptConversion::convert(nameIdActor, pp.actor.stringId))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert actor id"));
return 0;
}
}
else if (nameActor)
{
const JavaStringParam jt(nameActor);
if(! JavaLibrary::convert(jt, pp.actor.str))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert actor name"));
return 0;
}
}
if (nameIdTarget)
{
if (!ScriptConversion::convert(nameIdTarget, pp.target.stringId))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert target id"));
return 0;
}
}
else if (nameTarget)
{
const JavaStringParam jt(nameTarget);
if(! JavaLibrary::convert(jt, pp.target.str))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert target name"));
return 0;
}
}
if (nameIdOther)
{
if (!ScriptConversion::convert(nameIdOther, pp.other.stringId))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert other id"));
return 0;
}
}
else if (nameOther)
{
const JavaStringParam jt(nameOther);
if(! JavaLibrary::convert(jt, pp.other.str))
{
DEBUG_WARNING (true, ("JavaLibrary::packOutOfBandProsePackage unable to convert other name"));
return 0;
}
}
pp.digitInteger = digitInteger;
pp.digitFloat = digitFloat;
Archive::ByteStream bs;
Archive::put(bs, pp);
OutOfBandPackager::pack(bs, OutOfBandPackager::OT_prosePackage, position, t);
JavaString result(t);
return result.getReturnValue();
}
bool ConsoleCommandParserResource::performParsing (const NetworkId & userId, const StringVector_t & argv, const String_t & originalCommand, String_t & result, const CommandParser * node)
{
NOT_NULL (node);
UNREF (userId);
UNREF(originalCommand);
//-----------------------------------------------------------------
if (isCommand( argv [0], "activate"))
{
CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));
ServerObject* harvesterObject = safe_cast<ServerObject*>(harvester.getObject());
if (harvesterObject == NULL)
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
return true;
}
Controller *const controller = harvesterObject->getController();
NOT_NULL(controller);
controller->appendMessage(static_cast<int>(CM_activateInstallation),0.0f,new MessageQueueActivateInstallation(), GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_SERVER);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else if (isCommand( argv [0], "harvest"))
{
CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));
ServerObject* harvesterObject = safe_cast<ServerObject*>(harvester.getObject());
if (harvesterObject == NULL)
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
return true;
}
//TODO: Make all of these into function calls instead of sending messages
Controller *const controller = harvesterObject->getController();
NOT_NULL(controller);
controller->appendMessage(static_cast<int>(CM_installationHarvest),0.0f,new MessageQueueInstallationHarvest(), GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_SERVER);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else if (isCommand( argv [0], "discardHopper"))
{
CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));
HarvesterInstallationObject* harvesterObject = dynamic_cast<HarvesterInstallationObject*>(harvester.getObject());
if (!harvesterObject)
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
return true;
}
harvesterObject->discardAllHopperContents ();
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else if (isCommand( argv [0], "deactivate"))
{
CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));
ServerObject* harvesterObject = safe_cast<ServerObject*>(harvester.getObject());
if (harvesterObject == NULL)
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
return true;
}
Controller *const controller = harvesterObject->getController();
NOT_NULL(controller);
controller->appendMessage(static_cast<int>(CM_deactivateInstallation),0.0f,new MessageQueueDeactivateInstallation(), GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_SERVER);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else if (isCommand( argv [0], "tree"))
{
ServerUniverse & universe = ServerUniverse::getInstance();
ResourceClassObject * root = 0;
if (argv.size () > 1)
root = universe.getResourceClassByName (Unicode::wideToNarrow (argv [1]));
else
root = universe.getResourceTreeRoot();
if (root)
{
std::string temp;
root->debugOutput(temp);
result += Unicode::narrowToWide(temp);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
else if (isCommand( argv [0], "pools"))
{
PlanetObject* planet=ServerUniverse::getInstance().getPlanetByName(Unicode::wideToNarrow(argv[1]));
if (planet)
{
std::string temp;
planet->debugOutputPools(temp);
result += Unicode::narrowToWide(temp);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
}
else if (isCommand( argv [0], "name"))
{
NetworkId resourceId(Unicode::wideToNarrow (argv[1]));
ResourceTypeObject * const resource = ServerUniverse::getInstance().getResourceTypeById(resourceId);
if (resource)
{
resource->setName(Unicode::wideToNarrow(argv[2]));
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
}
else if (isCommand( argv [0], "viewcontainer"))
{
CachedNetworkId contId (Unicode::wideToNarrow (argv[1]));
ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(contId.getObject());
if (container)
{
result += Unicode::narrowToWide(container->debugPrint()+'\n');
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
}
else if (isCommand( argv [0], "addtocontainer"))
{
NetworkId const contId (Unicode::wideToNarrow (argv[1]));
ResourceContainerObject * const container = dynamic_cast<ResourceContainerObject*>(NetworkIdManager::getObjectById(contId));
std::string const & resourcePath = Unicode::wideToNarrow(argv[2]);
ResourceTypeObject * const resType = ServerUniverse::getInstance().getResourceTypeByName(resourcePath);
int const amount = strtol(Unicode::wideToNarrow (argv[3]).c_str (), NULL, 10);
NetworkId const source(Unicode::wideToNarrow (argv[4]));
if (container && resType)
{
if (container->addResource(CachedNetworkId(resType->getNetworkId()),amount, source))
result += getErrorMessage(argv[0], ERR_SUCCESS);
else
result += getErrorMessage(argv[0], ERR_INVALID_CONTAINER_TRANSFER);
}
else
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
}
else if (isCommand( argv [0], "fillcontainer"))
{
NetworkId contId (Unicode::wideToNarrow (argv[1]));
ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(NetworkIdManager::getObjectById(contId));
if (container != NULL)
{
NetworkId sourceId;
if (argv.size() >= 3)
sourceId = NetworkId(Unicode::wideToNarrow (argv[2]));
if (container->addResource(container->getResourceType(),
container->getMaxQuantity() - container->getQuantity(),
sourceId))
{
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
result += getErrorMessage(argv[0], ERR_INVALID_CONTAINER_TRANSFER);
}
else
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
else if (isCommand( argv [0], "recycle"))
{
NetworkId contId (Unicode::wideToNarrow (argv[1]));
ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(NetworkIdManager::getObjectById(contId));
if (container != NULL)
{
if (container->debugRecycle())
result += getErrorMessage(argv[0], ERR_SUCCESS);
else
result += Unicode::narrowToWide("The resource in the container could not be recycled.\n");
}
else
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
else if (isCommand( argv [0], "removefromcontainer"))
{
CachedNetworkId contId (Unicode::wideToNarrow (argv[1]));
ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(contId.getObject());
ResourceTypeObject *resType=ServerUniverse::getInstance().getResourceTypeByName(Unicode::wideToNarrow(argv[2]));
int amount=strtol(Unicode::wideToNarrow (argv[3]).c_str (), NULL, 10);
if (container && resType)
{
NetworkId sourcePlayer(NetworkId::cms_invalid);
typedef std::vector<std::pair<NetworkId, int> > SourcesType;
SourcesType sources;
if (container->removeResource(resType->getNetworkId(),amount,&sources))
{
char buffer[50];
for(SourcesType::iterator i=sources.begin(); i!=sources.end(); ++i)
{
IGNORE_RETURN(snprintf(buffer,50,"%i",i->second));
result += Unicode::narrowToWide(std::string("Removed ") + buffer + " resources harvested by player " + i->first.getValueString() + '\n');
}
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
result += getErrorMessage(argv[0], ERR_INVALID_CONTAINER_TRANSFER);
}
else
{
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
}
else if (isCommand( argv [0], "getSurveyList"))
{
std::string parentResourceClassName(Unicode::wideToNarrow(argv[1]));
CachedNetworkId tool(Unicode::wideToNarrow (argv[2]));
SurveySystem::getInstance().requestResourceListForSurvey(userId, tool, parentResourceClassName);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else if (isCommand( argv [0], "survey"))
{
const std::string parentResourceClassName (Unicode::wideToNarrow(argv[1]));
const std::string resourceTypeName (Unicode::wideToNarrow(argv[2]));
const int surveyRange = strtol(Unicode::wideToNarrow(argv[3]).c_str(),NULL,10);
const int numPoints = strtol(Unicode::wideToNarrow(argv[4]).c_str(),NULL,10);
const Object * player = NetworkIdManager::getObjectById(userId);
if (player)
{
SurveySystem::getInstance().requestSurvey(userId, parentResourceClassName, resourceTypeName, player->getPosition_w(), surveyRange, numPoints);
result += getErrorMessage(argv[0], ERR_SUCCESS);
}
else
result += getErrorMessage(argv [0], ERR_INVALID_OBJECT);
}
else if (isCommand( argv [0], "deplete"))
{
NetworkId resourceId (Unicode::wideToNarrow (argv[1]));
if (ServerUniverse::getInstance().manualDepleteResource(resourceId))
result += getErrorMessage(argv[0], ERR_SUCCESS);
else
result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
}
return true;
} // ConsoleCommandParserResource::performParsing
void CentralServerConnection::onReceive(const Archive::ByteStream & message)
{
Archive::ReadIterator ri = message.begin();
GameNetworkMessage msg(ri);
ri = message.begin();
if(msg.isType("ConGenericMessage"))
{
// dispatch to CentralCommandParser
ConGenericMessage con(ri);
Unicode::String wideResult;
m_centralCommandParser->parse(NetworkId(static_cast<NetworkId::NetworkIdType>(con.getMsgId())), Unicode::narrowToWide(con.getMsg()), wideResult);
ConGenericMessage response(Unicode::wideToNarrow(wideResult), con.getMsgId());
send(response, true);
}
else if(msg.isType("CharacterTransferStatusMessage"))
{
CharacterTransferStatusMessage c(ri);
CreatureObject * character = safe_cast<CreatureObject *>(NetworkIdManager::getObjectById(c.getToCharacterId()));
if(character)
{
if(character->getClient())
{
character->receiveCharacterTransferStatusMessage(c.getStatusMessage());
}
}
}
else if(msg.isType("TransferRequestNameValidation"))
{
const GenericValueTypeMessage<TransferCharacterData> requestNameValidation(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferRequestNameValidation from CentralServer : %s", requestNameValidation.getValue().toString().c_str()));
std::string name = requestNameValidation.getValue().getDestinationCharacterName();
if(name.empty())
{
name = requestNameValidation.getValue().getSourceCharacterName();
}
// call the same name validation code that gets called for normal character creation
std::string templateName = requestNameValidation.getValue().getObjectTemplateName();
if (templateName.empty())
{
uint32 const templateCrc = requestNameValidation.getValue().getObjectTemplateCrc();
if (templateCrc != 0)
{
templateName = ObjectTemplateList::lookUp(templateCrc).getString();
}
}
VerifyAndLockNameRequest const verifyRequest(requestNameValidation.getValue().getDestinationStationId(), NetworkId::cms_invalid, templateName, Unicode::narrowToWide(name), 0xFFFFFFFF);
StringId const verifyResult = GameServer::getInstance().handleVerifyAndLockNameRequest(verifyRequest, false, false);
TransferCharacterData replyData(requestNameValidation.getValue());
replyData.setIsValidName(verifyResult == NameErrors::nameApproved);
GenericValueTypeMessage<std::pair<std::string, TransferCharacterData> > reply("TransferReplyNameValidation", std::make_pair(std::string("@") + verifyResult.getCanonicalRepresentation(), replyData));
send(reply, true);
}
else if(msg.isType("TransferReplyCharacterList"))
{
const TransferReplyCharacterList reply(ri);
const AvatarList & oldAl = reply.getAvatarList();
// remove any characters from the list that would qualify for free CTS; characters that
// qualify for free CTS should/must use the in-game free CTS to transfer the character;
AvatarList newAl;
std::string const & clusterName = GameServer::getInstance().getClusterName();
for (AvatarList::const_iterator iter = oldAl.begin(); iter != oldAl.end(); ++iter)
{
if (!FreeCtsDataTable::getFreeCtsInfoForCharacter(static_cast<time_t>(NameManager::getInstance().getPlayerCreateTime(iter->m_networkId)), clusterName, false))
newAl.push_back(*iter);
else
LOG("CustomerService", ("CharacterTransfer: removing (%s, %s, %s) from paid CTS character list for station id %u because the character qualifies for free CTS", clusterName.c_str(), Unicode::wideToNarrow(iter->m_name).c_str(), iter->m_networkId.getValueString().c_str(), reply.getStationId()));
}
// send updated character list back to CentralServer
const TransferReplyCharacterList updatedReply(reply.getTrack(), reply.getStationId(), newAl);
send(updatedReply, true);
}
else if(msg.isType("CtsCompletedForcharacter"))
{
const GenericValueTypeMessage<std::pair<std::string, NetworkId> > msg(ri);
MessageToQueue::getInstance().sendMessageToJava(msg.getValue().second, "ctsCompletedForCharacter", std::vector<int8>(), 0, false);
}
else if( msg.isType( "GameServerCSRequest" ) )
{
GameServerCSRequestMessage request( ri );
GameServer::getInstance().handleCSRequest( request );
}
else if( msg.isType( "CSFindAuthObject" ) )
{
// see if we have the object.
GenericValueTypeMessage< std::pair<NetworkId, unsigned int> > msg( ri );
ServerObject * object = safe_cast<ServerObject *>( NetworkIdManager::getObjectById( msg.getValue().first ) );
// return an appropriate response.
if( object && object->isAuthoritative() )
{
GenericValueTypeMessage< std::pair< unsigned int, bool > > rmsg( "CSFindAuthObjectReply", std::make_pair( msg.getValue().second, true ) );
GameServer::getInstance().sendToCentralServer( rmsg );
}
else
{
GenericValueTypeMessage< std::pair< unsigned int, bool > > rmsg( "CSFindAuthObjectReply", std::make_pair( msg.getValue().second, false ) );
GameServer::getInstance().sendToCentralServer( rmsg );
}
}
else
{
ServerConnection::onReceive(message);
}
}
/**
* Send the snapshot to the appropriate server.
*
* This function will send messages to the appropriate gameServer to
* create a proxy for the objects in the snapshot, then it will send a
* message to central to relinquish authority for the objects.
*
* @return true if the objects were sent, false if they were not.
*/
bool SwgSnapshot::send(GameServerConnection *connection) const
{
PROFILER_AUTO_BLOCK_DEFINE("SwgSnapshot::send");
if (connection==0)
return false;
DEBUG_REPORT_LOG(ConfigServerDatabase::getLogObjectLoading(),("Sending Snapshot\n"));
PROFILER_BLOCK_DEFINE(prebaselinesBlock,"sendPreBaselinesCustomData");
PROFILER_BLOCK_ENTER(prebaselinesBlock);
for (LocatorListType::const_iterator loc=m_locatorList.begin(); loc!=m_locatorList.end(); ++loc)
{
(*loc)->sendPreBaselinesCustomData(*connection);
}
PROFILER_BLOCK_LEAVE(prebaselinesBlock);
OIDListType oidList;
m_objectTableBuffer.getObjectList(oidList);
PROFILER_BLOCK_DEFINE(sendObjectData,"send object data");
PROFILER_BLOCK_ENTER(sendObjectData);
static std::vector<BatchBaselinesMessageData> baselines;
baselines.clear();
for (OIDListType::iterator i=oidList.begin(); i!=oidList.end(); ++i)
{
PROFILER_BLOCK_DEFINE(createBlock, "object create and position");
PROFILER_BLOCK_ENTER(createBlock);
const DBSchema::ObjectBufferRow *baseData=m_objectTableBuffer.findConstRowByIndex((*i));
NOT_NULL(baseData);
NetworkId networkId=(*i);
DEBUG_FATAL(networkId != baseData->object_id.getValue(),("Object ID and row value didn't match"));
uint32 crc = baseData->object_template_id.getValue();
CreateObjectByCrcMessage com(networkId,
crc,
static_cast<unsigned short>(baseData->type_id.getValue()),
true,
NetworkId(baseData->contained_by.getValue()));
// connection->send(com,true);
DEBUG_REPORT_LOG(ConfigServerDatabase::getLogObjectLoading(),("\tSent CreateObjectMessage for object %s\n",networkId.getValueString().c_str()));
Transform t;
Quaternion q(static_cast<real>(baseData->quaternion_w.getValue()),
static_cast<real>(baseData->quaternion_x.getValue()),
static_cast<real>(baseData->quaternion_y.getValue()),
static_cast<real>(baseData->quaternion_z.getValue()));
q.getTransform(&t); // reorients the transform according to the quaternion
t.validate();
t.setPosition_p(Vector (static_cast<real>(baseData->x.getValue()),
static_cast<real>(baseData->y.getValue()),
static_cast<real>(baseData->z.getValue())));
UpdateObjectPositionMessage uopm(
NetworkId(baseData->object_id.getValue()),
t,
t,
NetworkId(baseData->contained_by.getValue()),
baseData->slot_arrangement.getValue(),
NetworkId(baseData->load_with.getValue()),
baseData->player_controlled.getValue(),
false);
// connection->send(uopm,true);
PROFILER_BLOCK_LEAVE(createBlock);
PROFILER_BLOCK_DEFINE(encodeData,"encode data");
PROFILER_BLOCK_ENTER(encodeData);
bool okToSend = encodeParentClientData(networkId,baseData->type_id.getValue(),baselines);
okToSend = okToSend && encodeClientData(networkId,baseData->type_id.getValue(),baselines);
okToSend = okToSend && encodeServerData(networkId,baseData->type_id.getValue(),baselines);
okToSend = okToSend && encodeSharedData(networkId,baseData->type_id.getValue(),baselines);
PROFILER_BLOCK_LEAVE(encodeData);
if (okToSend)
{
PROFILER_AUTO_BLOCK_DEFINE("connection->send (baselines)");
connection->send(com,true);
connection->send(uopm,true);
}
else
{
(*i)=NetworkId::cms_invalid;
}
}
BatchBaselinesMessage bbm(baselines);
connection->send(bbm,true);
PROFILER_BLOCK_LEAVE(sendObjectData);
PROFILER_BLOCK_DEFINE(sendEndBaselines,"send EndBaselines");
PROFILER_BLOCK_ENTER(sendEndBaselines);
// Send EndBaselines in reverse order (container & portal system requires this)
for (OIDListType::reverse_iterator r=oidList.rbegin(); r!=oidList.rend(); ++r)
{
if (*r != NetworkId::cms_invalid)
{
EndBaselinesMessage const ebm(*r);
connection->send(ebm,true);
}
// DEBUG_REPORT_LOG(true, ("\tSent EndBaselinesMessage for object %i\n",(*r).getValue()));
}
PROFILER_BLOCK_LEAVE(sendEndBaselines);
// Send resource data (if any) after all objects but before the post-baselines custom data
m_resourceTypeBuffer.sendResourceTypeObjects(*connection);
m_bountyHunterTargetBuffer.sendBountyHunterTargetMessage (*connection);
// Send post-baselines custom data, such as "UniverseComplete" messages, etc.
PROFILER_BLOCK_DEFINE(sendPostBaselinesCustomData,"sendPostBaselinesCustomData");
PROFILER_BLOCK_ENTER(sendPostBaselinesCustomData);
for (LocatorListType::const_iterator loc2=m_locatorList.begin(); loc2!=m_locatorList.end(); ++loc2)
{
(*loc2)->sendPostBaselinesCustomData(*connection);
}
PROFILER_BLOCK_LEAVE(sendPostBaselinesCustomData);
// Send any MessageTos for these objects
// This must happen after EndBaselinesMessage is sent for all of the objects
{
PROFILER_AUTO_BLOCK_DEFINE("send MessageTos");
m_messageBuffer.sendMessages(*connection);
for (OIDListType::const_iterator i=oidList.begin(); i!=oidList.end(); ++i)
{
if (*i != NetworkId::cms_invalid)
MessageToManager::getInstance().sendMessagesForObject(*i, *connection);
}
}
DEBUG_REPORT_LOG(ConfigServerDatabase::getLogObjectLoading(),("Done sending Snapshot\n"));
return true;
}
void SwgSnapshot::encodePersistedBuffs (Archive::ByteStream &data, DB::BufferString const& dbString) const
{
// some persisted buffs in the database were written as a AutoDeltaPackedMap of Crc's and uint64
// the new type ones are marked with a version number followed by a 'v' then the data
std::string stringRepresentation;
dbString.getValue (stringRepresentation);
size_t numchars = stringRepresentation.size();
int version = -1;
//format: [<versionNumber>v]<packedData>
//extract the version
if (numchars > 0)
{
size_t vpos = stringRepresentation.find('v');
if(vpos == stringRepresentation.npos)
{
version = 0;
}
else
{
std::string versionToken = stringRepresentation.substr(0,vpos);
sscanf(versionToken.c_str(), versionFormat, &version);
stringRepresentation = stringRepresentation.substr(vpos+1);
}
}
Archive::AutoDeltaMap<uint32, Buff::PackedBuff>::Command tempCommand;
std::vector<Archive::AutoDeltaMap<uint32, Buff::PackedBuff>::Command> commands;
char temp[200];
if(version == 0)
{
//string is the old AutoDeltaPackedMap written as [<crc> <packed64>:]*
uint64 tempPacked64;
uint32 tempCrc;
int numbuffs = Archive::countCharacter(stringRepresentation,':');
commands.reserve(numbuffs);
int tempPos = 0;
for (std::string::const_iterator i=stringRepresentation.begin(); i!=stringRepresentation.end(); ++i)
{
if (*i==':')
{
temp[tempPos]='\0';
sscanf(temp, oldschoolBuffFormat, &tempCrc, &tempPacked64);
tempCommand.cmd = Archive::AutoDeltaMap<uint32, Buff::PackedBuff>::Command::ADD;
tempCommand.key = tempCrc;
tempCommand.value = Buff::makePackedBuff(tempPacked64);
commands.push_back(tempCommand);
tempPos=0;
}
else
{
temp[tempPos++]=*i;
}
}
}
else if (version == 1)
{
//version 1 written as [<crc> <endtime> <value> <duration>:]*
uint32 tempCrc = 0, tempEndtime = 0, tempDuration = 0;
float tempValue = 0.0f;
int numbuffs = Archive::countCharacter(stringRepresentation,':');
commands.reserve(numbuffs);
int tempPos = 0;
for (std::string::const_iterator i=stringRepresentation.begin(); i!=stringRepresentation.end(); ++i)
{
if (*i==':')
{
temp[tempPos]='\0';
sscanf(temp, versionOneFormat, &tempCrc, &tempEndtime, &tempValue, &tempDuration);
tempCommand.cmd = Archive::AutoDeltaMap<uint32, Buff::PackedBuff>::Command::ADD;
tempCommand.key = tempCrc;
tempCommand.value = Buff(tempCrc, tempEndtime, tempValue, tempDuration).getPackedBuffValue();
commands.push_back(tempCommand);
tempPos=0;
}
else
{
temp[tempPos++]=*i;
}
}
}
else if (version == 2)
{
//version 2 written as [<crc> <endtime> <value> <duration> <caster> <stackCount>:]*
uint32 tempCrc = 0, tempEndtime = 0, tempDuration = 0, tempStackCount = 0;
float tempValue = 0.0f;
int64 tempCaster = 0;
int numbuffs = Archive::countCharacter(stringRepresentation,':');
commands.reserve(numbuffs);
int tempPos = 0;
for (std::string::const_iterator i=stringRepresentation.begin(); i!=stringRepresentation.end(); ++i)
{
if (*i==':')
{
temp[tempPos]='\0';
sscanf(temp, versionTwoFormat, &tempCrc, &tempEndtime, &tempValue, &tempDuration, &tempCaster, &tempStackCount);
tempCommand.cmd = Archive::AutoDeltaMap<uint32, Buff::PackedBuff>::Command::ADD;
tempCommand.key = tempCrc;
tempCommand.value = Buff(tempCrc, tempEndtime, tempValue, tempDuration, NetworkId(tempCaster), tempStackCount).getPackedBuffValue();
commands.push_back(tempCommand);
tempPos=0;
}
else
{
temp[tempPos++]=*i;
}
}
}
else
{
//we don't know how to convert this string to buffs, treat it as though there were no buffs there at all
WARNING(true, ("encodePersistedBuffs: Cannot convert db string with version %d to buffs", version));
}
Archive::AutoDeltaMap<uint32, Buff::PackedBuff>::pack(data, commands);
}
