/// Add everything from an object database, swaying positions.
///
/// \param db Database.
/// \param amplitude Swaying amplitudes.
/// \param phase Current phase.
/// \param block_size Block size, objects in same block are considered to be in same phase.
/// \param pass Render pass id.
void addObjectDatabaseSwaying(const ObjectDatabase &db, const vec3 &litude, float phase,
unsigned block_size, unsigned pass = 0)
{
for(unsigned ii = 0; (ii < db.getObjectCount()); ++ii)
{
const Object& obj = db.getObject(ii);
bsd_srand(ii / block_size);
float px = frand(-amplitude[0], amplitude[0]);
float py = frand(-amplitude[1], amplitude[1]);
float pz = frand(-amplitude[2], amplitude[2]);
float ax = frand(static_cast<float>(M_PI));
float ay = frand(static_cast<float>(M_PI));
float az = frand(static_cast<float>(M_PI));
px *= dnload_sinf(ax + phase * (brand() ? -1.0f : 1.0f));
py *= dnload_sinf(ay + phase * (brand() ? -1.0f : 1.0f));
pz *= dnload_sinf(az + phase * (brand() ? -1.0f : 1.0f));
mat4 tr = obj.unpackTransform(m_frame);
tr[12] += px;
tr[13] += py;
tr[14] += pz;
addObject(obj, tr, pass);
}
}
void ObjectVersionUpdateManager::updateCityTreasuryToDouble(){
info("---------------MOdifying City Treasury---------------------",true);
info("Converting treasury to double for all cities ", true);
ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("cityregions", true);
ObjectInputStream objectData(2000);
String className;
ObjectDatabaseIterator iterator(database);
uint64 objectID = 0;
int count = 0;
try {
while (iterator.getNextKeyAndValue(objectID, &objectData)) {
String className;
try {
if (!Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData)) {
objectData.clear();
continue;
}
} catch (...) {
objectData.clear();
continue;
}
float funds;
double floatFunds = 5;
if (className == "CityRegion") {
count++;
printf("\r\tUpdating city treasury [%d] / [?]\t", count);
if ( Serializable::getVariable<float>(STRING_HASHCODE("CityRegion.cityTreasury"), &funds, &objectData)){
floatFunds = funds;
ObjectOutputStream newFunds;
TypeInfo<double>::toBinaryStream(&floatFunds, &newFunds );
ObjectOutputStream* test = changeVariableData(STRING_HASHCODE("CityRegion.cityTreasury"), &objectData, &newFunds);
test->reset();
database->putData(objectID, test, NULL);
} else {
info("Error... city " + String::valueOf(objectID) + " doesn't have cityTreasury variable",true);
}
}
objectData.clear();
}
} catch (Exception& e) {
error(e.getMessage());
e.printStackTrace();
}
}
/// Add everything from an object database.
///
/// \param db Database.
/// \param pass Render pass id.
void addObjectDatabase(const ObjectDatabase &db, unsigned pass = 0)
{
for(unsigned ii = 0; (ii < db.getObjectCount()); ++ii)
{
const Object& obj = db.getObject(ii);
addObject(obj, pass);
}
}
SceneObject* ObjectManager::cloneObject(SceneObject* object, bool makeTransient) {
ObjectOutputStream objectData(500);
(cast<ManagedObject*>(object))->writeObject(&objectData);
objectData.reset();
ObjectInputStream objectInput;
objectData.copy(&objectInput, 0);
objectInput.reset();
uint32 serverCRC = object->getServerObjectCRC();
SceneObject* clonedObject = NULL;
ObjectDatabase* database = getTable(object->getObjectID());
String databaseName;
uint64 oid;
if (database != NULL) {
database->getDatabaseName(databaseName);
oid = getNextObjectID(databaseName);
} else
oid = getNextFreeObjectID();
clonedObject = instantiateSceneObject(serverCRC, oid, false);
if (makeTransient || !object->isPersistent()) {
//clonedObject = createObject(serverCRC, 0, databaseName);
clonedObject->setPersistent(0);
} else if (object->isPersistent()) {
//clonedObject = createObject(serverCRC, object->getPersistenceLevel(), databaseName);
clonedObject->setPersistent(object->getPersistenceLevel());
}
Locker locker(clonedObject);
clonedObject->readObject(&objectInput);
clonedObject->createComponents();
clonedObject->setParent(NULL);
if (clonedObject->isPersistent())
updatePersistentObject(clonedObject);
return clonedObject;
}
void ObjectManager::loadLastUsedObjectID() {
info("loading last used object id");
uint64 storedID = databaseManager->getLastUsedObjectID();
if (!ServerCore::truncateDatabases() && storedID != 0) {
info("loading stored id..");
nextObjectID = storedID + 1;
info("done loading last used object id 0x" + String::hexvalueOf((int64)nextObjectID).toUpperCase());
return;
}
info("loading bruteforce id..");
uint64 maxObjectID = 0;
uint64 objectID;
uint64 nullify = 0x0000FFFF;
nullify = (nullify << 32) + 0xFFFFFFFF;
for (int i = 0; i < databaseManager->getTotalDatabaseCount(); ++i) {
LocalDatabase* database = databaseManager->getDatabase(i);
if (!database->isObjectDatabase())
continue;
ObjectDatabase* db = cast<ObjectDatabase*>(database);
String dbName;
db->getDatabaseName(dbName);
ObjectDatabaseIterator iterator(db);
while (iterator.getNextKey(objectID)) {
objectID = objectID & nullify;
if (objectID > maxObjectID)
maxObjectID = objectID;
}
}
if (nextObjectID < maxObjectID + 1)
nextObjectID = maxObjectID + 1;
info("done loading last used object id 0x" + String::hexvalueOf((int64)nextObjectID).toUpperCase());
}
void ObjectVersionUpdateManager::setResidence(uint64 buildingID, bool isResidence){
ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("playerstructures", true);
ObjectInputStream objectData(2000);
bool res = isResidence;
String className;
ObjectOutputStream newResidenceValue;
TypeInfo<bool>::toBinaryStream(&res, &newResidenceValue );
if(!database->getData(buildingID,&objectData)){
if ( Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData)){
if(className == "BuildingObject"){
if ( !Serializable::getVariable<bool>(STRING_HASHCODE("BuildingObject.isOwnerResidence"), &isResidence, &objectData)){
//info("setResidence() adding the variable",true);
ObjectOutputStream* newVariableData = addVariable("BuildingObject.isOwnerResidence", &objectData, &newResidenceValue);
database->putData(buildingID, newVariableData, NULL);
} else {
//info("setResidence() has variable and value = " + String::valueOf(isResidence) + " ... changing it",true);
ObjectOutputStream* test = changeVariableData(STRING_HASHCODE("BuildingObject.isOwnerResidence"), &objectData, &newResidenceValue);
test->reset();
database->putData(buildingID, test, NULL);
}
}
} else {
info("ERROR couldn't get object " + String::valueOf(buildingID),true);
}
}
}
SceneObject* ObjectManager::cloneObject(SceneObject* object, bool makeTransient) {
ObjectOutputStream objectData(500);
(cast<ManagedObject*>(object))->writeObject(&objectData);
objectData.reset();
ObjectInputStream objectInput;
objectData.copy(&objectInput, 0);
objectInput.reset();
uint32 serverCRC = object->getServerObjectCRC();
SceneObject* clonedObject = NULL;
ObjectDatabase* database = getTable(object->getObjectID());
String databaseName;
uint64 oid;
if (database != NULL) {
database->getDatabaseName(databaseName);
oid = getNextObjectID(databaseName);
} else
oid = getNextFreeObjectID();
clonedObject = instantiateSceneObject(serverCRC, oid, false);
if (makeTransient || !object->isPersistent()) {
//clonedObject = createObject(serverCRC, 0, databaseName);
clonedObject->setPersistent(0);
} else if (object->isPersistent()) {
//clonedObject = createObject(serverCRC, object->getPersistenceLevel(), databaseName);
clonedObject->setPersistent(object->getPersistenceLevel());
}
Locker locker(clonedObject);
clonedObject->readObject(&objectInput);
clonedObject->createComponents();
clonedObject->setParent(NULL);
VectorMap<String, ManagedReference<SceneObject*> > slottedObjects;
clonedObject->getSlottedObjects(slottedObjects);
for (int i=slottedObjects.size()-1; i>=0; i--) {
String key = slottedObjects.elementAt(i).getKey();
Reference<SceneObject*> obj = slottedObjects.elementAt(i).getValue();
clonedObject->removeSlottedObject(i);
Reference<SceneObject*> clonedChild = cloneObject(obj, makeTransient);
clonedChild->setParent(object);
slottedObjects.put(key, clonedChild);
}
VectorMap<uint64, ManagedReference<SceneObject*> > objects;
clonedObject->getContainerObjects(objects);
for (int i=objects.size()-1; i>=0; i--) {
uint64 key = objects.elementAt(i).getKey();
Reference<SceneObject*> obj = objects.elementAt(i).getValue();
objects.remove(i);
Reference<SceneObject*> clonedChild = cloneObject(obj, makeTransient);
clonedChild->setParent(object);
objects.put(key, clonedChild);
}
clonedObject->onCloneObject(object);
if (clonedObject->isPersistent())
updatePersistentObject(clonedObject);
return clonedObject;
}
void ObjectVersionUpdateManager::updateStructurePermissionLists() {
ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("playerstructures", true);
ObjectDatabaseIterator iterator(database);
ObjectInputStream objectData(2000);
uint64 objectID = 0;
int count = 0;
info("Setting owner on structure permission lists",true);
try {
while (iterator.getNextKeyAndValue(objectID, &objectData)) {
String className;
try {
if (!Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData)) {
objectData.clear();
continue;
}
} catch (...) {
objectData.clear();
continue;
}
if (className == "BuildingObject" || className == "InstallationObject" || className == "GarageInstallation" || className == "ShuttleInstallation") {
uint64 ownerID = 0;
String ownerName;
count ++;
printf("\r\tUpdating structure owners [%d] / [?]\t", count);
if( Serializable::getVariable<uint64>(STRING_HASHCODE("StructureObject.ownerObjectID"), &ownerID, &objectData)) {
StructurePermissionList permissionList;
if ( Serializable::getVariable<StructurePermissionList>(STRING_HASHCODE("StructureObject.structurePermissionList"), &permissionList, &objectData)){
ObjectOutputStream newOutputStream;
permissionList.setOwner(ownerID);
permissionList.toBinaryStream(&newOutputStream);
ObjectOutputStream* test = changeVariableData(STRING_HASHCODE("StructureObject.structurePermissionList"), &objectData, &newOutputStream);
test->reset();
database->putData(objectID, test, NULL);
} else {
info("ERROR unable to get structurePermissionList for structure " + String::valueOf(objectID),true);
}
} else {
info("ERROR unable to get ownerObjectID for structure " + String::valueOf(objectID),true);
}
}
objectData.clear();
}
} catch (Exception& e) {
error(e.getMessage());
e.printStackTrace();
}
info("Done updating owner on structure permission lists\n",true);
}
void ObjectVersionUpdateManager::updateWeaponsDots() {
ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("sceneobjects", true);
ObjectDatabaseIterator iterator(database);
ObjectInputStream objectData(2000);
uint64 objectID = 0;
info("update database weapon dots", true);
int count = 0;
uint32 classNameHashCode = STRING_HASHCODE("_className");
try {
while (iterator.getNextKeyAndValue(objectID, &objectData)) {
String className;
int oldType = 0;
try {
if (!Serializable::getVariable<String>(classNameHashCode, &className, &objectData) ||
!Serializable::getVariable<int>(STRING_HASHCODE("WeaponObject.dotType"), &oldType, &objectData)) {
objectData.clear();
continue;
}
} catch (...) {
objectData.clear();
continue;
}
if (className == "WeaponObject") {
Vector<int> dots;
ObjectOutputStream newDotsValue;
TypeInfo<Vector<int> >::toBinaryStream(&dots, &newDotsValue);
// info("we found a Player " + String::valueOf(objectID) + " with residence " + String::valueOf(residence),true);
ObjectOutputStream* newData = changeVariableData(STRING_HASHCODE("WeaponObject.dotType"), &objectData, &newDotsValue);
newData->reset();
ObjectInputStream* inputStream = new ObjectInputStream(newData->getBuffer(), newData->size());
delete newData;
ObjectOutputStream* newNextData = changeVariableData(STRING_HASHCODE("WeaponObject.dotAttribute"), inputStream, &newDotsValue);
newNextData->reset();
delete inputStream;
inputStream = new ObjectInputStream(newNextData->getBuffer(), newNextData->size());
delete newNextData;
newData = changeVariableData(STRING_HASHCODE("WeaponObject.dotStrength"), inputStream, &newDotsValue);
newData->reset();
delete inputStream;
inputStream = new ObjectInputStream(newData->getBuffer(), newData->size());
delete newData;
newNextData = changeVariableData(STRING_HASHCODE("WeaponObject.dotDuration"), inputStream, &newDotsValue);
newNextData->reset();
delete inputStream;
inputStream = new ObjectInputStream(newNextData->getBuffer(), newNextData->size());
delete newNextData;
newData = changeVariableData(STRING_HASHCODE("WeaponObject.dotPotency"), inputStream, &newDotsValue);
newData->reset();
delete inputStream;
inputStream = new ObjectInputStream(newData->getBuffer(), newData->size());
delete newData;
newNextData = changeVariableData(STRING_HASHCODE("WeaponObject.dotUses"), inputStream, &newDotsValue);
newNextData->reset();
delete inputStream;
database->putData(objectID, newNextData, NULL);
}
objectData.clear();
}
} catch (Exception& e) {
error(e.getMessage());
e.printStackTrace();
}
info("done updating databse weapon dots\n", true);
}
/// Add objects from an object database, constructing at limits.
///
/// \param db Database.
/// \param pos Position to render from.
/// \param fw Collect objects that have bounding box lying in area this much forward.
/// \param bk Collect objects that have bounding box lying in area this much backward.
/// \param interp Fade-in interpolation range (<=0 to disable).
/// \param pass Render pass id.
void addObjectDatabaseConstructing(const ObjectDatabase &db, const vec3 &pos, float fw, float bk,
float fade = 0.0f, unsigned pass = 0)
{
unsigned mid = db.find(pos[2]);
#if defined(USE_LD)
if((fade >= fw) || (fade >= bk))
{
std::ostringstream sstr;
sstr << "fade-in range " << fade << " must be smaller than advance ranges " << vec2(bk, fw);
BOOST_THROW_EXCEPTION(std::runtime_error(sstr.str()));
}
#endif
// Forward.
{
float limit = pos[2] + fw;
for(unsigned ii = mid; (ii < db.getObjectCount()); ++ii)
{
const Object &obj = db.getObject(ii);
float cmp = obj.getBoundingVolume().getMinZ();
if(cmp <= limit)
{
float diff = limit - cmp;
if(diff <= fade)
{
mat4 aa = obj.unpackTransform(m_frame);
mat4 bb = randomOffsetTransform(aa, obj.getCenter(), ii, diff / fade);
addObject(obj, bb, pass, false);
}
else
{
addObject(obj, pass);
}
}
else if(cmp - fade > limit)
{
break;
}
}
}
if(mid > 0)
{
float limit = pos[2] - bk;
unsigned ii = mid - 1;
for(;;)
{
const Object &obj = db.getObject(ii);
float cmp = obj.getBoundingVolume().getMaxZ();
if(cmp >= limit)
{
float diff = cmp - limit;
if(diff <= fade)
{
//std::cout << "cmp " << cmp << " versus limit " << limit << ", diff: " << diff << std::endl <<
// obj.getBoundingVolume() << std::endl;
mat4 aa = obj.unpackTransform(m_frame);
mat4 bb = randomOffsetTransform(aa, obj.getCenter(), ii, diff / fade);
addObject(obj, bb, pass, false);
}
else
{
addObject(obj, pass);
}
}
else if(cmp + fade < limit)
{
break;
}
if(0 >= ii)
{
break;
}
--ii;
}
}
}
