ObjectOutputStream* ObjectVersionUpdateManager::changeVariableData(const uint32& variableHashCode, ObjectInputStream* object, Stream* newVariableData) {
int offset = getVariableDataOffset(variableHashCode, object);
if (offset == -1)
return NULL;
ObjectOutputStream* newData = new ObjectOutputStream(object->size());
object->copy(newData);
object->reset();
newData->reset();
object->shiftOffset(offset - 4);
uint32 dataSize = object->readInt();
newData->shiftOffset(offset); //we go data length
if (dataSize > 0)
newData->removeRange(offset, offset + dataSize);
newData->writeInt(offset - 4, newVariableData->size());
newData->insertStream(newVariableData, newVariableData->size(), offset);
object->reset();
//newData->reset();
return newData;
}
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();
}
}
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);
}
}
}
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);
}
