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::updateResidences(){
ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("sceneobjects", true);
ObjectDatabaseIterator iterator(database);
ObjectInputStream objectData(2000);
uint64 objectID = 0;
info("---------------Setting residences---------------------",true);
info("Setting residence values for all active player residences ", true);
int count = 0;
try {
while (iterator.getNextKeyAndValue(objectID, &objectData)) {
String className;
uint64 residence = 0;
try {
if (!Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData) ||
!Serializable::getVariable<uint64>(STRING_HASHCODE("PlayerObject.declaredResidence"), &residence, &objectData)) {
objectData.clear();
continue;
}
} catch (...) {
objectData.clear();
continue;
}
if (className == "PlayerObject") {
// info("we found a Player " + String::valueOf(objectID) + " with residence " + String::valueOf(residence),true);
SortedVector<unsigned long long> structureList;
uint64 residence = 0;
count++;
printf("\r\tUpdating player residence [%d] / [?]\t", count);
if( Serializable::getVariable< SortedVector<unsigned long long> >(STRING_HASHCODE("PlayerObject.ownedStructures"), &structureList, &objectData) &&
Serializable::getVariable<uint64>(STRING_HASHCODE("PlayerObject.declaredResidence"), &residence, &objectData)){
for(int i = 0; i < structureList.size(); i++){
bool isRes = (structureList.get(i) == residence);
//info("Owned structure " + String::valueOf(structureList.get(i)) + " residence = " + String::valueOf(isRes),true);
setResidence(structureList.get(i),isRes);
}
} else {
info("ERROR unable to get ownedStructures for player " + String::valueOf(objectID),true);
}
}
objectData.clear();
}
} catch (Exception& e) {
error(e.getMessage());
e.printStackTrace();
}
info("\n",true);
}
void CWizKbSync::processConflictDocumentData(const WIZDOCUMENTDATAEX& data)
{
// to avoid unable to download document object data, just save it
m_conflictDownloadedInfo = data;
WIZOBJECTDATA objectData(data);
downloadObjectData(objectData);
}
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);
}
}
}
starDust::starDust()
: initDone(false)
, menu(NULL)
{
plugin = this;
fprintf(stderr, "starDust::starDust()\n");
tuiTab = new coTUITab("starDust", coVRTui::instance()->mainFolder->getID());
tuiTab->setPos(0, 0);
tuiSimulate = new coTUIToggleButton("simulate", tuiTab->getID());
tuiSimulate->setEventListener(this);
tuiSimulate->setPos(0, 0);
tuiSimulate->setState(true);
tuiReset = new coTUIButton("reset", tuiTab->getID());
tuiReset->setEventListener(this);
tuiReset->setPos(1, 0);
tuiRender = new coTUIToggleButton("render", tuiTab->getID());
tuiRender->setEventListener(this);
tuiRender->setPos(0, 1);
tuiRender->setState(true);
tuiSimTime = new coTUILabel("Year:", tuiTab->getID());
tuiSimTime->setPos(2, 0);
tuiPlanetScaleLabel = new coTUILabel("PlanetScale:", tuiTab->getID());
tuiPlanetScaleLabel->setPos(3, 0);
tuiPlanetScale = new coTUIEditFloatField("PlanetScale:", tuiTab->getID());
tuiPlanetScale->setPos(4, 0);
tuiPlanetScale->setEventListener(this);
tuiPlanetScale->setValue(1000000);
planetScale = 1000000;
deltaT = 900;
tuiIntegrationTimestepLabel = new coTUILabel("IterationTimestep:", tuiTab->getID());
tuiIntegrationTimestepLabel->setPos(3, 1);
tuiIntegrationTimestep = new coTUIEditFloatField("IterationTimestep:", tuiTab->getID());
tuiIntegrationTimestep->setPos(4, 1);
tuiIntegrationTimestep->setEventListener(this);
tuiIntegrationTimestep->setValue(deltaT);
numIterationsPerFrame = 960;
tuiIterationsPerFrameLabel = new coTUILabel("IterationsPerFrame:", tuiTab->getID());
tuiIterationsPerFrameLabel->setPos(3, 2);
tuiIterationsPerFrame = new coTUIEditFloatField("IterationsPerFrame:", tuiTab->getID());
tuiIterationsPerFrame->setPos(4, 2);
tuiIterationsPerFrame->setEventListener(this);
tuiIterationsPerFrame->setValue(numIterationsPerFrame);
tuiSimulateToYearLabel = new coTUILabel("SimulateToYear:", tuiTab->getID());
tuiSimulateToYearLabel->setPos(3, 3);
tuiSimulateToYear = new coTUIEditFloatField("SimulateToYear:", tuiTab->getID());
tuiSimulateToYear->setPos(4, 3);
tuiSimulateToYear->setEventListener(this);
tuiSimulateToYear->setValue(4000);
simulateTo = (4000 - 2000) * 365.0 * 24.0 * 60.0 * 60.0;
tuiActivePlanetsLabel = new coTUILabel("numActivePlanets:", tuiTab->getID());
tuiActivePlanetsLabel->setPos(3, 4);
numActivePlanets = 5;
tuiActivePlanets = new coTUIEditIntField("numActivePlanets:", tuiTab->getID());
tuiActivePlanets->setPos(4, 4);
tuiActivePlanets->setEventListener(this);
tuiActivePlanets->setValue(numActivePlanets);
particleSize = 10000.0;
tuiParticleSizeLabel = new coTUILabel("ParticleSize:", tuiTab->getID());
tuiParticleSizeLabel->setPos(3, 5);
tuiParticleSize = new coTUIEditFloatField("ParticleSize:", tuiTab->getID());
tuiParticleSize->setPos(4, 5);
tuiParticleSize->setEventListener(this);
tuiParticleSize->setValue(particleSize);
FILE *fp;
fp = fopen("/data/irs/planets.txt", "r");
if (fp)
{
#define LINE_LEN 1000
char buf[1001];
buf[1000] = '\0';
while (!feof(fp))
{
fgets(buf, LINE_LEN, fp);
if ((buf[0] != '%') && (buf[0] != '#'))
{
double xc, yc, zc, vx, vy, vz, mass;
char name[LINE_LEN];
sscanf(buf, "%s %lf %lf %lf %lf %lf %lf %lf %lf", name, &xc, &yc, &zc, &vx, &vy, &vz, &mass, &startTime);
planetData pd = planetData(xc, yc, zc, vx, vy, vz, mass, startTime);
planets.push_back(pd);
initialPlanets.push_back(pd);
fprintf(stderr, "startTime %lf\n", startTime);
}
}
SimulationTime = startTime;
fclose(fp);
}
else
{
fprintf(stderr, "Could not open file %s\n", "/data/irs/planets.txt");
}
fp = fopen("/data/irs/objects.txt", "r");
if (fp)
{
char buf[1001];
buf[1000] = '\0';
while (!feof(fp))
{
fgets(buf, LINE_LEN, fp);
if ((buf[0] != '%') && (buf[0] != '#'))
{
double xc, yc, zc, vx, vy, vz, mass, startT;
char name[LINE_LEN];
sscanf(buf, "%s %lf %lf %lf %lf %lf %lf %lf %lf", name, &xc, &yc, &zc, &vx, &vy, &vz, &mass, &startT);
objectData od = objectData(xc, yc, zc, vx, vy, vz, mass, startT);
objects.push_back(od);
initialObjects.push_back(od);
}
}
fclose(fp);
}
else
{
fprintf(stderr, "Could not open file %s\n", "/data/irs/objects.txt");
}
VrmlNamespace::addBuiltIn(VrmlNodeSolarSystem::defineType());
}
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);
}
