bool upgradeFilesInTemp() {
// Get path to temp files
string tempFilePath = "temp/";
if(getGameReadWritePath(GameConstants::path_logs_CacheLookupKey) != "") {
tempFilePath = getGameReadWritePath(GameConstants::path_logs_CacheLookupKey) + tempFilePath;
}
else {
Config &config = Config::getInstance();
string userData = config.getString("UserData_Root","");
if(userData != "") {
endPathWithSlash(userData);
}
tempFilePath = userData + tempFilePath;
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Temp files path [%s]\n",tempFilePath.c_str());
// Move all files into binary folder
bool anyFailures = false;
vector<string> fileList = getFolderTreeContentsListRecursively(tempFilePath, "", false, NULL);
for(unsigned int index = 0; index < fileList.size(); ++index) {
string fileName = fileList[index];
string newFileName = Properties::getApplicationPath() + extractFileFromDirectoryPath(fileName);
bool result = renameFile(fileName,newFileName);
if(result == false) {
printf("FAILED Rename: [%s] to [%s] result = %d errno = %d\n",fileName.c_str(),newFileName.c_str(),result,errno);
anyFailures = true;
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Rename: [%s] to [%s] result = %d\n",fileName.c_str(),newFileName.c_str(),result);
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Successfully updated!\n");
return (fileList.size() > 0 && anyFailures == false);
}
string MenuStateAbout::loadAdditionalCredits(){
string data_path= getGameReadWritePath(GameConstants::path_data_CacheLookupKey);
if(data_path != ""){
endPathWithSlash(data_path);
}
string result= "";
const string dir= getGameCustomCoreDataPath(data_path,"data/core/menu/credits.txt");
//printf("dir [%s]\n",dir.c_str());
if(fileExists(dir) == true) {
#if defined(WIN32) && !defined(__MINGW32__)
FILE *fp = _wfopen(utf8_decode(dir).c_str(), L"r");
ifstream file(fp);
#else
ifstream file(dir.c_str());
#endif
std::string buffer;
while(!file.eof()){
getline(file, buffer);
result+= buffer + "\n";
}
std::cout << buffer << std::endl;
file.close();
#if defined(WIN32) && !defined(__MINGW32__)
if(fp) fclose(fp);
#endif
}
return result;
}
string getGameCustomCoreDataPath(string originalBasePath, string uniqueFilePath) {
// original file path setup
if(originalBasePath != "") {
endPathWithSlash(originalBasePath);
}
//
// mydata user data override
Config &config = Config::getInstance();
string data_path = config.getString("UserData_Root","");
if(data_path != "") {
endPathWithSlash(data_path);
}
//
// if set this is the current active mod
string custom_mod_path = config.getCustomRuntimeProperty(Config::ACTIVE_MOD_PROPERTY_NAME);
if(custom_mod_path != "") {
endPathWithSlash(custom_mod_path);
}
//
// decide which file to use
string result = "";
if (SystemFlags::VERBOSE_MODE_ENABLED) printf("Looking for [%s] in\n#1: [%s]\n#2: [%s]\n#3: [%s]\n",uniqueFilePath.c_str(),custom_mod_path.c_str(),data_path.c_str(),originalBasePath.c_str());
if(custom_mod_path != "" &&
(uniqueFilePath == "" || fileExists(custom_mod_path + uniqueFilePath) == true)) {
result = custom_mod_path + uniqueFilePath;
}
else if(data_path != "" &&
(uniqueFilePath == "" || fileExists(data_path + uniqueFilePath) == true)) {
result = data_path + uniqueFilePath;
}
else {
result = originalBasePath + uniqueFilePath;
}
if (SystemFlags::VERBOSE_MODE_ENABLED) printf("result [%s]\n",result.c_str());
return result;
}
Checksum Tileset::loadTileset(const vector<string> pathList, const string &tilesetName,
Checksum* checksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
Checksum tilesetChecksum;
bool found = false;
for(int idx = 0; idx < pathList.size(); idx++) {
string currentPath = pathList[idx];
endPathWithSlash(currentPath);
string path = currentPath + tilesetName;
if(isdir(path.c_str()) == true) {
load(path, checksum, &tilesetChecksum, loadedFileList);
found = true;
break;
}
}
if(found == false) {
throw megaglest_runtime_error("Error could not find tileset [" + tilesetName + "]\n");
}
return tilesetChecksum;
}
void AmbientSounds::load(const string &dir, const XmlNode *xmlNode,
std::map<string,vector<pair<string, string> > > &loadedFileList, string parentLoader) {
string path="";
//day
const XmlNode *dayNode= xmlNode->getChild("day-sound");
enabledDay= dayNode->getAttribute("enabled")->getBoolValue();
if(enabledDay) {
string currentPath = dir;
endPathWithSlash(currentPath);
path= dayNode->getAttribute("path")->getRestrictedValue(currentPath);
day.open(path);
loadedFileList[path].push_back(make_pair(parentLoader,dayNode->getAttribute("path")->getRestrictedValue()));
alwaysPlayDay= dayNode->getAttribute("play-always")->getBoolValue();
}
//night
const XmlNode *nightNode= xmlNode->getChild("night-sound");
enabledNight= nightNode->getAttribute("enabled")->getBoolValue();
if(enabledNight) {
string currentPath = dir;
endPathWithSlash(currentPath);
path= nightNode->getAttribute("path")->getRestrictedValue(currentPath);
night.open(path);
loadedFileList[path].push_back(make_pair(parentLoader,nightNode->getAttribute("path")->getRestrictedValue()));
alwaysPlayNight= nightNode->getAttribute("play-always")->getBoolValue();
}
//rain
const XmlNode *rainNode= xmlNode->getChild("rain-sound");
enabledRain= rainNode->getAttribute("enabled")->getBoolValue();
if(enabledRain) {
string currentPath = dir;
endPathWithSlash(currentPath);
path= rainNode->getAttribute("path")->getRestrictedValue(currentPath);
rain.open(path);
loadedFileList[path].push_back(make_pair(parentLoader,rainNode->getAttribute("path")->getRestrictedValue()));
}
//snow
const XmlNode *snowNode= xmlNode->getChild("snow-sound");
enabledSnow= snowNode->getAttribute("enabled")->getBoolValue();
if(enabledSnow) {
string currentPath = dir;
endPathWithSlash(currentPath);
path= snowNode->getAttribute("path")->getRestrictedValue(currentPath);
snow.open(path);
loadedFileList[path].push_back(make_pair(parentLoader,snowNode->getAttribute("path")->getRestrictedValue()));
}
//dayStart
const XmlNode *dayStartNode= xmlNode->getChild("day-start-sound");
enabledDayStart= dayStartNode->getAttribute("enabled")->getBoolValue();
if(enabledDayStart) {
string currentPath = dir;
endPathWithSlash(currentPath);
path= dayStartNode->getAttribute("path")->getRestrictedValue(currentPath);
dayStart.load(path);
loadedFileList[path].push_back(make_pair(parentLoader,dayStartNode->getAttribute("path")->getRestrictedValue()));
}
//nightStart
const XmlNode *nightStartNode= xmlNode->getChild("night-start-sound");
enabledNightStart= nightStartNode->getAttribute("enabled")->getBoolValue();
if(enabledNightStart) {
string currentPath = dir;
endPathWithSlash(currentPath);
path= nightStartNode->getAttribute("path")->getRestrictedValue(currentPath);
nightStart.load(path);
loadedFileList[path].push_back(make_pair(parentLoader,nightStartNode->getAttribute("path")->getRestrictedValue()));
}
}
void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
random.init(time(NULL));
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
string name= lastDir(dir);
tileset_name = name;
string currentPath = dir;
endPathWithSlash(currentPath);
string path= currentPath + name + ".xml";
string sourceXMLFile = path;
checksum->addFile(path);
tilesetChecksum->addFile(path);
checksumValue.addFile(path);
try {
char szBuf[8096]="";
snprintf(szBuf,8096,Lang::getInstance().get("LogScreenGameLoadingTileset","",true).c_str(),formatString(name).c_str());
Logger::getInstance().add(szBuf, true);
Renderer &renderer= Renderer::getInstance();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//printf("About to load tileset [%s]\n",path.c_str());
//parse xml
XmlTree xmlTree;
xmlTree.load(path,Properties::getTagReplacementValues());
loadedFileList[path].push_back(make_pair(currentPath,currentPath));
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
const XmlNode *tilesetNode= xmlTree.getRootNode();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//surfaces
const XmlNode *surfacesNode= tilesetNode->getChild("surfaces");
int partsize= 0;
for(int i=0; i < surfCount; ++i) {
const XmlNode *surfaceNode;
if(surfacesNode->hasChildAtIndex("surface",i)){
surfaceNode= surfacesNode->getChild("surface", i);
}
else {
// cliff texture does not exist, use texture 2 instead
surfaceNode= surfacesNode->getChild("surface", 2);
}
if(surfaceNode->hasAttribute("partsize")){
partsize=surfaceNode->getAttribute("partsize",true)->getIntValue();
}
else{
partsize=0;
}
if(partsize==0){
int childCount= surfaceNode->getChildCount();
surfPixmaps[i].resize(childCount);
surfProbs[i].resize(childCount);
for(int j = 0; j < childCount; ++j) {
surfPixmaps[i][j] = NULL;
}
for(int j = 0; j < childCount; ++j) {
const XmlNode *textureNode= surfaceNode->getChild("texture", j);
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
surfPixmaps[i][j] = new Pixmap2D();
surfPixmaps[i][j]->init(3);
surfPixmaps[i][j]->load(textureNode->getAttribute("path")->getRestrictedValue(currentPath));
}
loadedFileList[textureNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,textureNode->getAttribute("path")->getRestrictedValue()));
surfProbs[i][j]= textureNode->getAttribute("prob")->getFloatValue();
}
}
else {
// read single big texture and cut it into pieces
const XmlNode *textureNode= surfaceNode->getChild("texture", 0);
Pixmap2D *pixmap=new Pixmap2D();
pixmap->init(3);
pixmap->load(textureNode->getAttribute("path")->getRestrictedValue(currentPath));
loadedFileList[textureNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,textureNode->getAttribute("path")->getRestrictedValue()));
int width=pixmap->getW();
int heith=pixmap->getW();
assert(width==heith);
assert(width%64==0);
assert(width%partsize==0);
int parts=width/partsize;
int numberOfPieces=parts*parts;
partsArray[i]=parts;
surfPixmaps[i].resize(numberOfPieces);
surfProbs[i].resize(numberOfPieces);
int j=0;
for(int x = 0; x < parts; ++x) {
for(int y = 0; y < parts; ++y) {
surfPixmaps[i][j] = new Pixmap2D();
surfPixmaps[i][j]->init(partsize,partsize,3);
surfPixmaps[i][j]->copyImagePart(x*partsize,y*partsize,pixmap);
surfProbs[i][j]=-1;
j++;
}
}
}
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//object models
const XmlNode *objectsNode= tilesetNode->getChild("objects");
for(int i=0; i<objCount; ++i){
const XmlNode *objectNode= objectsNode->getChild("object", i);
int childCount= objectNode->getChildCount();
int objectHeight = 0;
bool walkable = objectNode->getAttribute("walkable")->getBoolValue();
if(walkable == false) {
const XmlAttribute *heightAttribute = objectNode->getAttribute("height",false);
if(heightAttribute != NULL) {
objectHeight = heightAttribute->getIntValue();
}
}
objectTypes[i].init(childCount, i, walkable,objectHeight);
for(int j=0; j<childCount; ++j) {
const XmlNode *modelNode= objectNode->getChild("model", j);
const XmlAttribute *pathAttribute= modelNode->getAttribute("path");
TilesetModelType* tmt=objectTypes[i].loadModel(pathAttribute->getRestrictedValue(currentPath),&loadedFileList, sourceXMLFile);
loadedFileList[pathAttribute->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,pathAttribute->getRestrictedValue()));
if(modelNode->hasAttribute("anim-speed") == true) {
int animSpeed= modelNode->getAttribute("anim-speed")->getIntValue();
tmt->setAnimSpeed(animSpeed);
}
if(modelNode->hasChild("particles")){
const XmlNode *particleNode= modelNode->getChild("particles");
bool particleEnabled= particleNode->getAttribute("value")->getBoolValue();
if(particleEnabled){
for(int k=0; k<particleNode->getChildCount(); ++k){
const XmlNode *particleFileNode= particleNode->getChild("particle-file", k);
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
ObjectParticleSystemType *objectParticleSystemType= new ObjectParticleSystemType();
objectParticleSystemType->load(particleFileNode, dir, currentPath + path,
&Renderer::getInstance(), loadedFileList, sourceXMLFile,"");
loadedFileList[currentPath + path].push_back(make_pair(sourceXMLFile,particleFileNode->getAttribute("path")->getRestrictedValue()));
tmt->addParticleSystem(objectParticleSystemType);
}
}
}
//rotationAllowed
if(modelNode->hasAttribute("rotationAllowed") == true) {
tmt->setRotationAllowed(modelNode->getAttribute("rotationAllowed")->getBoolValue());
}
else if(modelNode->hasChild("rotationAllowed")){
const XmlNode *rotationAllowedNode= modelNode->getChild("rotationAllowed");
tmt->setRotationAllowed(rotationAllowedNode->getAttribute("value")->getBoolValue());
}
else{
tmt->setRotationAllowed(true);
}
//smoothTwoFrameAnim
if(modelNode->hasAttribute("smoothTwoFrameAnim") == true) {
tmt->setSmoothTwoFrameAnim(modelNode->getAttribute("smoothTwoFrameAnim")->getBoolValue());
}
else{
tmt->setSmoothTwoFrameAnim(false);
}
}
}
// Now free up the pixmap memory
for(int i=0; i<objCount; ++i){
objectTypes[i].deletePixels();
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//ambient sounds
ambientSounds.load(dir, tilesetNode->getChild("ambient-sounds"), loadedFileList, sourceXMLFile);
//parameters
const XmlNode *parametersNode= tilesetNode->getChild("parameters");
//water
const XmlNode *waterNode= parametersNode->getChild("water");
waterTex= renderer.newTexture3D(rsGame);
if(waterTex) {
waterTex->setMipmap(false);
waterTex->setWrapMode(Texture::wmRepeat);
}
waterEffects= waterNode->getAttribute("effects")->getBoolValue();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
int waterFrameCount= waterNode->getChildCount();
if(waterTex) {
waterTex->getPixmap()->init(waterFrameCount, 4);
}
for(int i=0; i<waterFrameCount; ++i){
const XmlNode *waterFrameNode= waterNode->getChild("texture", i);
if(waterTex) {
waterTex->getPixmap()->loadSlice(waterFrameNode->getAttribute("path")->getRestrictedValue(currentPath), i);
}
loadedFileList[waterFrameNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,waterFrameNode->getAttribute("path")->getRestrictedValue()));
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//fog
const XmlNode *fogNode= parametersNode->getChild("fog");
fog= fogNode->getAttribute("enabled")->getBoolValue();
if(fog){
fogMode= fogNode->getAttribute("mode")->getIntValue(1, 2);
fogDensity= fogNode->getAttribute("density")->getFloatValue();
fogColor.x= fogNode->getAttribute("color-red")->getFloatValue(0.f, 1.f);
fogColor.y= fogNode->getAttribute("color-green")->getFloatValue(0.f, 1.f);
fogColor.z= fogNode->getAttribute("color-blue")->getFloatValue(0.f, 1.f);
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//sun and moon light colors
const XmlNode *sunLightColorNode= parametersNode->getChild("sun-light");
sunLightColor.x= sunLightColorNode->getAttribute("red")->getFloatValue();
sunLightColor.y= sunLightColorNode->getAttribute("green")->getFloatValue();
sunLightColor.z= sunLightColorNode->getAttribute("blue")->getFloatValue();
const XmlNode *moonLightColorNode= parametersNode->getChild("moon-light");
moonLightColor.x= moonLightColorNode->getAttribute("red")->getFloatValue();
moonLightColor.y= moonLightColorNode->getAttribute("green")->getFloatValue();
moonLightColor.z= moonLightColorNode->getAttribute("blue")->getFloatValue();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//weather
const XmlNode *weatherNode= parametersNode->getChild("weather");
float sunnyProb= weatherNode->getAttribute("sun")->getFloatValue(0.f, 1.f);
float rainyProb= weatherNode->getAttribute("rain")->getFloatValue(0.f, 1.f) + sunnyProb;
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
#ifdef USE_STREFLOP
float rnd= streflop::fabs(static_cast<streflop::Simple>(random.randRange(-1.f, 1.f)));
#else
float rnd= fabs(random.randRange(-1.f, 1.f));
#endif
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
if(rnd < sunnyProb) {
weather= wSunny;
}
else if(rnd < rainyProb) {
weather= wRainy;
}
else {
weather= wSnowy;
}
//printf("==> Weather is: %d rnd = %f [sun: %f rainyProb: %f]",weather,rnd,sunnyProb,rainyProb);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
}
//Exception handling (conversions and so on);
catch(const exception &e) {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());
throw megaglest_runtime_error("Error: " + path + "\n" + e.what());
}
Lang &lang = Lang::getInstance();
lang.loadTilesetStrings(name);
}
