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

- added a more graceful way to handle more serious errors during data validation commands in order to offer more detailed error analysis

This commit is contained in:
Mark Vejvoda 2013-11-04 07:21:04 +00:00
parent 7c4c7a142b
commit 1134ad399d
13 changed files with 703 additions and 593 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

@ -38,7 +38,9 @@ FactionType::FactionType() {
//load a faction, given a directory
void FactionType::load(const string &factionName, const TechTree *techTree, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
Checksum *techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
@ -162,29 +164,49 @@ void FactionType::load(const string &factionName, const TechTree *techTree, Chec
int progressBaseValue=logger.getProgress();
for(int i = 0; i < unitTypes.size(); ++i) {
string str= currentPath + "units/" + unitTypes[i].getName();
unitTypes[i].loaddd(i, str, techTree,techTreePath, this, checksum,techtreeChecksum,
loadedFileList);
logger.setProgress(progressBaseValue+(int)((((double)i + 1.0) / (double)unitTypes.size()) * 100.0/techTree->getTypeCount()));
SDL_PumpEvents();
try {
unitTypes[i].loaddd(i, str, techTree,techTreePath, this, checksum,techtreeChecksum,
loadedFileList,validationMode);
logger.setProgress(progressBaseValue+(int)((((double)i + 1.0) / (double)unitTypes.size()) * 100.0/techTree->getTypeCount()));
SDL_PumpEvents();
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what());
}
}
}
}
catch(megaglest_runtime_error& ex) {
//printf("1111111b ex.wantStackTrace() = %d\n",ex.wantStackTrace());
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what());
//printf("222222b\n");
throw megaglest_runtime_error("Error loading units: "+ currentPath + "\n" + ex.what(),!ex.wantStackTrace());
throw megaglest_runtime_error("Error loading units: "+ currentPath + "\nMessage: " + ex.what(),!ex.wantStackTrace());
}
catch(const exception &e) {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
throw megaglest_runtime_error("Error loading units: "+ currentPath + "\n" + e.what());
throw megaglest_runtime_error("Error loading units: "+ currentPath + "\nMessage: " + e.what());
}
// b2) load upgrades
try{
for(int i = 0; i < upgradeTypes.size(); ++i) {
string str= currentPath + "upgrades/" + upgradeTypes[i].getName();
upgradeTypes[i].load(str, techTree, this, checksum,techtreeChecksum,
loadedFileList);
try {
upgradeTypes[i].load(str, techTree, this, checksum,
techtreeChecksum,loadedFileList,validationMode);
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what());
}
}
SDL_PumpEvents();
}
@ -214,7 +236,18 @@ void FactionType::load(const string &factionName, const TechTree *techTree, Chec
const XmlNode *resourceNode= startingResourcesNode->getChild("resource", i);
string name= resourceNode->getAttribute("name")->getRestrictedValue();
int amount= resourceNode->getAttribute("amount")->getIntValue();
startingResources[i].init(techTree->getResourceType(name), amount);
try {
startingResources[i].init(techTree->getResourceType(name), amount);
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\nFor FactionType: %s for StartResource: %s\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what(),this->name.c_str(),name.c_str());
}
}
SDL_PumpEvents();
}
@ -858,29 +891,32 @@ void FactionType::deletePixels() {
bool FactionType::factionUsesResourceType(const ResourceType *rt) const {
bool factionUsesResourceType = false;
for(unsigned int j = 0; factionUsesResourceType == false && j < this->getUnitTypeCount(); ++j) {
const UnitType *ut= this->getUnitType(j);
for(int k = 0; factionUsesResourceType == false && k < ut->getCostCount(); ++k) {
const Resource *costResource = ut->getCost(k);
//printf("#1 factionUsesResourceType, unit [%s] resource [%s] cost [%s]\n",ut->getName().c_str(),rt->getName().c_str(),costResource->getType()->getName().c_str());
if(rt != NULL) {
for(unsigned int j = 0; factionUsesResourceType == false && j < this->getUnitTypeCount(); ++j) {
const UnitType *ut= this->getUnitType(j);
for(int k = 0; factionUsesResourceType == false && k < ut->getCostCount(); ++k) {
const Resource *costResource = ut->getCost(k);
//printf("#1 factionUsesResourceType, unit [%s] resource [%s] cost [%s]\n",ut->getName().c_str(),rt->getName().c_str(),costResource->getType()->getName().c_str());
if(costResource != NULL && costResource->getType()->getName() == rt->getName()) {
factionUsesResourceType = true;
break;
if(costResource != NULL && costResource->getType() != NULL &&
costResource->getType()->getName() == rt->getName()) {
factionUsesResourceType = true;
break;
}
}
}
if(factionUsesResourceType == false) {
for(unsigned int k = 0; factionUsesResourceType == false && k < ut->getCommandTypeCount(); ++k) {
const CommandType *commandType = ut->getCommandType(k);
if(commandType != NULL && commandType->getClass() == ccHarvest) {
const HarvestCommandType *hct = dynamic_cast<const HarvestCommandType *>(commandType);
if(hct != NULL && hct->getHarvestedResourceCount() > 0) {
for(unsigned int l = 0; factionUsesResourceType == false && l < hct->getHarvestedResourceCount(); ++l) {
//printf("#2 factionUsesResourceType, unit [%s] resource [%s] harvest [%s]\n",ut->getName().c_str(),rt->getName().c_str(),hct->getHarvestedResource(l)->getName().c_str());
if(factionUsesResourceType == false) {
for(unsigned int k = 0; factionUsesResourceType == false && k < ut->getCommandTypeCount(); ++k) {
const CommandType *commandType = ut->getCommandType(k);
if(commandType != NULL && commandType->getClass() == ccHarvest) {
const HarvestCommandType *hct = dynamic_cast<const HarvestCommandType *>(commandType);
if(hct != NULL && hct->getHarvestedResourceCount() > 0) {
for(unsigned int l = 0; factionUsesResourceType == false && l < hct->getHarvestedResourceCount(); ++l) {
//printf("#2 factionUsesResourceType, unit [%s] resource [%s] harvest [%s]\n",ut->getName().c_str(),rt->getName().c_str(),hct->getHarvestedResource(l)->getName().c_str());
if(hct->getHarvestedResource(l)->getName() == rt->getName()) {
factionUsesResourceType = true;
break;
if(hct->getHarvestedResource(l)->getName() == rt->getName()) {
factionUsesResourceType = true;
break;
}
}
}
}
@ -888,7 +924,6 @@ bool FactionType::factionUsesResourceType(const ResourceType *rt) const {
}
}
}
return factionUsesResourceType;
}

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

@ -100,7 +100,9 @@ public:
//init
FactionType();
void load(const string &factionName, const TechTree *techTree, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList);
Checksum *techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode=false);
virtual ~FactionType();
const std::vector<FactionType::PairPUnitTypeInt> getAIBehaviorUnits(AIBehaviorUnitCategory category) const;

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

@ -46,6 +46,7 @@ TechTree::TechTree(const vector<string> pathList) {
translatedTechNames.clear();
translatedTechFactionNames.clear();
languageUsedForCache = "";
isValidationModeEnabled = false;
}
string TechTree::getNameUntranslated() const {
@ -155,13 +156,17 @@ string TechTree::getTranslatedFactionName(string techName, string factionName) {
}
Checksum TechTree::loadTech(const string &techName,
set<string> &factions, Checksum* checksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
set<string> &factions, Checksum* checksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode) {
name = "";
isValidationModeEnabled = validationMode;
Checksum techtreeChecksum;
string path=findPath(techName);
if(path!="") {
//printf(">>> path=%s\n",path.c_str());
load(path, factions, checksum, &techtreeChecksum, loadedFileList);
load(path, factions, checksum, &techtreeChecksum, loadedFileList,
validationMode);
}
else {
printf(">>> techtree [%s] path not found.\n",techName.c_str());
@ -191,7 +196,9 @@ string TechTree::findPath(const string &techName, const vector<string> &pathTech
void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
Checksum *techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
string currentPath = dir;
@ -230,7 +237,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",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
throw megaglest_runtime_error("Error loading Resource Types in: [" + currentPath + "]\n" + e.what());
throw megaglest_runtime_error("Error loading Resource Types in: [" + currentPath + "]\n" + e.what(),isValidationModeEnabled);
}
// give CPU time to update other things to avoid apperance of hanging
@ -302,7 +309,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",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
throw megaglest_runtime_error("Error loading Tech Tree: "+ currentPath + "\n" + e.what());
throw megaglest_runtime_error("Error loading Tech Tree: "+ currentPath + "\n" + e.what(),isValidationModeEnabled);
}
// give CPU time to update other things to avoid apperance of hanging
@ -327,7 +334,8 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
logger.setState(szBuf);
logger.setProgress((int)((((double)i) / (double)factions.size()) * 100.0));
factionTypes[i++].load(factionName, this, checksum,&checksumValue,loadedFileList);
factionTypes[i++].load(factionName, this, checksum,&checksumValue,
loadedFileList,validationMode);
// give CPU time to update other things to avoid apperance of hanging
sleep(0);
@ -336,14 +344,12 @@ void TechTree::load(const string &dir, set<string> &factions, Checksum* checksum
}
}
catch(megaglest_runtime_error& ex) {
//printf("1111111b ex.wantStackTrace() = %d\n",ex.wantStackTrace());
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what());
//printf("222222b\n");
throw megaglest_runtime_error("Error loading Faction Types: "+ currentPath + "\n" + ex.what(),!ex.wantStackTrace());
throw megaglest_runtime_error("Error loading Faction Types: "+ currentPath + "\nMessage: " + ex.what(),!ex.wantStackTrace() || isValidationModeEnabled);
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
throw megaglest_runtime_error("Error loading Faction Types: "+ currentPath + "\n" + e.what());
throw megaglest_runtime_error("Error loading Faction Types: "+ currentPath + "\nMessage: " + e.what(),isValidationModeEnabled);
}
if(techtreeChecksum != NULL) {
@ -429,7 +435,7 @@ FactionType *TechTree::getTypeByName(const string &name) {
}
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error("Faction not found: "+name);
throw megaglest_runtime_error("Faction not found: " + name,isValidationModeEnabled);
}
const FactionType *TechTree::getType(const string &name) const {
@ -439,7 +445,7 @@ const FactionType *TechTree::getType(const string &name) const {
}
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error("Faction not found: "+name);
throw megaglest_runtime_error("Faction not found: " + name,isValidationModeEnabled);
}
const ResourceType *TechTree::getTechResourceType(int i) const{
@ -466,8 +472,7 @@ const ResourceType *TechTree::getFirstTechResourceType() const{
char szBuf[8096]="";
snprintf(szBuf,8096,"The referenced tech tree [%s] is either missing or has no resources defined but at least one resource is required.",this->name.c_str());
//throw megaglest_runtime_error("This tech tree has no resources defined, at least one is required");
throw megaglest_runtime_error(szBuf);
throw megaglest_runtime_error(szBuf,isValidationModeEnabled);
}
const ResourceType *TechTree::getResourceType(const string &name) const{
@ -478,7 +483,7 @@ const ResourceType *TechTree::getResourceType(const string &name) const{
}
}
throw megaglest_runtime_error("Resource Type not found: "+name);
throw megaglest_runtime_error("Resource Type not found: " + name,isValidationModeEnabled);
}
const ArmorType *TechTree::getArmorType(const string &name) const{
@ -488,7 +493,7 @@ const ArmorType *TechTree::getArmorType(const string &name) const{
}
}
throw megaglest_runtime_error("Armor Type not found: "+name);
throw megaglest_runtime_error("Armor Type not found: " + name,isValidationModeEnabled);
}
const AttackType *TechTree::getAttackType(const string &name) const{
@ -498,7 +503,7 @@ const AttackType *TechTree::getAttackType(const string &name) const{
}
}
throw megaglest_runtime_error("Attack Type not found: "+name);
throw megaglest_runtime_error("Attack Type not found: " + name,isValidationModeEnabled);
}
double TechTree::getDamageMultiplier(const AttackType *att, const ArmorType *art) const {

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

@ -56,12 +56,17 @@ private:
string languageUsedForCache;
std::map<string,string> translatedTechNames;
std::map<string,std::map<string,string> > translatedTechFactionNames;
bool isValidationModeEnabled;
public:
Checksum loadTech(const string &techName,
set<string> &factions, Checksum* checksum, std::map<string,vector<pair<string, string> > > &loadedFileList);
set<string> &factions, Checksum* checksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode=false);
void load(const string &dir, set<string> &factions, Checksum* checksum,
Checksum *techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList);
Checksum *techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode=false);
string findPath(const string &techName) const;
static string findPath(const string &techName, const vector<string> &pathTechList);

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

@ -164,9 +164,11 @@ void UnitType::preLoad(const string &dir) {
name= lastDir(dir);
}
void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const string &techTreePath,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
void UnitType::loaddd(int id,const string &dir, const TechTree *techTree,
const string &techTreePath, const FactionType *factionType,
Checksum* checksum, Checksum* techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
@ -281,7 +283,7 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
const XmlNode *rowNode= cellMapNode->getChild("row", i);
string row= rowNode->getAttribute("value")->getRestrictedValue();
if(row.size()!=size){
throw megaglest_runtime_error("Cellmap row has not the same length as unit size");
throw megaglest_runtime_error("Cellmap row has not the same length as unit size",validationMode);
}
for(int j=0; j<row.size(); ++j){
cellMap[i*size+j]= row[j]=='0'? false: true;
@ -294,6 +296,7 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
levels.resize(levelsNode->getChildCount());
for(int i=0; i<levels.size(); ++i){
const XmlNode *levelNode= levelsNode->getChild("level", i);
levels[i].init(
levelNode->getAttribute("name")->getRestrictedValue(),
levelNode->getAttribute("kills")->getIntValue());
@ -311,7 +314,7 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
fields[fAir]= true;
}
else{
throw megaglest_runtime_error("Not a valid field: "+fieldName+": "+ path);
throw megaglest_runtime_error("Not a valid field: "+fieldName+": "+ path, validationMode);
}
}
@ -322,7 +325,7 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
field = fAir;
}
else {
throw megaglest_runtime_error("Unit has no field: " + path);
throw megaglest_runtime_error("Unit has no field: " + path, validationMode);
}
//properties
@ -339,7 +342,7 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
}
}
if(!found) {
throw megaglest_runtime_error("Unknown property: " + propertyName);
throw megaglest_runtime_error("Unknown property: " + propertyName, validationMode);
}
}
//damage-particles
@ -353,18 +356,11 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
UnitParticleSystemType *unitParticleSystemType= new UnitParticleSystemType();
//Texture2D *newTexture = Renderer::getInstance().newTexture2D(rsGame);
//Texture2D *newTexture = NULL;
unitParticleSystemType->load(particleFileNode, dir, currentPath + path,
&Renderer::getInstance(),loadedFileList, sourceXMLFile,
techTree->getPath());
loadedFileList[currentPath + path].push_back(make_pair(sourceXMLFile,particleFileNode->getAttribute("path")->getRestrictedValue()));
//if(unitParticleSystemType->hasTexture() == false) {
//Renderer::getInstance().endLastTexture(rsGame,true);
//}
if(particleFileNode->getAttribute("minHp",false) != NULL && particleFileNode->getAttribute("maxHp",false) != NULL) {
unitParticleSystemType->setMinmaxEnabled(true);
unitParticleSystemType->setMinHp(particleFileNode->getAttribute("minHp")->getIntValue());
@ -374,7 +370,6 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
unitParticleSystemType->setMinmaxIsPercent(particleFileNode->getAttribute("ispercentbased")->getBoolValue());
}
//printf("Found customized particle trigger by HP [%d to %d]\n",unitParticleSystemType->getMinHp(),unitParticleSystemType->getMaxHp());
}
damageParticleSystemTypes.push_back(unitParticleSystemType);
@ -476,8 +471,18 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
int index = 0;
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
iterMap != sortedItems.end(); ++iterMap) {
costs[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
index++;
try {
costs[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
index++;
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\nFor UnitType: %s Cost: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what(),name.c_str(),iterMap->second);
}
}
}
sortedItems.clear();
hasDup = false;
@ -508,8 +513,18 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
index = 0;
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
iterMap != sortedItems.end(); ++iterMap) {
storedResources[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
index++;
try {
storedResources[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
index++;
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\nFor UnitType: %s Store: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what(),name.c_str(),iterMap->second);
}
}
}
sortedItems.clear();
@ -544,21 +559,24 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
if(parametersNode->hasChild("count-unit-death-in-stats")){
const XmlNode *countUnitDeathInStatsNode= parametersNode->getChild("count-unit-death-in-stats");
countUnitDeathInStats= countUnitDeathInStatsNode->getAttribute("value")->getBoolValue();
} else {
}
else {
countUnitDeathInStats=true;
}
//countUnitProductionInStats
if(parametersNode->hasChild("count-unit-production-in-stats")){
const XmlNode *countUnitProductionInStatsNode= parametersNode->getChild("count-unit-production-in-stats");
countUnitProductionInStats= countUnitProductionInStatsNode->getAttribute("value")->getBoolValue();
} else {
}
else {
countUnitProductionInStats=true;
}
//countUnitKillInStats
if(parametersNode->hasChild("count-unit-kill-in-stats")){
const XmlNode *countUnitKillInStatsNode= parametersNode->getChild("count-unit-kill-in-stats");
countUnitKillInStats= countUnitKillInStatsNode->getAttribute("value")->getBoolValue();
} else {
}
else {
countUnitKillInStats=true;
}
@ -622,9 +640,19 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
string classId= typeNode->getAttribute("value")->getRestrictedValue();
SkillType *skillType= SkillTypeFactory::getInstance().newInstance(classId);
skillType->load(sn, attackBoostsNode, dir, techTree, factionType, loadedFileList,sourceXMLFile);
skillTypes[i]= skillType;
skillTypes[i]=NULL;
try {
skillType->load(sn, attackBoostsNode, dir, techTree, factionType, loadedFileList,sourceXMLFile);
skillTypes[i]= skillType;
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\nFor UnitType: %s SkillType: %s\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what(),name.c_str(),classId.c_str());
}
}
}
//commands
@ -635,32 +663,42 @@ void UnitType::loaddd(int id,const string &dir, const TechTree *techTree, const
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,
loadedFileList,sourceXMLFile);
commandTypes[i]= commandType;
commandTypes[i]=NULL;
try {
commandType->load(i, commandNode, dir, techTree, factionType, *this,
loadedFileList,sourceXMLFile);
commandTypes[i]= commandType;
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\nFor UnitType: %s CommandType:%s\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what(),name.c_str(),classId.c_str());
}
}
}
computeFirstStOfClass();
computeFirstCtOfClass();
if(getFirstStOfClass(scStop)==NULL){
throw megaglest_runtime_error("Every unit must have at least one stop skill: "+ path);
throw megaglest_runtime_error("Every unit must have at least one stop skill: "+ path,validationMode);
}
if(getFirstStOfClass(scDie)==NULL){
throw megaglest_runtime_error("Every unit must have at least one die skill: "+ path);
throw megaglest_runtime_error("Every unit must have at least one die skill: "+ path,validationMode);
}
}
//Exception handling (conversions and so on);
catch(megaglest_runtime_error& ex) {
//printf("1111111a ex.wantStackTrace() = %d\n",ex.wantStackTrace());
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what());
//printf("222222a\n");
throw megaglest_runtime_error("Error loading UnitType: " + path + "\n" + ex.what(),!ex.wantStackTrace());
throw megaglest_runtime_error("Error loading UnitType: " + path + "\nMessage: " + ex.what(),!ex.wantStackTrace());
}
catch(const exception &e){
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
throw megaglest_runtime_error("Error loading UnitType: " + path + "\n" + e.what());
throw megaglest_runtime_error("Error loading UnitType: " + path + "\nMessage: " + e.what());
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
@ -976,7 +1014,7 @@ void UnitType::computeFirstStOfClass() {
for(int j= 0; j < scCount; ++j) {
firstSkillTypeOfClass[j]= NULL;
for(int i= 0; i < skillTypes.size(); ++i) {
if(skillTypes[i]->getClass()== SkillClass(j)) {
if(skillTypes[i] != NULL && skillTypes[i]->getClass()== SkillClass(j)) {
firstSkillTypeOfClass[j]= skillTypes[i];
break;
}
@ -988,7 +1026,7 @@ void UnitType::computeFirstCtOfClass() {
for(int j = 0; j < ccCount; ++j) {
firstCommandTypeOfClass[j]= NULL;
for(int i = 0; i < commandTypes.size(); ++i) {
if(commandTypes[i]->getClass() == CommandClass(j)) {
if(commandTypes[i] != NULL && commandTypes[i]->getClass() == CommandClass(j)) {
firstCommandTypeOfClass[j] = commandTypes[i];
break;
}

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

@ -163,9 +163,12 @@ public:
UnitType();
virtual ~UnitType();
void preLoad(const string &dir);
void loaddd(int id, const string &dir, const TechTree *techTree,const string &techTreePath,
void loaddd(int id, const string &dir, const TechTree *techTree,
const string &techTreePath,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList);
Checksum* techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode=false);
virtual string getName(bool translatedValue=false) const;

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

@ -585,7 +585,9 @@ void UpgradeType::preLoad(const string &dir){
void UpgradeType::load(const string &dir, const TechTree *techTree,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
Checksum* techtreeChecksum, std::map<string,
vector<pair<string, string> > > &loadedFileList,
bool validationMode) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
char szBuf[8096]="";
@ -610,29 +612,9 @@ void UpgradeType::load(const string &dir, const TechTree *techTree,
//image
image = NULL; // Not used for upgrade types
// const XmlNode *imageNode= upgradeNode->getChild("image");
// image= Renderer::getInstance().newTexture2D(rsGame);
// if(image) {
// image->load(imageNode->getAttribute("path")->getRestrictedValue(currentPath,true));
// }
// loadedFileList[imageNode->getAttribute("path")->getRestrictedValue(currentPath,true)].push_back(make_pair(sourceXMLFile,imageNode->getAttribute("path")->getRestrictedValue()));
//if(fileExists(imageNode->getAttribute("path")->getRestrictedValue(currentPath,true)) == false) {
// printf("\n***ERROR MISSING FILE [%s]\n",imageNode->getAttribute("path")->getRestrictedValue(currentPath,true).c_str());
//}
//image cancel
cancelImage = NULL; // Not used for upgrade types
// const XmlNode *imageCancelNode= upgradeNode->getChild("image-cancel");
// cancelImage= Renderer::getInstance().newTexture2D(rsGame);
// if(cancelImage) {
// cancelImage->load(imageCancelNode->getAttribute("path")->getRestrictedValue(currentPath,true));
// }
// loadedFileList[imageCancelNode->getAttribute("path")->getRestrictedValue(currentPath,true)].push_back(make_pair(sourceXMLFile,imageCancelNode->getAttribute("path")->getRestrictedValue()));
//if(fileExists(imageCancelNode->getAttribute("path")->getRestrictedValue(currentPath,true)) == false) {
// printf("\n***ERROR MISSING FILE [%s]\n",imageCancelNode->getAttribute("path")->getRestrictedValue(currentPath,true).c_str());
//}
//upgrade time
const XmlNode *upgradeTimeNode= upgradeNode->getChild("time");
@ -719,8 +701,19 @@ void UpgradeType::load(const string &dir, const TechTree *techTree,
index = 0;
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
iterMap != sortedItems.end(); ++iterMap) {
costs[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
index++;
try {
costs[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
index++;
}
catch(megaglest_runtime_error& ex) {
if(validationMode == false) {
throw ex;
}
else {
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\nFor UpgradeType: %s Cost: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what(),name.c_str(),iterMap->second);
}
}
}
sortedItems.clear();
hasDup = false;

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

@ -204,7 +204,9 @@ public:
void preLoad(const string &dir);
void load(const string &dir, const TechTree *techTree,
const FactionType *factionType, Checksum* checksum,
Checksum* techtreeChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList);
Checksum* techtreeChecksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode=false);
virtual string getName(bool translatedValue=false) const;

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

@ -454,14 +454,16 @@ Checksum World::loadTileset(const string &dir, Checksum *checksum, std::map<stri
//load tech
Checksum World::loadTech(const vector<string> pathList, const string &techName,
set<string> &factions, Checksum *checksum, std::map<string,vector<pair<string, string> > > &loadedFileList) {
set<string> &factions, Checksum *checksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode) {
Checksum techtreeChecksum;
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
techTree = new TechTree(pathList);
techtreeChecksum = techTree->loadTech( techName, factions,
checksum,loadedFileList);
checksum,loadedFileList,validationMode);
return techtreeChecksum;
}

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

@ -205,7 +205,9 @@ public:
std::map<string,vector<pair<string, string> > > &loadedFileList);
void clearTileset();
Checksum loadTech(const vector<string> pathList, const string &techName,
set<string> &factions, Checksum* checksum,std::map<string,vector<pair<string, string> > > &loadedFileList);
set<string> &factions, Checksum* checksum,
std::map<string,vector<pair<string, string> > > &loadedFileList,
bool validationMode=false);
Checksum loadMap(const string &path, Checksum* checksum);
Checksum loadScenario(const string &path, Checksum* checksum,bool resetCurrentScenario=false,const XmlNode *rootNode=NULL);
void setQueuedScenario(string scenarioName,bool keepFactions);

1
source/shared_lib/include/graphics/vec.h
View File

@ -70,6 +70,7 @@ inline T truncateDecimal(const T &value, int precision=6) {
if((T)value * (T)precNum <= MAX_INT_VALUE) {
int resultInt = (T)value * (T)precNum;
T result = (T)resultInt / precNum;
//printf("=======================\nvalue = %.10f\nresultInt: %d\nprecision: %d\nbecame: %.10f\n----------\n",value,resultInt,precision,result);
return result;
}

6
source/shared_lib/sources/platform/sdl/platform_util.cpp
View File

@ -60,12 +60,12 @@ const char * getDialogCommand() {
return NULL;
}
bool showMessage(const std::string & warning) {
bool showMessage(std::string warning) {
bool guiMessage = false;
const char * dialogCommand = getDialogCommand();
if (dialogCommand) {
std::string command = dialogCommand;
command += " --title \"Error\" --msgbox \"`printf \"" + warning + "\"`\"";
command += " --title \"Error\" --msgbox \"`printf \"" + warning.erase(4096,std::string::npos) + "\"`\"";
//printf("\n\n\nzenity command [%s]\n\n\n",command.c_str());
@ -79,9 +79,11 @@ bool showMessage(const std::string & warning) {
}
void message(string message, bool isNonGraphicalModeEnabled) {
std::cerr << "\n\n\n";
std::cerr << "******************************************************\n";
std::cerr << " " << message << "\n";
std::cerr << "******************************************************\n";
std::cerr << "\n\n\n";
if(isNonGraphicalModeEnabled == false) {
showMessage(message);