Rampoina
/
MegaGlest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- new commandline options to discover and optional delete unused files in techtrees

This commit is contained in:
Mark Vejvoda 2011-03-15 15:30:28 +00:00
parent 6eab8f905e
commit 7d38aec84a
33 changed files with 609 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
source/g3d_viewer/main.cpp
View File

@ -1072,8 +1072,10 @@ void MainWindow::loadParticle(string path) {
// std::cout << "About to load [" << particlePath << "] from [" << dir << "] unit [" << unitXML << "]" << std::endl;
std::map<string,int> loadedFileList;
UnitParticleSystemType *unitParticleSystemType= new UnitParticleSystemType();
unitParticleSystemType->load(dir, dir + folderDelimiter + particlePath, renderer);
unitParticleSystemType->load(dir, dir + folderDelimiter + particlePath,
renderer,loadedFileList);
unitParticleSystemTypes.push_back(unitParticleSystemType);
for(std::vector<UnitParticleSystemType *>::const_iterator it= unitParticleSystemTypes.begin(); it != unitParticleSystemTypes.end(); ++it) {
@ -1167,8 +1169,10 @@ void MainWindow::loadProjectileParticle(string path) {
// std::cout << "Loaded successfully, loading values..." << std::endl;
std::map<string,int> loadedFileList;
ParticleSystemTypeProjectile *projectileParticleSystemType= new ParticleSystemTypeProjectile();
projectileParticleSystemType->load(dir, dir + folderDelimiter + particlePath,renderer);
projectileParticleSystemType->load(dir,
dir + folderDelimiter + particlePath,renderer, loadedFileList);
// std::cout << "Values loaded, about to read..." << std::endl;
@ -1267,8 +1271,10 @@ void MainWindow::loadSplashParticle(string path) { // uses ParticleSystemTypeSp
// std::cout << "Loaded successfully, loading values..." << std::endl;
std::map<string,int> loadedFileList;
ParticleSystemTypeSplash *splashParticleSystemType= new ParticleSystemTypeSplash();
splashParticleSystemType->load(dir, dir + folderDelimiter + particlePath,renderer); // <---- only that must be splash...
splashParticleSystemType->load(dir, dir + folderDelimiter + particlePath,renderer,
loadedFileList); // <---- only that must be splash...
// std::cout << "Values loaded, about to read..." << std::endl;

5
source/glest_game/game/game.cpp
View File

@ -370,6 +370,7 @@ void Game::load() {
}
void Game::load(LoadGameItem loadTypes) {
std::map<string,int> loadedFileList;
originalDisplayMsgCallback = NetworkInterface::getDisplayMessageFunction();
NetworkInterface::setDisplayMessageFunction(ErrorDisplayMessage);
@ -411,7 +412,7 @@ void Game::load(LoadGameItem loadTypes) {
if((loadTypes & lgt_TileSet) == lgt_TileSet) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
world.loadTileset( config.getPathListForType(ptTilesets,scenarioDir),
tilesetName, &checksum);
tilesetName, &checksum, loadedFileList);
}
// give CPU time to update other things to avoid apperance of hanging
@ -433,7 +434,7 @@ void Game::load(LoadGameItem loadTypes) {
//tech, load before map because of resources
world.loadTech( config.getPathListForType(ptTechs,scenarioDir), techName,
factions, &checksum);
factions, &checksum,loadedFileList);
// Validate the faction setup to ensure we don't have any bad associations
/*

21
source/glest_game/graphics/particle_type.cpp
View File

@ -40,7 +40,8 @@ ParticleSystemType::ParticleSystemType() {
model=NULL;
}
void ParticleSystemType::load(const XmlNode *particleSystemNode, const string &dir,RendererInterface *renderer) {
void ParticleSystemType::load(const XmlNode *particleSystemNode, const string &dir,
RendererInterface *renderer, std::map<string,int> &loadedFileList) {
//texture
const XmlNode *textureNode= particleSystemNode->getChild("texture");
bool textureEnabled= textureNode->getAttribute("value")->getBoolValue();
@ -57,6 +58,7 @@ void ParticleSystemType::load(const XmlNode *particleSystemNode, const string &d
string currentPath = dir;
endPathWithSlash(currentPath);
texture->load(currentPath + textureNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + textureNode->getAttribute("path")->getRestrictedValue()]++;
}
else {
texture= NULL;
@ -73,7 +75,8 @@ void ParticleSystemType::load(const XmlNode *particleSystemNode, const string &d
string currentPath = dir;
endPathWithSlash(currentPath);
model->load(currentPath + path);
model->load(currentPath + path, false, &loadedFileList);
loadedFileList[currentPath + path]++;
}
}
else{
@ -182,14 +185,17 @@ void ParticleSystemType::setValues(AttackParticleSystem *ats){
// class ParticleSystemTypeProjectile
// ===========================================================
void ParticleSystemTypeProjectile::load(const string &dir, const string &path,RendererInterface *renderer) {
void ParticleSystemTypeProjectile::load(const string &dir, const string &path,
RendererInterface *renderer, std::map<string,int> &loadedFileList) {
try{
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *particleSystemNode= xmlTree.getRootNode();
ParticleSystemType::load(particleSystemNode, dir, renderer);
ParticleSystemType::load(particleSystemNode, dir, renderer, loadedFileList);
//trajectory values
const XmlNode *tajectoryNode= particleSystemNode->getChild("trajectory");
@ -240,14 +246,17 @@ ProjectileParticleSystem *ParticleSystemTypeProjectile::create() {
// class ParticleSystemTypeSplash
// ===========================================================
void ParticleSystemTypeSplash::load(const string &dir, const string &path,RendererInterface *renderer) {
void ParticleSystemTypeSplash::load(const string &dir, const string &path,
RendererInterface *renderer, std::map<string,int> &loadedFileList) {
try{
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *particleSystemNode= xmlTree.getRootNode();
ParticleSystemType::load(particleSystemNode, dir, renderer);
ParticleSystemType::load(particleSystemNode, dir, renderer, loadedFileList);
//emission rate fade
const XmlNode *emissionRateFadeNode= particleSystemNode->getChild("emission-rate-fade");

13
source/glest_game/graphics/particle_type.h
View File

@ -44,7 +44,7 @@ using Shared::Xml::XmlNode;
/// A type of particle system
// ===========================================================
class ParticleSystemType{
class ParticleSystemType {
protected:
string type;
Texture2D *texture;
@ -67,7 +67,8 @@ protected:
public:
ParticleSystemType();
void load(const XmlNode *particleSystemNode, const string &dir,RendererInterface *renderer);
void load(const XmlNode *particleSystemNode, const string &dir,
RendererInterface *renderer, std::map<string,int> &loadedFileList);
void setValues(AttackParticleSystem *ats);
bool hasTexture() const { return(texture != NULL); }
bool hasModel() const { return(model != NULL); }
@ -88,7 +89,8 @@ private:
float trajectoryFrequency;
public:
void load(const string &dir, const string &path,RendererInterface *renderer);
void load(const string &dir, const string &path,
RendererInterface *renderer, std::map<string,int> &loadedFileList);
ProjectileParticleSystem *create();
};
@ -97,9 +99,10 @@ public:
// class ParticleSystemTypeSplash
// ===========================================================
class ParticleSystemTypeSplash: public ParticleSystemType{
class ParticleSystemTypeSplash: public ParticleSystemType {
public:
void load(const string &dir, const string &path,RendererInterface *renderer);
void load(const string &dir, const string &path,
RendererInterface *renderer, std::map<string,int> &loadedFileList);
SplashParticleSystem *create();
private:

12
source/glest_game/graphics/unit_particle_type.cpp
View File

@ -29,8 +29,9 @@ namespace Glest{ namespace Game{
// class UnitParticleSystemType
// =====================================================
void UnitParticleSystemType::load(const XmlNode *particleSystemNode, const string &dir, RendererInterface *renderer) {
ParticleSystemType::load(particleSystemNode, dir, renderer);
void UnitParticleSystemType::load(const XmlNode *particleSystemNode, const string &dir,
RendererInterface *renderer, std::map<string,int> &loadedFileList) {
ParticleSystemType::load(particleSystemNode, dir, renderer, loadedFileList);
//radius
const XmlNode *radiusNode= particleSystemNode->getChild("radius");
radius= radiusNode->getAttribute("value")->getFloatValue();
@ -134,14 +135,17 @@ const void UnitParticleSystemType::setValues(UnitParticleSystem *ups){
}
}
void UnitParticleSystemType::load(const string &dir, const string &path, RendererInterface *renderer){
void UnitParticleSystemType::load(const string &dir, const string &path,
RendererInterface *renderer, std::map<string,int> &loadedFileList) {
try{
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *particleSystemNode= xmlTree.getRootNode();
UnitParticleSystemType::load(particleSystemNode, dir, renderer);
UnitParticleSystemType::load(particleSystemNode, dir, renderer,
loadedFileList);
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());

8
source/glest_game/graphics/unit_particle_type.h
View File

@ -42,7 +42,7 @@ using Shared::Xml::XmlNode;
/// A type of particle system
// ===========================================================
class UnitParticleSystemType: public ParticleSystemType{
class UnitParticleSystemType: public ParticleSystemType {
protected:
float radius;
@ -56,8 +56,10 @@ protected:
bool radiusBasedStartenergy;
public:
void load(const XmlNode *particleSystemNode, const string &dir, RendererInterface *newTexture);
void load(const string &dir, const string &path, RendererInterface *newTexture);
void load(const XmlNode *particleSystemNode, const string &dir,
RendererInterface *newTexture, std::map<string,int> &loadedFileList);
void load(const string &dir, const string &path, RendererInterface *newTexture,
std::map<string,int> &loadedFileList);
const void setValues (UnitParticleSystem *uts);
bool hasTexture() const { return(texture != NULL); }
};

143
source/glest_game/main/main.cpp
View File

@ -126,7 +126,7 @@ enum GAME_ARG_TYPE {
GAME_ARG_LOG_PATH,
GAME_ARG_SHOW_INI_SETTINGS,
GAME_ARG_CONVERT_MODELS,
GAME_ARG_CONVERT_TEXTURES,
// GAME_ARG_CONVERT_TEXTURES,
GAME_ARG_DISABLE_BACKTRACE,
GAME_ARG_DISABLE_VBO,
GAME_ARG_VERBOSE_MODE
@ -843,13 +843,15 @@ void printParameterHelp(const char *argv0, bool foundInvalidArgs) {
printf("\n%s\t\t\tdisplays your SDL version information.",GAME_ARGS[GAME_ARG_SDL_INFO]);
printf("\n%s\t\t\tdisplays your LUA version information.",GAME_ARGS[GAME_ARG_LUA_INFO]);
printf("\n%s\t\t\tdisplays your CURL version information.",GAME_ARGS[GAME_ARG_CURL_INFO]);
printf("\n%s=x\t\tdisplays a report detailing any known problems related",GAME_ARGS[GAME_ARG_VALIDATE_TECHTREES]);
printf("\n%s=x=purgeunused\t\tdisplays a report detailing any known problems related",GAME_ARGS[GAME_ARG_VALIDATE_TECHTREES]);
printf("\n \t\tto your selected techtrees game data.");
printf("\n \t\tWhere x is a comma-delimited list of techtrees to validate.");
printf("\n \t\tWhere purgeunused is an optional parameter telling the validation to delete extra files in the techtree that are not used.");
printf("\n \t\texample: %s %s=megapack,vbros_pack_5",argv0,GAME_ARGS[GAME_ARG_VALIDATE_TECHTREES]);
printf("\n%s=x\t\tdisplays a report detailing any known problems related",GAME_ARGS[GAME_ARG_VALIDATE_FACTIONS]);
printf("\n%s=x=purgeunused\t\tdisplays a report detailing any known problems related",GAME_ARGS[GAME_ARG_VALIDATE_FACTIONS]);
printf("\n \t\tto your selected factions game data.");
printf("\n \t\tWhere x is a comma-delimited list of factions to validate.");
printf("\n \t\tWhere purgeunused is an optional parameter telling the validation to delete extra files in the faction that are not used.");
printf("\n \t\t*NOTE: leaving the list empty is the same as running");
printf("\n \t\t%s",GAME_ARGS[GAME_ARG_VALIDATE_TECHTREES]);
printf("\n \t\texample: %s %s=tech,egypt",argv0,GAME_ARGS[GAME_ARG_VALIDATE_FACTIONS]);
@ -869,10 +871,10 @@ void printParameterHelp(const char *argv0, bool foundInvalidArgs) {
printf("\n \t\tWhere keepsmallest is an optional flag indicating to keep original texture if its filesize is smaller than the converted format.");
printf("\n \t\texample: %s %s=techs/megapack/factions/tech/units/castle/models/castle.g3d=png=keepsmallest",argv0,GAME_ARGS[GAME_ARG_CONVERT_MODELS]);
printf("\n%s=x=textureformat\t\t\tconvert a texture file or folder to the format textureformat.",GAME_ARGS[GAME_ARG_CONVERT_TEXTURES]);
printf("\n \t\tWhere x is a filename or folder containing the texture(s).");
printf("\n \t\tWhere textureformat is a supported texture format to convert to (tga,bmp,jpg,png).");
printf("\n \t\texample: %s %s=data/core/misc_textures/fire_particle.tga=png",argv0,GAME_ARGS[GAME_ARG_CONVERT_TEXTURES]);
// printf("\n%s=x=textureformat\t\t\tconvert a texture file or folder to the format textureformat.",GAME_ARGS[GAME_ARG_CONVERT_TEXTURES]);
// printf("\n \t\tWhere x is a filename or folder containing the texture(s).");
// printf("\n \t\tWhere textureformat is a supported texture format to convert to (tga,bmp,jpg,png).");
// printf("\n \t\texample: %s %s=data/core/misc_textures/fire_particle.tga=png",argv0,GAME_ARGS[GAME_ARG_CONVERT_TEXTURES]);
printf("\n%s\t\tdisables stack backtrace on errors.",GAME_ARGS[GAME_ARG_DISABLE_BACKTRACE]);
printf("\n%s\t\tdisables trying to use Vertex Buffer Objects.",GAME_ARGS[GAME_ARG_DISABLE_VBO]);
@ -1098,9 +1100,11 @@ void setupLogging(Config &config, bool haveSpecialOutputCommandLineOption) {
void runTechValidationReport(int argc, char** argv) {
//disableBacktrace=true;
printf("====== Started Validation ======\n");
bool purgeUnusedFiles = false;
Config &config = Config::getInstance();
// Did the user pass a specific list of factions to validate?
std::vector<string> filteredFactionList;
if(hasCommandArgument(argc, argv,string(GAME_ARGS[GAME_ARG_VALIDATE_FACTIONS]) + string("=")) == true) {
@ -1122,10 +1126,15 @@ void runTechValidationReport(int argc, char** argv) {
printf("%s\n",filteredFactionList[idx].c_str());
}
}
if(paramPartTokens.size() >= 3) {
if(paramPartTokens[2] == "purgeunused") {
purgeUnusedFiles = true;
printf("*NOTE All unused faction files will be deleted!\n");
}
}
}
}
Config &config = Config::getInstance();
vector<string> results;
findDirs(config.getPathListForType(ptTechs), results);
vector<string> techTreeFiles = results;
@ -1148,6 +1157,13 @@ void runTechValidationReport(int argc, char** argv) {
printf("%s\n",filteredTechTreeList[idx].c_str());
}
}
if(paramPartTokens.size() >= 3) {
if(paramPartTokens[2] == "purgeunused") {
purgeUnusedFiles = true;
printf("*NOTE All unused techtree files will be deleted!\n");
}
}
}
}
@ -1170,7 +1186,7 @@ void runTechValidationReport(int argc, char** argv) {
std::find(filteredTechTreeList.begin(),filteredTechTreeList.end(),techName) != filteredTechTreeList.end()) {
vector<string> factionsList;
findAll(techPath + techName + "/factions/*.", factionsList, false, false);
findDirs(techPath + techName + "/factions/", factionsList, false, false);
if(factionsList.size() > 0) {
Checksum checksum;
@ -1193,7 +1209,26 @@ void runTechValidationReport(int argc, char** argv) {
if(factions.size() > 0) {
bool techtree_errors = false;
world.loadTech(config.getPathListForType(ptTechs,""), techName, factions, &checksum);
std::map<string,int> loadedFileList;
vector<string> pathList = config.getPathListForType(ptTechs,"");
world.loadTech(pathList, techName, factions, &checksum, loadedFileList);
// Fixup paths with ..
{
std::map<string,int> newLoadedFileList;
for( std::map<string,int>::iterator iterMap = loadedFileList.begin();
iterMap != loadedFileList.end(); ++iterMap) {
string loadedFile = iterMap->first;
replaceAll(loadedFile,"//","/");
replaceAll(loadedFile,"\\\\","\\");
updatePathClimbingParts(loadedFile);
newLoadedFileList[loadedFile] = iterMap->second;
}
loadedFileList = newLoadedFileList;
}
// Validate the faction setup to ensure we don't have any bad associations
std::vector<std::string> resultErrors = world.validateFactionTypes();
if(resultErrors.size() > 0) {
@ -1234,6 +1269,78 @@ void runTechValidationReport(int argc, char** argv) {
printf("%s",errorText.c_str());
}
// Now check for unused files in the techtree
std::map<string,int> foundFileList;
for(unsigned int i = 0; i < pathList.size(); ++i) {
string path = pathList[i];
endPathWithSlash(path);
path = path + techName + "/";
vector<string> foundFiles = getFolderTreeContentsListRecursively(path + "*.", "");
for(unsigned int j = 0; j < foundFiles.size(); ++j) {
string file = foundFiles[j];
if( file.find("loading_screen") != string::npos ||
file.find("preview_screen") != string::npos) {
continue;
}
if(file.find("/factions/") != string::npos) {
bool includeFaction = false;
for ( set<string>::iterator it = factions.begin(); it != factions.end(); ++it ) {
string currentFaction = *it;
if(file.find("/factions/" + currentFaction) != string::npos) {
includeFaction = true;
break;
}
}
if(includeFaction == false) {
continue;
}
}
replaceAll(file,"//","/");
replaceAll(file,"\\\\","\\");
foundFileList[file]++;
}
}
printf("Found techtree filecount = %lu, used = %lu\n",(unsigned long)foundFileList.size(),(unsigned long)loadedFileList.size());
// for( std::map<string,int>::iterator iterMap = loadedFileList.begin();
// iterMap != loadedFileList.end(); ++iterMap) {
// string foundFile = iterMap->first;
//
// if(foundFile.find("golem_ack1.wav") != string::npos) {
// printf("FOUND file [%s]\n",foundFile.c_str());
// }
// }
bool foundUnusedFile = false;
for( std::map<string,int>::iterator iterMap = foundFileList.begin();
iterMap != foundFileList.end(); ++iterMap) {
string foundFile = iterMap->first;
if(loadedFileList.find(foundFile) == loadedFileList.end()) {
if(foundUnusedFile == false) {
printf("\nWarning, unused files were detected - START:\n=====================\n");
}
foundUnusedFile = true;
printf("[%s]\n",foundFile.c_str());
string fileName = extractFileFromDirectoryPath(foundFile);
if(loadedFileList.find(fileName) != loadedFileList.end()) {
printf("possible match on [%s] ?\n",loadedFileList.find(fileName)->first.c_str());
}
else if(purgeUnusedFiles == true) {
removeFile(foundFile);
}
}
}
if(foundUnusedFile == true) {
printf("\nWarning, unused files were detected - END:\n");
}
if(techtree_errors == false) {
printf("\nValidation found NO ERRORS for techPath [%s] techName [%s] factions checked (count = %d):\n",techPath.c_str(), techName.c_str(),(int)factions.size());
for ( set<string>::iterator it = factions.begin(); it != factions.end(); ++it ) {
@ -1895,12 +2002,12 @@ int glestMain(int argc, char** argv) {
}
}
if(hasCommandArgument(argc, argv,GAME_ARGS[GAME_ARG_CONVERT_TEXTURES]) == true) {
//!!!
printf("\nComing soon (not yet implemented)\n\n");
delete mainWindow;
return -1;
}
// if(hasCommandArgument(argc, argv,GAME_ARGS[GAME_ARG_CONVERT_TEXTURES]) == true) {
// //!!!
// printf("\nComing soon (not yet implemented)\n\n");
// delete mainWindow;
// return -1;
// }
if( hasCommandArgument(argc, argv,GAME_ARGS[GAME_ARG_VALIDATE_TECHTREES]) == true ||
hasCommandArgument(argc, argv,GAME_ARGS[GAME_ARG_VALIDATE_FACTIONS]) == true) {

11
source/glest_game/menu/menu_state_connected_game.cpp
View File

@ -501,6 +501,7 @@ void MenuStateConnectedGame::mouseClick(int x, int y, MouseButton mouseButton){
ftpClientThread->addMapToRequests(getMissingMapFromFTPServer);
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList[getMissingMapFromFTPServer] = pair<int,string>(0,"");
safeMutexFTPProgress.ReleaseLock();
}
}
else if(ftpMissingDataType == ftpmsg_MissingTileset) {
@ -519,6 +520,7 @@ void MenuStateConnectedGame::mouseClick(int x, int y, MouseButton mouseButton){
ftpClientThread->addTilesetToRequests(getMissingTilesetFromFTPServer);
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList[getMissingTilesetFromFTPServer] = pair<int,string>(0,"");
safeMutexFTPProgress.ReleaseLock();
}
}
else if(ftpMissingDataType == ftpmsg_MissingTechtree) {
@ -537,6 +539,7 @@ void MenuStateConnectedGame::mouseClick(int x, int y, MouseButton mouseButton){
ftpClientThread->addTechtreeToRequests(getMissingTechtreeFromFTPServer);
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList[getMissingTechtreeFromFTPServer] = pair<int,string>(0,"");
safeMutexFTPProgress.ReleaseLock();
}
}
}
@ -1989,14 +1992,16 @@ void MenuStateConnectedGame::FTPClient_CallbackEvent(string itemName, FTP_Client
}
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Got FTP Callback for [%s] current file [%s] fileProgress = %d [now = %f, total = %f]\n",itemName.c_str(),stats->currentFilename.c_str(), fileProgress,stats->download_now,stats->download_total);
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList[itemName] = pair<int,string>(fileProgress,stats->currentFilename);
safeMutexFTPProgress.ReleaseLock();
}
}
else if(type == ftp_cct_Map) {
getMissingMapFromFTPServerInProgress = false;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Got FTP Callback for [%s] result = %d\n",itemName.c_str(),result);
MutexSafeWrapper safeMutexFTPProgress(ftpClientThread->getProgressMutex(),string(__FILE__) + "_" + intToStr(__LINE__));
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList.erase(itemName);
safeMutexFTPProgress.ReleaseLock();
@ -2034,7 +2039,7 @@ void MenuStateConnectedGame::FTPClient_CallbackEvent(string itemName, FTP_Client
getMissingTilesetFromFTPServerInProgress = false;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Got FTP Callback for [%s] result = %d\n",itemName.c_str(),result);
MutexSafeWrapper safeMutexFTPProgress(ftpClientThread->getProgressMutex(),string(__FILE__) + "_" + intToStr(__LINE__));
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList.erase(itemName);
safeMutexFTPProgress.ReleaseLock(true);
@ -2092,7 +2097,7 @@ void MenuStateConnectedGame::FTPClient_CallbackEvent(string itemName, FTP_Client
getMissingTechtreeFromFTPServerInProgress = false;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Got FTP Callback for [%s] result = %d\n",itemName.c_str(),result);
MutexSafeWrapper safeMutexFTPProgress(ftpClientThread->getProgressMutex(),string(__FILE__) + "_" + intToStr(__LINE__));
MutexSafeWrapper safeMutexFTPProgress((ftpClientThread != NULL ? ftpClientThread->getProgressMutex() : NULL),string(__FILE__) + "_" + intToStr(__LINE__));
fileFTPProgressList.erase(itemName);
safeMutexFTPProgress.ReleaseLock(true);

86
source/glest_game/types/command_type.cpp
View File

@ -42,7 +42,9 @@ CommandClass CommandType::getClass() const{
return commandTypeClass;
}
void CommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
void CommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
this->id= id;
@ -55,10 +57,11 @@ void CommandType::load(int id, const XmlNode *n, const string &dir, const TechTr
string currentPath = dir;
endPathWithSlash(currentPath);
image->load(currentPath + imageNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + imageNode->getAttribute("path")->getRestrictedValue()]++;
//unit requirements
const XmlNode *unitRequirementsNode= n->getChild("unit-requirements");
for(int i=0; i<unitRequirementsNode->getChildCount(); ++i){
for(int i = 0; i < unitRequirementsNode->getChildCount(); ++i) {
const XmlNode *unitNode= unitRequirementsNode->getChild("unit", i);
string name= unitNode->getAttribute("name")->getRestrictedValue();
unitReqs.push_back(ft->getUnitType(name));
@ -66,7 +69,7 @@ void CommandType::load(int id, const XmlNode *n, const string &dir, const TechTr
//upgrade requirements
const XmlNode *upgradeRequirementsNode= n->getChild("upgrade-requirements");
for(int i=0; i<upgradeRequirementsNode->getChildCount(); ++i){
for(int i = 0; i < upgradeRequirementsNode->getChildCount(); ++i) {
const XmlNode *upgradeReqNode= upgradeRequirementsNode->getChild("upgrade", i);
string name= upgradeReqNode->getAttribute("name")->getRestrictedValue();
upgradeReqs.push_back(ft->getUpgradeType(name));
@ -107,8 +110,10 @@ string StopCommandType::toString() const{
return lang.get("Stop");
}
void StopCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
CommandType::load(id, n, dir, tt, ft, ut);
void StopCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//stop
string skillName= n->getChild("stop-skill")->getAttribute("value")->getRestrictedValue();
@ -130,8 +135,10 @@ void MoveCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateMove(unit);
}
void MoveCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
CommandType::load(id, n, dir, tt, ft, ut);
void MoveCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//move
string skillName= n->getChild("move-skill")->getAttribute("value")->getRestrictedValue();
@ -177,8 +184,10 @@ void AttackCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateAttack(unit);
}
void AttackCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
CommandType::load(id, n, dir, tt, ft, ut);
void AttackCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//move
string skillName= n->getChild("move-skill")->getAttribute("value")->getRestrictedValue();
@ -267,8 +276,10 @@ void AttackStoppedCommandType::update(UnitUpdater *unitUpdater, Unit *unit) cons
unitUpdater->updateAttackStopped(unit);
}
void AttackStoppedCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
CommandType::load(id, n, dir, tt, ft, ut);
void AttackStoppedCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//stop
string skillName= n->getChild("stop-skill")->getAttribute("value")->getRestrictedValue();
@ -352,10 +363,11 @@ void BuildCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateBuild(unit);
}
void BuildCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
CommandType::load(id, n, dir, tt, ft, ut);
void BuildCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//move
string skillName= n->getChild("move-skill")->getAttribute("value")->getRestrictedValue();
@ -380,11 +392,14 @@ void BuildCommandType::load(int id, const XmlNode *n, const string &dir, const T
for(int i=0; i<startSoundNode->getChildCount(); ++i){
const XmlNode *soundFileNode= startSoundNode->getChild("sound-file", i);
string path= soundFileNode->getAttribute("path")->getRestrictedValue();
trimPathWithStartingSlash(path);
StaticSound *sound= new StaticSound();
string currentPath = dir;
endPathWithSlash(currentPath);
sound->load(currentPath + path);
loadedFileList[currentPath + path]++;
startSounds[i]= sound;
}
}
@ -396,11 +411,14 @@ void BuildCommandType::load(int id, const XmlNode *n, const string &dir, const T
for(int i=0; i<builtSoundNode->getChildCount(); ++i){
const XmlNode *soundFileNode= builtSoundNode->getChild("sound-file", i);
string path= soundFileNode->getAttribute("path")->getRestrictedValue();
trimPathWithStartingSlash(path);
StaticSound *sound= new StaticSound();
string currentPath = dir;
endPathWithSlash(currentPath);
sound->load(currentPath + path);
loadedFileList[currentPath + path]++;
builtSounds[i]= sound;
}
}
@ -443,9 +461,10 @@ void HarvestCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateHarvest(unit);
}
void HarvestCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
CommandType::load(id, n, dir, tt, ft, ut);
void HarvestCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//move
string skillName= n->getChild("move-skill")->getAttribute("value")->getRestrictedValue();
@ -523,11 +542,10 @@ void RepairCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateRepair(unit);
}
void RepairCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
CommandType::load(id, n, dir, tt, ft, ut);
void RepairCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//move
string skillName= n->getChild("move-skill")->getAttribute("value")->getRestrictedValue();
@ -601,10 +619,10 @@ void ProduceCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateProduce(unit);
}
void ProduceCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
CommandType::load(id, n, dir, tt, ft, ut);
void ProduceCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//produce
string skillName= n->getChild("produce-skill")->getAttribute("value")->getRestrictedValue();
@ -666,9 +684,11 @@ void UpgradeCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateUpgrade(unit);
}
void UpgradeCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
void UpgradeCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut);
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//upgrade
string skillName= n->getChild("upgrade-skill")->getAttribute("value")->getRestrictedValue();
@ -721,10 +741,10 @@ void MorphCommandType::update(UnitUpdater *unitUpdater, Unit *unit) const{
unitUpdater->updateMorph(unit);
}
void MorphCommandType::load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut){
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
CommandType::load(id, n, dir, tt, ft, ut);
void MorphCommandType::load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList) {
CommandType::load(id, n, dir, tt, ft, ut, loadedFileList);
//morph skill
string skillName= n->getChild("morph-skill")->getAttribute("value")->getRestrictedValue();

43
source/glest_game/types/command_type.h
View File

@ -81,7 +81,9 @@ public:
id = -1;
}
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const= 0;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const= 0;
virtual string toString() const= 0;
virtual const ProducibleType *getProduced() const {return NULL;}
@ -114,7 +116,8 @@ private:
public:
StopCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt,
const FactionType *ft, const UnitType &ut, std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
virtual Queueability isQueuable() const {return qNever;}
@ -135,7 +138,9 @@ private:
public:
MoveCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
@ -156,7 +161,9 @@ private:
public:
AttackCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
@ -178,7 +185,9 @@ private:
public:
AttackStoppedCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
@ -204,7 +213,9 @@ public:
BuildCommandType();
~BuildCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
@ -235,7 +246,9 @@ private:
public:
HarvestCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
virtual Queueability isQueuable() const {return qOnRequest;}
@ -267,7 +280,9 @@ public:
RepairCommandType();
~RepairCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
@ -294,7 +309,9 @@ private:
public:
ProduceCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string getReqDesc() const;
virtual string toString() const;
@ -319,7 +336,9 @@ private:
public:
UpgradeCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
virtual string getReqDesc() const;
@ -344,7 +363,9 @@ private:
public:
MorphCommandType();
virtual void update(UnitUpdater *unitUpdater, Unit *unit) const;
virtual void load(int id, const XmlNode *n, const string &dir, const TechTree *tt, const FactionType *ft, const UnitType &ut);
virtual void load(int id, const XmlNode *n, const string &dir,
const TechTree *tt, const FactionType *ft, const UnitType &ut,
std::map<string,int> &loadedFileList);
virtual string getDesc(const TotalUpgrade *totalUpgrade) const;
virtual string toString() const;
virtual string getReqDesc() const;

53
source/glest_game/types/faction_type.cpp
View File

@ -30,17 +30,21 @@ namespace Glest{ namespace Game{
// Class FactionType
// ======================================================
FactionType::FactionType(){
FactionType::FactionType() {
music = NULL;
personalityType = fpt_Normal;
}
//load a faction, given a directory
void FactionType::load(const string &dir, const TechTree *techTree, Checksum* checksum,Checksum *techtreeChecksum) {
void FactionType::load(const string &dir, const TechTree *techTree, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,int> &loadedFileList) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
name= lastDir(dir);
string currentPath = dir;
endPathWithSlash(currentPath);
name= lastDir(currentPath);
// Add special Observer Faction
Lang &lang= Lang::getInstance();
@ -52,75 +56,78 @@ void FactionType::load(const string &dir, const TechTree *techTree, Checksum* ch
if(personalityType == fpt_Normal) {
// a1) preload units
string unitsPath= dir + "/units/*.";
string unitsPath= currentPath + "units/*.";
vector<string> unitFilenames;
findAll(unitsPath, unitFilenames);
unitTypes.resize(unitFilenames.size());
for(int i=0; i<unitTypes.size(); ++i) {
string str= dir + "/units/" + unitFilenames[i];
for(int i = 0; i < unitTypes.size(); ++i) {
string str= currentPath + "units/" + unitFilenames[i];
unitTypes[i].preLoad(str);
SDL_PumpEvents();
}
// a2) preload upgrades
string upgradesPath= dir + "/upgrades/*.";
string upgradesPath= currentPath + "upgrades/*.";
vector<string> upgradeFilenames;
findAll(upgradesPath, upgradeFilenames, false, false);
upgradeTypes.resize(upgradeFilenames.size());
for(int i=0; i<upgradeTypes.size(); ++i) {
string str= dir + "/upgrades/" + upgradeFilenames[i];
for(int i = 0; i < upgradeTypes.size(); ++i) {
string str= currentPath + "upgrades/" + upgradeFilenames[i];
upgradeTypes[i].preLoad(str);
SDL_PumpEvents();
}
// b1) load units
try{
try {
Logger &logger= Logger::getInstance();
int progressBaseValue=logger.getProgress();
for(int i = 0; i < unitTypes.size(); ++i) {
string str= dir + "/units/" + unitTypes[i].getName();
unitTypes[i].load(i, str, techTree, this, checksum,techtreeChecksum);
string str= currentPath + "units/" + unitTypes[i].getName();
unitTypes[i].load(i, str, techTree, this, checksum,techtreeChecksum,
loadedFileList);
logger.setProgress(progressBaseValue+(int)((((double)i + 1.0) / (double)unitTypes.size()) * 100.0/techTree->getTypeCount()));
SDL_PumpEvents();
}
}
catch(const exception &e) {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());
throw runtime_error("Error loading units: "+ dir + "\n" + e.what());
throw runtime_error("Error loading units: "+ currentPath + "\n" + e.what());
}
// b2) load upgrades
try{
for(int i = 0; i < upgradeTypes.size(); ++i) {
string str= dir + "/upgrades/" + upgradeTypes[i].getName();
upgradeTypes[i].load(str, techTree, this, checksum,techtreeChecksum);
string str= currentPath + "upgrades/" + upgradeTypes[i].getName();
upgradeTypes[i].load(str, techTree, this, checksum,techtreeChecksum,
loadedFileList);
SDL_PumpEvents();
}
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());
throw runtime_error("Error loading upgrades: "+ dir + "\n" + e.what());
throw runtime_error("Error loading upgrades: "+ currentPath + "\n" + e.what());
}
//open xml file
string currentPath = dir;
endPathWithSlash(currentPath);
string path= currentPath + name + ".xml";
checksum->addFile(path);
techtreeChecksum->addFile(path);
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *factionNode= xmlTree.getRootNode();
//read starting resources
const XmlNode *startingResourcesNode= factionNode->getChild("starting-resources");
startingResources.resize(startingResourcesNode->getChildCount());
for(int i=0; i<startingResources.size(); ++i){
for(int i = 0; i < startingResources.size(); ++i) {
const XmlNode *resourceNode= startingResourcesNode->getChild("resource", i);
string name= resourceNode->getAttribute("name")->getRestrictedValue();
int amount= resourceNode->getAttribute("amount")->getIntValue();
@ -131,7 +138,7 @@ void FactionType::load(const string &dir, const TechTree *techTree, Checksum* ch
//read starting units
const XmlNode *startingUnitsNode= factionNode->getChild("starting-units");
for(int i=0; i<startingUnitsNode->getChildCount(); ++i){
for(int i = 0; i < startingUnitsNode->getChildCount(); ++i) {
const XmlNode *unitNode= startingUnitsNode->getChild("unit", i);
string name= unitNode->getAttribute("name")->getRestrictedValue();
int amount= unitNode->getAttribute("amount")->getIntValue();
@ -143,12 +150,10 @@ void FactionType::load(const string &dir, const TechTree *techTree, Checksum* ch
//read music
const XmlNode *musicNode= factionNode->getChild("music");
bool value= musicNode->getAttribute("value")->getBoolValue();
if(value){
if(value) {
music= new StrSound();
string currentPath = dir;
endPathWithSlash(currentPath);
music->open(currentPath + musicNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + musicNode->getAttribute("path")->getRestrictedValue()]++;
}
}
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);

5
source/glest_game/types/faction_type.h
View File

@ -27,7 +27,7 @@ namespace Glest{ namespace Game{
/// Each of the possible factions the user can select
// =====================================================
class FactionType{
class FactionType {
private:
typedef pair<const UnitType*, int> PairPUnitTypeInt;
typedef vector<UnitType> UnitTypes;
@ -47,7 +47,8 @@ private:
public:
//init
FactionType();
void load(const string &dir, const TechTree *techTree, Checksum* checksum,Checksum *techtreeChecksum);
void load(const string &dir, const TechTree *techTree, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,int> &loadedFileList);
~FactionType();
//get

4
source/glest_game/types/object_type.cpp
View File

@ -38,9 +38,9 @@ ObjectType::~ObjectType(){
//Logger::getInstance().add("ObjectType", true);
}
void ObjectType::loadModel(const string &path){
void ObjectType::loadModel(const string &path, std::map<string,int> *loadedFileList) {
Model *model= Renderer::getInstance().newModel(rsGame);
model->load(path);
model->load(path, false, loadedFileList);
color= Vec3f(0.f);
if(model->getMeshCount()>0 && model->getMesh(0)->getTexture(0) != NULL) {
const Pixmap2D *p= model->getMesh(0)->getTexture(0)->getPixmapConst();

2
source/glest_game/types/object_type.h
View File

@ -56,7 +56,7 @@ public:
~ObjectType();
void init(int modelCount, int objectClass, bool walkable, int height);
void loadModel(const string &path);
void loadModel(const string &path, std::map<string,int> *loadedFileList=NULL);
void addParticleSystem(ObjectParticleSystemType *particleSystem);
Model *getModel(int i) {return models[i];}

31
source/glest_game/types/resource_type.cpp
View File

@ -45,7 +45,8 @@ ResourceType::~ResourceType(){
}
}
void ResourceType::load(const string &dir, Checksum* checksum, Checksum *techtreeChecksum) {
void ResourceType::load(const string &dir, Checksum* checksum, Checksum *techtreeChecksum,
std::map<string,int> &loadedFileList) {
string path, str;
Renderer &renderer= Renderer::getInstance();
@ -66,16 +67,19 @@ void ResourceType::load(const string &dir, Checksum* checksum, Checksum *techtre
//tree
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *resourceNode= xmlTree.getRootNode();
//image
const XmlNode *imageNode= resourceNode->getChild("image");
image= renderer.newTexture2D(rsGame);
image->load(currentPath + imageNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + imageNode->getAttribute("path")->getRestrictedValue()]++;
//type
const XmlNode *typeNode= resourceNode->getChild("type");
resourceClass= strToRc(typeNode->getAttribute("value")->getRestrictedValue());
resourceClass = strToRc(typeNode->getAttribute("value")->getRestrictedValue());
switch(resourceClass)
{
@ -83,21 +87,25 @@ void ResourceType::load(const string &dir, Checksum* checksum, Checksum *techtre
{
//model
const XmlNode *modelNode= typeNode->getChild("model");
string path= currentPath + modelNode->getAttribute("path")->getRestrictedValue();
string modelPath= currentPath + modelNode->getAttribute("path")->getRestrictedValue();
model= renderer.newModel(rsGame);
model->load(path);
model->load(modelPath, false, &loadedFileList);
loadedFileList[modelPath]++;
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){
if(particleEnabled == true) {
for(int k= 0; k < particleNode->getChildCount(); ++k) {
const XmlNode *particleFileNode= particleNode->getChild("particle-file", k);
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
string particlePath= particleFileNode->getAttribute("path")->getRestrictedValue();
ObjectParticleSystemType *objectParticleSystemType= new ObjectParticleSystemType();
objectParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance());
objectParticleSystemType->load(dir, currentPath + particlePath,
&Renderer::getInstance(), loadedFileList);
loadedFileList[currentPath + particlePath]++;
particleTypes.push_back(objectParticleSystemType);
}
}
@ -110,7 +118,6 @@ void ResourceType::load(const string &dir, Checksum* checksum, Checksum *techtre
//resource number
const XmlNode *resourceNumberNode= typeNode->getChild("resource-number");
resourceNumber= resourceNumberNode->getAttribute("value")->getIntValue();
}
break;
@ -137,11 +144,9 @@ void ResourceType::load(const string &dir, Checksum* checksum, Checksum *techtre
case rcStatic:
{
//recoup_cost
if(typeNode->hasChild("recoup_cost") == true)
{
if(typeNode->hasChild("recoup_cost") == true) {
const XmlNode *recoup_costNode= typeNode->getChild("recoup_cost");
if(recoup_costNode != NULL)
{
if(recoup_costNode != NULL) {
recoup_cost= recoup_costNode->getAttribute("value")->getBoolValue();
}
}

3
source/glest_game/types/resource_type.h
View File

@ -53,7 +53,8 @@ private:
public:
ResourceType();
~ResourceType();
void load(const string &dir, Checksum* checksum,Checksum *techtreeChecksum);
void load(const string &dir, Checksum* checksum,Checksum *techtreeChecksum,
std::map<string,int> &loadedFileList);
//get
int getClass() const {return resourceClass;}

52
source/glest_game/types/skill_type.cpp
View File

@ -32,16 +32,17 @@ namespace Glest{ namespace Game{
// class SkillType
// =====================================================
SkillType::~SkillType(){
SkillType::~SkillType() {
deleteValues(sounds.getSounds().begin(), sounds.getSounds().end());
//remove unitParticleSystemTypes
while(!unitParticleSystemTypes.empty()){
while(!unitParticleSystemTypes.empty()) {
delete unitParticleSystemTypes.back();
unitParticleSystemTypes.pop_back();
}
}
void SkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt, const FactionType *ft){
void SkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt,
const FactionType *ft, std::map<string,int> &loadedFileList) {
//name
name= sn->getChild("name")->getAttribute("value")->getRestrictedValue();
@ -65,43 +66,45 @@ void SkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt, c
animation= Renderer::getInstance().newModel(rsGame);
string currentPath = dir;
endPathWithSlash(currentPath);
animation->load(currentPath + path);
animation->load(currentPath + path, false, &loadedFileList);
loadedFileList[currentPath + path]++;
//particles
if(sn->hasChild("particles")){
if(sn->hasChild("particles")) {
const XmlNode *particleNode= sn->getChild("particles");
bool particleEnabled= particleNode->getAttribute("value")->getBoolValue();
if(particleEnabled){
for(int i=0; i<particleNode->getChildCount(); ++i){
if(particleEnabled) {
for(int i = 0; i < particleNode->getChildCount(); ++i) {
const XmlNode *particleFileNode= particleNode->getChild("particle-file", i);
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
UnitParticleSystemType *unitParticleSystemType= new UnitParticleSystemType();
unitParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance());
unitParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance(),
loadedFileList);
loadedFileList[currentPath + path]++;
unitParticleSystemTypes.push_back(unitParticleSystemType);
}
}
}
//sound
const XmlNode *soundNode= sn->getChild("sound");
if(soundNode->getAttribute("enabled")->getBoolValue()){
if(soundNode->getAttribute("enabled")->getBoolValue()) {
soundStartTime= soundNode->getAttribute("start-time")->getFloatValue();
sounds.resize(soundNode->getChildCount());
for(int i=0; i<soundNode->getChildCount(); ++i){
for(int i = 0; i < soundNode->getChildCount(); ++i) {
const XmlNode *soundFileNode= soundNode->getChild("sound-file", i);
string path= soundFileNode->getAttribute("path")->getRestrictedValue();
trimPathWithStartingSlash(path);
StaticSound *sound= new StaticSound();
sound->load(currentPath + path);
loadedFileList[currentPath + path]++;
sounds[i]= sound;
}
}
}
string SkillType::skillClassToStr(SkillClass skillClass){
string SkillType::skillClassToStr(SkillClass skillClass) {
switch(skillClass){
case scStop: return "Stop";
case scMove: return "Move";
@ -188,8 +191,9 @@ AttackSkillType::~AttackSkillType() {
deleteValues(projSounds.getSounds().begin(), projSounds.getSounds().end());
}
void AttackSkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt, const FactionType *ft) {
SkillType::load(sn, dir, tt, ft);
void AttackSkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt,
const FactionType *ft, std::map<string,int> &loadedFileList) {
SkillType::load(sn, dir, tt, ft, loadedFileList);
string currentPath = dir;
endPathWithSlash(currentPath);
@ -244,7 +248,8 @@ void AttackSkillType::load(const XmlNode *sn, const string &dir, const TechTree
if(particleEnabled){
string path= particleNode->getAttribute("path")->getRestrictedValue();
projectileParticleSystemType= new ParticleSystemTypeProjectile();
projectileParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance());
projectileParticleSystemType->load(dir, currentPath + path,
&Renderer::getInstance(), loadedFileList);
}
//proj sounds
@ -255,8 +260,11 @@ void AttackSkillType::load(const XmlNode *sn, const string &dir, const TechTree
for(int i=0; i<soundNode->getChildCount(); ++i){
const XmlNode *soundFileNode= soundNode->getChild("sound-file", i);
string path= soundFileNode->getAttribute("path")->getRestrictedValue();
trimPathWithStartingSlash(path);
StaticSound *sound= new StaticSound();
sound->load(currentPath + path);
loadedFileList[currentPath + path]++;
projSounds[i]= sound;
}
}
@ -275,7 +283,8 @@ void AttackSkillType::load(const XmlNode *sn, const string &dir, const TechTree
if(particleEnabled){
string path= particleNode->getAttribute("path")->getRestrictedValue();
splashParticleSystemType= new ParticleSystemTypeSplash();
splashParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance());
splashParticleSystemType->load(dir, currentPath + path,
&Renderer::getInstance(),loadedFileList);
}
}
}
@ -397,8 +406,9 @@ DieSkillType::DieSkillType(){
skillClass= scDie;
}
void DieSkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt, const FactionType *ft){
SkillType::load(sn, dir, tt, ft);
void DieSkillType::load(const XmlNode *sn, const string &dir, const TechTree *tt,
const FactionType *ft, std::map<string,int> &loadedFileList) {
SkillType::load(sn, dir, tt, ft, loadedFileList);
fade= sn->getChild("fade")->getAttribute("value")->getBoolValue();
}

11
source/glest_game/types/skill_type.h
View File

@ -72,7 +72,7 @@ typedef list<UnitParticleSystemType*> UnitParticleSystemTypes;
/// A basic action that an unit can perform
// =====================================================
class SkillType{
class SkillType {
protected:
@ -91,7 +91,8 @@ public:
public:
//varios
virtual ~SkillType();
virtual void load(const XmlNode *sn, const string &dir, const TechTree *tt, const FactionType *ft);
virtual void load(const XmlNode *sn, const string &dir, const TechTree *tt,
const FactionType *ft, std::map<string,int> &loadedFileList);
//get
const string &getName() const {return name;}
@ -160,7 +161,8 @@ private:
public:
AttackSkillType();
~AttackSkillType();
virtual void load(const XmlNode *sn, const string &dir, const TechTree *tt, const FactionType *ft);
virtual void load(const XmlNode *sn, const string &dir, const TechTree *tt,
const FactionType *ft, std::map<string,int> &loadedFileList);
virtual string toString() const;
//get
@ -279,7 +281,8 @@ public:
DieSkillType();
bool getFade() const {return fade;}
virtual void load(const XmlNode *sn, const string &dir, const TechTree *tt, const FactionType *ft);
virtual void load(const XmlNode *sn, const string &dir, const TechTree *tt,
const FactionType *ft, std::map<string,int> &loadedFileList);
virtual string toString() const;
};

55
source/glest_game/types/tech_tree.cpp
View File

@ -32,7 +32,8 @@ namespace Glest{ namespace Game{
// class TechTree
// =====================================================
Checksum TechTree::loadTech(const vector<string> pathList, const string &techName, set<string> &factions, Checksum* checksum) {
Checksum TechTree::loadTech(const vector<string> pathList, const string &techName,
set<string> &factions, Checksum* checksum, std::map<string,int> &loadedFileList) {
Checksum techtreeChecksum;
for(int idx = 0; idx < pathList.size(); idx++) {
string currentPath = pathList[idx];
@ -40,44 +41,47 @@ Checksum TechTree::loadTech(const vector<string> pathList, const string &techNam
string path = currentPath + techName;
if(isdir(path.c_str()) == true) {
load(path, factions, checksum, &techtreeChecksum);
load(path, factions, checksum, &techtreeChecksum, loadedFileList);
break;
}
}
return techtreeChecksum;
}
void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum, Checksum *techtreeChecksum) {
void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,int> &loadedFileList) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
string str;
string currentPath = dir;
endPathWithSlash(currentPath);
vector<string> filenames;
string name= lastDir(dir);
string name= lastDir(currentPath);
Logger::getInstance().add("TechTree: "+ formatString(name), true);
//load resources
str= dir+"/resources/*.";
string str= currentPath + "resources/*.";
try{
try {
findAll(str, filenames);
resourceTypes.resize(filenames.size());
for(int i=0; i<filenames.size(); ++i){
str=dir+"/resources/"+filenames[i];
resourceTypes[i].load(str, checksum, &checksumValue);
str= currentPath + "resources/" + filenames[i];
resourceTypes[i].load(str, checksum, &checksumValue, loadedFileList);
Window::handleEvent();
SDL_PumpEvents();
}
// Cleanup pixmap memory
for(int i=0; i<filenames.size(); ++i) {
for(int i = 0; i < filenames.size(); ++i) {
resourceTypes[i].deletePixels();
}
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());
throw runtime_error("Error loading Resource Types: "+ dir + "\n" + e.what());
throw runtime_error("Error loading Resource Types in: [" + currentPath + "]\n" + e.what());
}
// give CPU time to update other things to avoid apperance of hanging
@ -86,7 +90,7 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
SDL_PumpEvents();
//load tech tree xml info
try{
try {
XmlTree xmlTree;
string currentPath = dir;
endPathWithSlash(currentPath);
@ -96,15 +100,18 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
checksumValue.addFile(path);
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *techTreeNode= xmlTree.getRootNode();
//attack types
const XmlNode *attackTypesNode= techTreeNode->getChild("attack-types");
attackTypes.resize(attackTypesNode->getChildCount());
for(int i=0; i<attackTypes.size(); ++i){
for(int i = 0; i < attackTypes.size(); ++i) {
const XmlNode *attackTypeNode= attackTypesNode->getChild("attack-type", i);
attackTypes[i].setName(attackTypeNode->getAttribute("name")->getRestrictedValue());
attackTypes[i].setId(i);
Window::handleEvent();
SDL_PumpEvents();
}
@ -116,10 +123,11 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
//armor types
const XmlNode *armorTypesNode= techTreeNode->getChild("armor-types");
armorTypes.resize(armorTypesNode->getChildCount());
for(int i=0; i<armorTypes.size(); ++i){
for(int i = 0; i < armorTypes.size(); ++i) {
const XmlNode *armorTypeNode= armorTypesNode->getChild("armor-type", i);
armorTypes[i].setName(armorTypeNode->getAttribute("name")->getRestrictedValue());
armorTypes[i].setId(i);
Window::handleEvent();
SDL_PumpEvents();
}
@ -127,19 +135,20 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
//damage multipliers
damageMultiplierTable.init(attackTypes.size(), armorTypes.size());
const XmlNode *damageMultipliersNode= techTreeNode->getChild("damage-multipliers");
for(int i=0; i<damageMultipliersNode->getChildCount(); ++i){
for(int i = 0; i < damageMultipliersNode->getChildCount(); ++i) {
const XmlNode *damageMultiplierNode= damageMultipliersNode->getChild("damage-multiplier", i);
const AttackType *attackType= getAttackType(damageMultiplierNode->getAttribute("attack")->getRestrictedValue());
const ArmorType *armorType= getArmorType(damageMultiplierNode->getAttribute("armor")->getRestrictedValue());
float multiplier= damageMultiplierNode->getAttribute("value")->getFloatValue();
damageMultiplierTable.setDamageMultiplier(attackType, armorType, multiplier);
Window::handleEvent();
SDL_PumpEvents();
}
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());
throw runtime_error("Error loading Tech Tree: "+ dir + "\n" + e.what());
throw runtime_error("Error loading Tech Tree: "+ currentPath + "\n" + e.what());
}
// give CPU time to update other things to avoid apperance of hanging
@ -147,7 +156,7 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
//SDL_PumpEvents();
//load factions
str = dir + "/factions/*.";
str = currentPath + "factions/*.";
try{
factionTypes.resize(factions.size());
@ -156,13 +165,17 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
string factionName = *it;
char szBuf[1024]="";
sprintf(szBuf,"%s %s [%d / %d] - %s",Lang::getInstance().get("Loading").c_str(),Lang::getInstance().get("Faction").c_str(),i+1,(int)factions.size(),factionName.c_str());
sprintf(szBuf,"%s %s [%d / %d] - %s",Lang::getInstance().get("Loading").c_str(),
Lang::getInstance().get("Faction").c_str(),
i+1,
(int)factions.size(),
factionName.c_str());
Logger &logger= Logger::getInstance();
logger.setState(szBuf);
logger.setProgress((int)((((double)i) / (double)factions.size()) * 100.0));
str=dir+"/factions/" + factionName;
factionTypes[i++].load(str, this, checksum,&checksumValue);
str = currentPath + "factions/" + factionName;
factionTypes[i++].load(str, this, checksum,&checksumValue,loadedFileList);
// give CPU time to update other things to avoid apperance of hanging
sleep(0);
@ -172,7 +185,7 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());
throw runtime_error("Error loading Faction Types: "+ dir + "\n" + e.what());
throw runtime_error("Error loading Faction Types: "+ currentPath + "\n" + e.what());
}
if(techtreeChecksum != NULL) {

6
source/glest_game/types/tech_tree.h
View File

@ -45,8 +45,10 @@ private:
Checksum checksumValue;
public:
Checksum loadTech(const vector<string> pathList, const string &techName, set<string> &factions, Checksum* checksum);
void load(const string &dir, set<string> &factions, Checksum* checksum,Checksum *techtreeChecksum);
Checksum loadTech(const vector<string> pathList, const string &techName,
set<string> &factions, Checksum* checksum, std::map<string,int> &loadedFileList);
void load(const string &dir, set<string> &factions, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,int> &loadedFileList);
~TechTree();
Checksum * getChecksumValue() { return &checksumValue; }

54
source/glest_game/types/unit_type.cpp
View File

@ -113,11 +113,13 @@ UnitType::~UnitType(){
}
}
void UnitType::preLoad(const string &dir){
void UnitType::preLoad(const string &dir) {
name= lastDir(dir);
}
void UnitType::load(int id,const string &dir, const TechTree *techTree, const FactionType *factionType, Checksum* checksum,Checksum* techtreeChecksum) {
void UnitType::load(int id,const string &dir, const TechTree *techTree,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,int> &loadedFileList) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
@ -137,6 +139,8 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *unitNode= xmlTree.getRootNode();
const XmlNode *parametersNode= unitNode->getChild("parameters");
@ -250,35 +254,38 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
if (fields[fLand]) {
field = fLand;
} else if (fields[fAir]) {
}
else if (fields[fAir]) {
field = fAir;
} else {
}
else {
throw runtime_error("Unit has no field: " + path);
}
//properties
const XmlNode *propertiesNode= parametersNode->getChild("properties");
for(int i=0; i<propertiesNode->getChildCount(); ++i){
for(int i = 0; i < propertiesNode->getChildCount(); ++i) {
const XmlNode *propertyNode= propertiesNode->getChild("property", i);
string propertyName= propertyNode->getAttribute("value")->getRestrictedValue();
bool found= false;
for(int i=0; i<pCount; ++i){
if(propertyName==propertyNames[i]){
for(int i = 0; i < pCount; ++i) {
if(propertyName == propertyNames[i]) {
properties[i]= true;
found= true;
break;
}
}
if(!found){
if(!found) {
throw runtime_error("Unknown property: " + propertyName);
}
}
//damage-particles
if(parametersNode->hasChild("damage-particles")){
if(parametersNode->hasChild("damage-particles")) {
const XmlNode *particleNode= parametersNode->getChild("damage-particles");
bool particleEnabled= particleNode->getAttribute("value")->getBoolValue();
if(particleEnabled){
for(int i=0; i<particleNode->getChildCount(); ++i){
if(particleEnabled) {
for(int i = 0; i < particleNode->getChildCount(); ++i) {
const XmlNode *particleFileNode= particleNode->getChild("particle-file", i);
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
UnitParticleSystemType *unitParticleSystemType= new UnitParticleSystemType();
@ -286,10 +293,13 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
//Texture2D *newTexture = Renderer::getInstance().newTexture2D(rsGame);
Texture2D *newTexture = NULL;
unitParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance());
if(unitParticleSystemType->hasTexture() == false) {
unitParticleSystemType->load(dir, currentPath + path,
&Renderer::getInstance(),loadedFileList);
loadedFileList[currentPath + path]++;
//if(unitParticleSystemType->hasTexture() == false) {
//Renderer::getInstance().endLastTexture(rsGame,true);
}
//}
damageParticleSystemTypes.push_back(unitParticleSystemType);
}
@ -306,7 +316,7 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
}
//rotationAllowed
if(parametersNode->hasChild("rotationAllowed")){
if(parametersNode->hasChild("rotationAllowed")) {
const XmlNode *rotationAllowedNode= parametersNode->getChild("rotationAllowed");
rotationAllowed= rotationAllowedNode->getAttribute("value")->getBoolValue();
}
@ -356,11 +366,13 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
const XmlNode *imageNode= parametersNode->getChild("image");
image= Renderer::getInstance().newTexture2D(rsGame);
image->load(currentPath + imageNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + imageNode->getAttribute("path")->getRestrictedValue()]++;
//image cancel
const XmlNode *imageCancelNode= parametersNode->getChild("image-cancel");
cancelImage= Renderer::getInstance().newTexture2D(rsGame);
cancelImage->load(currentPath + imageCancelNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + imageCancelNode->getAttribute("path")->getRestrictedValue()]++;
//meeting point
const XmlNode *meetingPointNode= parametersNode->getChild("meeting-point");
@ -368,6 +380,7 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
if(meetingPoint){
meetingPointImage= Renderer::getInstance().newTexture2D(rsGame);
meetingPointImage->load(currentPath + meetingPointNode->getAttribute("image-path")->getRestrictedValue());
loadedFileList[currentPath + meetingPointNode->getAttribute("image-path")->getRestrictedValue()]++;
}
//selection sounds
@ -379,6 +392,7 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
string path= soundNode->getAttribute("path")->getRestrictedValue();
StaticSound *sound= new StaticSound();
sound->load(currentPath + path);
loadedFileList[currentPath + path]++;
selectionSounds[i]= sound;
}
}
@ -392,6 +406,7 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
string path= soundNode->getAttribute("path")->getRestrictedValue();
StaticSound *sound= new StaticSound();
sound->load(currentPath + path);
loadedFileList[currentPath + path]++;
commandSounds[i]= sound;
}
}
@ -399,24 +414,25 @@ void UnitType::load(int id,const string &dir, const TechTree *techTree, const Fa
//skills
const XmlNode *skillsNode= unitNode->getChild("skills");
skillTypes.resize(skillsNode->getChildCount());
for(int i=0; i<skillTypes.size(); ++i){
for(int i = 0; i < skillTypes.size(); ++i) {
const XmlNode *sn= skillsNode->getChild("skill", i);
const XmlNode *typeNode= sn->getChild("type");
string classId= typeNode->getAttribute("value")->getRestrictedValue();
SkillType *skillType= SkillTypeFactory::getInstance().newInstance(classId);
skillType->load(sn, dir, techTree, factionType);
skillType->load(sn, dir, techTree, factionType, loadedFileList);
skillTypes[i]= skillType;
}
//commands
const XmlNode *commandsNode= unitNode->getChild("commands");
commandTypes.resize(commandsNode->getChildCount());
for(int i=0; i<commandTypes.size(); ++i){
for(int i = 0; i < commandTypes.size(); ++i) {
const XmlNode *commandNode= commandsNode->getChild("command", i);
const XmlNode *typeNode= commandNode->getChild("type");
string classId= typeNode->getAttribute("value")->getRestrictedValue();
CommandType *commandType= CommandTypeFactory::getInstance().newInstance(classId);
commandType->load(i, commandNode, dir, techTree, factionType, *this);
commandType->load(i, commandNode, dir, techTree, factionType, *this,
loadedFileList);
commandTypes[i]= commandType;
}

4
source/glest_game/types/unit_type.h
View File

@ -136,7 +136,9 @@ public:
UnitType();
virtual ~UnitType();
void preLoad(const string &dir);
void load(int id, const string &dir, const TechTree *techTree, const FactionType *factionType, Checksum* checksum, Checksum* techtreeChecksum);
void load(int id, const string &dir, const TechTree *techTree,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,int> &loadedFileList);
//get
int getId() const {return id;}

20
source/glest_game/types/upgrade_type.cpp
View File

@ -47,16 +47,16 @@ void UpgradeType::preLoad(const string &dir){
name=lastDir(dir);
}
void UpgradeType::load(const string &dir, const TechTree *techTree, const FactionType *factionType, Checksum* checksum, Checksum* techtreeChecksum) {
void UpgradeType::load(const string &dir, const TechTree *techTree,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,int> &loadedFileList) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
string path;
Logger::getInstance().add("Upgrade type: "+ formatString(name), true);
string currentPath = dir;
endPathWithSlash(currentPath);
path = currentPath + name + ".xml";
string path = currentPath + name + ".xml";
try{
checksum->addFile(path);
@ -64,17 +64,20 @@ void UpgradeType::load(const string &dir, const TechTree *techTree, const Factio
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
const XmlNode *upgradeNode= xmlTree.getRootNode();
//image
const XmlNode *imageNode= upgradeNode->getChild("image");
image= Renderer::getInstance().newTexture2D(rsGame);
image->load(currentPath + imageNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + imageNode->getAttribute("path")->getRestrictedValue()]++;
//image cancel
const XmlNode *imageCancelNode= upgradeNode->getChild("image-cancel");
cancelImage= Renderer::getInstance().newTexture2D(rsGame);
cancelImage->load(currentPath + imageCancelNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + imageCancelNode->getAttribute("path")->getRestrictedValue()]++;
//upgrade time
const XmlNode *upgradeTimeNode= upgradeNode->getChild("time");
@ -82,7 +85,7 @@ void UpgradeType::load(const string &dir, const TechTree *techTree, const Factio
//unit requirements
const XmlNode *unitRequirementsNode= upgradeNode->getChild("unit-requirements");
for(int i=0; i<unitRequirementsNode->getChildCount(); ++i){
for(int i = 0; i < unitRequirementsNode->getChildCount(); ++i) {
const XmlNode *unitNode= unitRequirementsNode->getChild("unit", i);
string name= unitNode->getAttribute("name")->getRestrictedValue();
unitReqs.push_back(factionType->getUnitType(name));
@ -90,7 +93,7 @@ void UpgradeType::load(const string &dir, const TechTree *techTree, const Factio
//upgrade requirements
const XmlNode *upgradeRequirementsNode= upgradeNode->getChild("upgrade-requirements");
for(int i=0; i<upgradeRequirementsNode->getChildCount(); ++i){
for(int i = 0; i < upgradeRequirementsNode->getChildCount(); ++i) {
const XmlNode *upgradeReqNode= upgradeRequirementsNode->getChild("upgrade", i);
string name= upgradeReqNode->getAttribute("name")->getRestrictedValue();
upgradeReqs.push_back(factionType->getUpgradeType(name));
@ -99,7 +102,7 @@ void UpgradeType::load(const string &dir, const TechTree *techTree, const Factio
//resource requirements
const XmlNode *resourceRequirementsNode= upgradeNode->getChild("resource-requirements");
costs.resize(resourceRequirementsNode->getChildCount());
for(int i=0; i<costs.size(); ++i){
for(int i = 0; i < costs.size(); ++i) {
const XmlNode *resourceNode= resourceRequirementsNode->getChild("resource", i);
string name= resourceNode->getAttribute("name")->getRestrictedValue();
int amount= resourceNode->getAttribute("amount")->getIntValue();
@ -108,7 +111,7 @@ void UpgradeType::load(const string &dir, const TechTree *techTree, const Factio
//effects
const XmlNode *effectsNode= upgradeNode->getChild("effects");
for(int i=0; i<effectsNode->getChildCount(); ++i){
for(int i = 0; i < effectsNode->getChildCount(); ++i) {
const XmlNode *unitNode= effectsNode->getChild("unit", i);
string name= unitNode->getAttribute("name")->getRestrictedValue();
effects.push_back(factionType->getUnitType(name));
@ -123,7 +126,6 @@ void UpgradeType::load(const string &dir, const TechTree *techTree, const Factio
armor= upgradeNode->getChild("armor")->getAttribute("value")->getIntValue();
moveSpeed= upgradeNode->getChild("move-speed")->getAttribute("value")->getIntValue();
prodSpeed= upgradeNode->getChild("production-speed")->getAttribute("value")->getIntValue();
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what());

4
source/glest_game/types/upgrade_type.h
View File

@ -77,7 +77,9 @@ private:
public:
void preLoad(const string &dir);
void load(const string &dir, const TechTree *techTree, const FactionType *factionType, Checksum* checksum, Checksum* techtreeChecksum);
void load(const string &dir, const TechTree *techTree,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,int> &loadedFileList);
//get all
int getEffectCount() const {return effects.size();}

29
source/glest_game/world/tileset.cpp
View File

@ -31,13 +31,14 @@ namespace Glest{ namespace Game{
// class AmbientSounds
// =====================================================
void AmbientSounds::load(const string &dir, const XmlNode *xmlNode){
void AmbientSounds::load(const string &dir, const XmlNode *xmlNode,
std::map<string,int> &loadedFileList) {
string path;
//day
const XmlNode *dayNode= xmlNode->getChild("day-sound");
enabledDay= dayNode->getAttribute("enabled")->getBoolValue();
if(enabledDay){
if(enabledDay) {
path= dayNode->getAttribute("path")->getRestrictedValue();
string currentPath = dir;
endPathWithSlash(currentPath);
@ -84,6 +85,7 @@ void AmbientSounds::load(const string &dir, const XmlNode *xmlNode){
string currentPath = dir;
endPathWithSlash(currentPath);
dayStart.load(currentPath + path);
loadedFileList[currentPath + path]++;
}
//nightStart
@ -94,6 +96,7 @@ void AmbientSounds::load(const string &dir, const XmlNode *xmlNode){
string currentPath = dir;
endPathWithSlash(currentPath);
nightStart.load(currentPath + path);
loadedFileList[currentPath + path]++;
}
}
@ -101,14 +104,15 @@ void AmbientSounds::load(const string &dir, const XmlNode *xmlNode){
// class Tileset
// =====================================================
Checksum Tileset::loadTileset(const vector<string> pathList, const string &tilesetName, Checksum* checksum) {
Checksum Tileset::loadTileset(const vector<string> pathList, const string &tilesetName,
Checksum* checksum, std::map<string,int> &loadedFileList) {
Checksum tilesetChecksum;
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);
load(path, checksum, &tilesetChecksum, loadedFileList);
break;
}
}
@ -116,7 +120,8 @@ Checksum Tileset::loadTileset(const vector<string> pathList, const string &tiles
}
void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum) {
void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum,
std::map<string,int> &loadedFileList) {
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
random.init(time(NULL));
@ -141,6 +146,7 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck
//parse xml
XmlTree xmlTree;
xmlTree.load(path);
loadedFileList[path]++;
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
@ -168,6 +174,8 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck
const XmlNode *textureNode= surfaceNode->getChild("texture", j);
surfPixmaps[i][j].init(3);
surfPixmaps[i][j].load(currentPath + textureNode->getAttribute("path")->getRestrictedValue());
loadedFileList[currentPath + textureNode->getAttribute("path")->getRestrictedValue()]++;
surfProbs[i][j]= textureNode->getAttribute("prob")->getFloatValue();
}
}
@ -193,7 +201,8 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck
for(int j=0; j<childCount; ++j) {
const XmlNode *modelNode= objectNode->getChild("model", j);
const XmlAttribute *pathAttribute= modelNode->getAttribute("path");
objectTypes[i].loadModel(currentPath + pathAttribute->getRestrictedValue());
objectTypes[i].loadModel(currentPath + pathAttribute->getRestrictedValue(),&loadedFileList);
loadedFileList[currentPath + pathAttribute->getRestrictedValue()]++;
if(modelNode->hasChild("particles")){
const XmlNode *particleNode= modelNode->getChild("particles");
@ -203,7 +212,10 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck
const XmlNode *particleFileNode= particleNode->getChild("particle-file", k);
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
ObjectParticleSystemType *objectParticleSystemType= new ObjectParticleSystemType();
objectParticleSystemType->load(dir, currentPath + path, &Renderer::getInstance());
objectParticleSystemType->load(dir, currentPath + path,
&Renderer::getInstance(), loadedFileList);
loadedFileList[currentPath + path]++;
objectTypes[i].addParticleSystem((objectParticleSystemType));
}
}
@ -219,7 +231,7 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
//ambient sounds
ambientSounds.load(dir, tilesetNode->getChild("ambient-sounds"));
ambientSounds.load(dir, tilesetNode->getChild("ambient-sounds"), loadedFileList);
//parameters
const XmlNode *parametersNode= tilesetNode->getChild("parameters");
@ -238,6 +250,7 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck
for(int i=0; i<waterFrameCount; ++i){
const XmlNode *waterFrameNode= waterNode->getChild("texture", i);
waterTex->getPixmap()->loadSlice(currentPath + waterFrameNode->getAttribute("path")->getRestrictedValue(), i);
loadedFileList[currentPath + waterFrameNode->getAttribute("path")->getRestrictedValue()]++;
}
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);

11
source/glest_game/world/tileset.h
View File

@ -88,7 +88,8 @@ public:
StaticSound *getDayStart() {return &dayStart;}
StaticSound *getNightStart() {return &nightStart;}
void load(const string &dir, const XmlNode *xmlNode);
void load(const string &dir, const XmlNode *xmlNode,
std::map<string,int> &loadedFileList);
};
// =====================================================
@ -97,7 +98,7 @@ public:
/// Containt textures, models and parameters for a tileset
// =====================================================
class Tileset{
class Tileset {
public:
static const int waterTexCount= 1;
static const int surfCount= 6;
@ -131,8 +132,10 @@ private:
public:
~Tileset();
Checksum loadTileset(const vector<string> pathList, const string &tilesetName, Checksum* checksum);
void load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum);
Checksum loadTileset(const vector<string> pathList, const string &tilesetName,
Checksum* checksum, std::map<string,int> &loadedFileList);
void load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum,
std::map<string,int> &loadedFileList);
Checksum * getChecksumValue() { return &checksumValue; }
//get

15
source/glest_game/world/world.cpp
View File

@ -198,11 +198,12 @@ void World::init(Game *game, bool createUnits){
}
//load tileset
Checksum World::loadTileset(const vector<string> pathList, const string &tilesetName, Checksum* checksum) {
Checksum World::loadTileset(const vector<string> pathList, const string &tilesetName,
Checksum* checksum, std::map<string,int> &loadedFileList) {
Checksum tilsetChecksum;
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
tilsetChecksum = tileset.loadTileset(pathList, tilesetName, checksum);
tilsetChecksum = tileset.loadTileset(pathList, tilesetName, checksum, loadedFileList);
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
timeFlow.init(&tileset);
@ -211,11 +212,11 @@ Checksum World::loadTileset(const vector<string> pathList, const string &tileset
return tilsetChecksum;
}
Checksum World::loadTileset(const string &dir, Checksum *checksum) {
Checksum World::loadTileset(const string &dir, Checksum *checksum, std::map<string,int> &loadedFileList) {
Checksum tilesetChecksum;
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
tileset.load(dir, checksum, &tilesetChecksum);
tileset.load(dir, checksum, &tilesetChecksum, loadedFileList);
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
timeFlow.init(&tileset);
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
@ -224,13 +225,15 @@ Checksum World::loadTileset(const string &dir, Checksum *checksum) {
}
//load tech
Checksum World::loadTech(const vector<string> pathList, const string &techName, set<string> &factions, Checksum *checksum) {
Checksum World::loadTech(const vector<string> pathList, const string &techName,
set<string> &factions, Checksum *checksum, std::map<string,int> &loadedFileList) {
Checksum techtreeChecksum;
SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
techTree = new TechTree();
techtreeChecksum = techTree->loadTech(pathList, techName, factions, checksum);
techtreeChecksum = techTree->loadTech(pathList, techName, factions,
checksum,loadedFileList);
return techtreeChecksum;
}

9
source/glest_game/world/world.h
View File

@ -173,9 +173,12 @@ public:
//init & load
void init(Game *game, bool createUnits);
Checksum loadTileset(const vector<string> pathList, const string &tilesetName, Checksum* checksum);
Checksum loadTileset(const string &dir, Checksum* checksum);
Checksum loadTech(const vector<string> pathList, const string &techName, set<string> &factions, Checksum* checksum);
Checksum loadTileset(const vector<string> pathList, const string &tilesetName,
Checksum* checksum, std::map<string,int> &loadedFileList);
Checksum loadTileset(const string &dir, Checksum* checksum,
std::map<string,int> &loadedFileList);
Checksum loadTech(const vector<string> pathList, const string &techName,
set<string> &factions, Checksum* checksum,std::map<string,int> &loadedFileList);
Checksum loadMap(const string &path, Checksum* checksum);
Checksum loadScenario(const string &path, Checksum* checksum);

14
source/shared_lib/include/graphics/model.h
View File

@ -133,12 +133,14 @@ public:
Texture2D *loadMeshTexture(int meshIndex, int textureIndex, TextureManager *textureManager, string textureFile,
int textureChannelCount, bool &textureOwned,
bool deletePixMapAfterLoad);
bool deletePixMapAfterLoad, std::map<string,int> *loadedFileList=NULL);
//load
void loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad);
void loadV3(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad);
void load(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad);
void loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
bool deletePixMapAfterLoad,std::map<string,int> *loadedFileList=NULL);
void loadV3(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
bool deletePixMapAfterLoad,std::map<string,int> *loadedFileList=NULL);
void load(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad,std::map<string,int> *loadedFileList=NULL);
void save(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
string convertTextureToFormat, std::map<string,int> &textureDeleteList,
bool keepsmallest);
@ -194,9 +196,9 @@ public:
uint32 getVertexCount() const;
//io
void load(const string &path,bool deletePixMapAfterLoad=false);
void load(const string &path,bool deletePixMapAfterLoad=false,std::map<string,int> *loadedFileList=NULL);
void save(const string &path, string convertTextureToFormat,bool keepsmallest);
void loadG3d(const string &path,bool deletePixMapAfterLoad=false);
void loadG3d(const string &path,bool deletePixMapAfterLoad=false,std::map<string,int> *loadedFileList=NULL);
void saveG3d(const string &path, string convertTextureToFormat,bool keepsmallest);
void setTextureManager(TextureManager *textureManager) {this->textureManager= textureManager;}

3
source/shared_lib/include/platform/common/platform_common.h
View File

@ -109,6 +109,7 @@ public:
// =====================================================
void Tokenize(const string& str,vector<string>& tokens,const string& delimiters = " ");
bool isdir(const char *path);
void findDirs(string path, vector<string> &results, bool errorOnNotFound,bool keepDuplicates);
void findDirs(const vector<string> &paths, vector<string> &results, bool errorOnNotFound=false,bool keepDuplicates=false);
void findAll(const vector<string> &paths, const string &fileFilter, vector<string> &results, bool cutExtension=false, bool errorOnNotFound=true,bool keepDuplicates=false);
void findAll(const string &path, vector<string> &results, bool cutExtension=false, bool errorOnNotFound=true);
@ -148,6 +149,8 @@ bool StartsWith(const std::string &str, const std::string &key);
bool EndsWith(const string &str, const string& key);
void endPathWithSlash(string &path);
void trimPathWithStartingSlash(string &path);
void updatePathClimbingParts(string &path);
string replaceAll(string& context, const string& from, const string& to);
bool removeFile(string file);

49
source/shared_lib/sources/graphics/model.cpp
View File

@ -207,7 +207,8 @@ string Mesh::findAlternateTexture(vector<string> conversionList, string textureF
return result;
}
void Mesh::loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad) {
void Mesh::loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
bool deletePixMapAfterLoad, std::map<string,int> *loadedFileList) {
this->textureManager = textureManager;
//read header
MeshHeaderV2 meshHeader;
@ -267,6 +268,9 @@ void Mesh::loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *tex
if(fileExists(texPath) == true) {
textures[mtDiffuse]= textureManager->newTexture2D();
textures[mtDiffuse]->load(texPath);
if(loadedFileList) {
(*loadedFileList)[texPath]++;
}
texturesOwned[mtDiffuse]=true;
textures[mtDiffuse]->init(textureManager->getTextureFilter(),textureManager->getMaxAnisotropy());
if(deletePixMapAfterLoad == true) {
@ -291,7 +295,9 @@ void Mesh::loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *tex
readBytes = fread(indices, sizeof(uint32)*indexCount, 1, f);
}
void Mesh::loadV3(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad) {
void Mesh::loadV3(int meshIndex, const string &dir, FILE *f,
TextureManager *textureManager,bool deletePixMapAfterLoad,
std::map<string,int> *loadedFileList) {
this->textureManager = textureManager;
//read header
@ -348,6 +354,10 @@ void Mesh::loadV3(int meshIndex, const string &dir, FILE *f, TextureManager *tex
if(fileExists(texPath) == true) {
textures[mtDiffuse]= textureManager->newTexture2D();
textures[mtDiffuse]->load(texPath);
if(loadedFileList) {
(*loadedFileList)[texPath]++;
}
texturesOwned[mtDiffuse]=true;
textures[mtDiffuse]->init(textureManager->getTextureFilter(),textureManager->getMaxAnisotropy());
if(deletePixMapAfterLoad == true) {
@ -374,8 +384,10 @@ void Mesh::loadV3(int meshIndex, const string &dir, FILE *f, TextureManager *tex
readBytes = fread(indices, sizeof(uint32)*indexCount, 1, f);
}
Texture2D* Mesh::loadMeshTexture(int meshIndex, int textureIndex, TextureManager *textureManager, string textureFile,
int textureChannelCount, bool &textureOwned, bool deletePixMapAfterLoad) {
Texture2D* Mesh::loadMeshTexture(int meshIndex, int textureIndex,
TextureManager *textureManager, string textureFile,
int textureChannelCount, bool &textureOwned, bool deletePixMapAfterLoad,
std::map<string,int> *loadedFileList) {
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s] #1 load texture [%s]\n",__FUNCTION__,textureFile.c_str());
@ -400,6 +412,9 @@ Texture2D* Mesh::loadMeshTexture(int meshIndex, int textureIndex, TextureManager
texture->getPixmap()->init(textureChannelCount);
}
texture->load(textureFile);
if(loadedFileList) {
(*loadedFileList)[textureFile]++;
}
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s] texture loaded [%s]\n",__FUNCTION__,textureFile.c_str());
@ -421,7 +436,7 @@ Texture2D* Mesh::loadMeshTexture(int meshIndex, int textureIndex, TextureManager
}
void Mesh::load(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
bool deletePixMapAfterLoad) {
bool deletePixMapAfterLoad,std::map<string,int> *loadedFileList) {
this->textureManager = textureManager;
//read header
@ -470,7 +485,8 @@ void Mesh::load(int meshIndex, const string &dir, FILE *f, TextureManager *textu
mapFullPath += mapPath;
textures[i] = loadMeshTexture(meshIndex, i, textureManager, mapFullPath,
meshTextureChannelCount[i],texturesOwned[i],deletePixMapAfterLoad);
meshTextureChannelCount[i],texturesOwned[i],
deletePixMapAfterLoad, loadedFileList);
}
flag *= 2;
}
@ -749,10 +765,11 @@ uint32 Model::getVertexCount() const {
// ==================== io ====================
void Model::load(const string &path, bool deletePixMapAfterLoad) {
void Model::load(const string &path, bool deletePixMapAfterLoad,
std::map<string,int> *loadedFileList) {
string extension= path.substr(path.find_last_of('.')+1);
if(extension=="g3d" || extension=="G3D"){
loadG3d(path,deletePixMapAfterLoad);
loadG3d(path,deletePixMapAfterLoad,loadedFileList);
}
else{
throw runtime_error("Unknown model format: " + extension);
@ -773,7 +790,8 @@ void Model::save(const string &path, string convertTextureToFormat,
}
//load a model from a g3d file
void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
void Model::loadG3d(const string &path, bool deletePixMapAfterLoad,
std::map<string,int> *loadedFileList) {
try{
FILE *f=fopen(path.c_str(),"rb");
@ -782,6 +800,10 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
throw runtime_error("Error opening g3d model file [" + path + "]");
}
if(loadedFileList) {
(*loadedFileList)[path]++;
}
string dir= extractDirectoryPathFromFile(path);
//file header
@ -811,7 +833,8 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
//load meshes
meshes= new Mesh[meshCount];
for(uint32 i = 0; i < meshCount; ++i) {
meshes[i].load(i, dir, f, textureManager,deletePixMapAfterLoad);
meshes[i].load(i, dir, f, textureManager,deletePixMapAfterLoad,
loadedFileList);
meshes[i].buildInterpolationData();
}
}
@ -823,7 +846,8 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
meshes= new Mesh[meshCount];
for(uint32 i = 0; i < meshCount; ++i) {
meshes[i].loadV3(i, dir, f, textureManager,deletePixMapAfterLoad);
meshes[i].loadV3(i, dir, f, textureManager,deletePixMapAfterLoad,
loadedFileList);
meshes[i].buildInterpolationData();
}
}
@ -835,7 +859,8 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
meshes= new Mesh[meshCount];
for(uint32 i = 0; i < meshCount; ++i){
meshes[i].loadV2(i,dir, f, textureManager,deletePixMapAfterLoad);
meshes[i].loadV2(i,dir, f, textureManager,deletePixMapAfterLoad,
loadedFileList);
meshes[i].buildInterpolationData();
}
}

58
source/shared_lib/sources/platform/common/platform_common.cpp
View File

@ -65,7 +65,6 @@ using namespace std;
namespace Shared { namespace PlatformCommon {
// Refresh every 3 days
const time_t REFRESH_CRC_DAY_SECONDS = 1 * 60 * 24;
static string crcCachePath = "";
@ -210,6 +209,30 @@ void Tokenize(const string& str,vector<string>& tokens,const string& delimiters)
}
}
void findDirs(string path, vector<string> &results, bool errorOnNotFound,bool keepDuplicates) {
results.clear();
string currentPath = path;
endPathWithSlash(currentPath);
string searchpath = currentPath + "*.";
vector<string> current_results;
findAll(searchpath, current_results, false, errorOnNotFound);
if(current_results.size() > 0) {
for(unsigned int folder_index = 0; folder_index < current_results.size(); folder_index++) {
const string current_folder = current_results[folder_index];
const string current_folder_path = currentPath + current_folder;
if(isdir(current_folder_path.c_str()) == true) {
if(keepDuplicates == true || std::find(results.begin(),results.end(),current_folder) == results.end()) {
results.push_back(current_folder);
}
}
}
}
std::sort(results.begin(),results.end());
}
void findDirs(const vector<string> &paths, vector<string> &results, bool errorOnNotFound,bool keepDuplicates) {
results.clear();
size_t pathCount = paths.size();
@ -412,6 +435,37 @@ void endPathWithSlash(string &path) {
}
}
void trimPathWithStartingSlash(string &path) {
if(StartsWith(path, "/") == true || StartsWith(path, "\\") == true) {
path.erase(path.begin(),path.begin()+1);
//printf("************* trimPathWithStartingSlash changed path [%s]\n",path.c_str());
}
}
void updatePathClimbingParts(string &path) {
// Update paths with ..
string::size_type pos = path.rfind("..");
if(pos != string::npos && pos != 0) {
string orig = path;
path.erase(pos,2);
pos--;
if(path[pos] == '/' || path[pos] == '\\') {
path.erase(pos,1);
}
for(int x = pos; x >= 0; --x) {
//printf("x [%d][%c] pos [%ld][%c] [%s]\n",x,path[x],(long int)pos,path[pos],path.substr(0,x+1).c_str());
if((path[x] == '/' || path[x] == '\\') && x != pos) {
path.erase(x,pos-x);
break;
}
}
//printf("CHANGED relative path from [%s] to [%s]\n",orig.c_str(),path.c_str());
}
}
string getCRCCacheFilePath() {
return crcCachePath;
}
@ -467,7 +521,7 @@ void writeCachedFileCRCValue(string crcCacheFile, int32 &crcValue) {
FILE *fp = fopen(crcCacheFile.c_str(),"w");
if(fp != NULL) {
RandomGen random;
int offset = random.randRange(1, 5);
int offset = random.randRange(5, 15);
time_t refreshDate = time(NULL) + (REFRESH_CRC_DAY_SECONDS * offset);
fprintf(fp,"%ld,%d",refreshDate,crcValue);
fclose(fp);

15
source/shared_lib/sources/util/util.cpp
View File

@ -494,7 +494,7 @@ void SystemFlags::logDebugEntry(DebugType type, string debugEntry, time_t debugT
}
string lastDir(const string &s){
string lastDir(const string &s) {
size_t i= s.find_last_of('/');
size_t j= s.find_last_of('\\');
size_t pos;
@ -513,7 +513,18 @@ string lastDir(const string &s){
throw runtime_error(string(__FILE__)+" lastDir - i==string::npos");
}
return (s.substr(pos+1, s.length()));
if( pos + 1 == s.length() && s.length() > 0 &&
(s[pos] == '/' || s[pos] == '\\')) {
string retry = s.substr(0, pos);
return lastDir(retry);
}
string result = s.substr(pos+1, s.length());
replaceAll(result,"/","");
replaceAll(result,"\\","");
//printf("=-=-=-=- LASTDIR in [%s] out [%s]\n",s.c_str(),result.c_str());
return result;
}
string lastFile(const string &s){