1446 lines
50 KiB
C++
1446 lines
50 KiB
C++
// ==============================================================
|
|
// This file is part of Glest (www.glest.org)
|
|
//
|
|
// Copyright (C) 2001-2008 Martiño Figueroa
|
|
//
|
|
// You can redistribute this code and/or modify it under
|
|
// the terms of the GNU General Public License as published
|
|
// by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version
|
|
// ==============================================================
|
|
|
|
#ifdef WIN32
|
|
#include <winsock2.h>
|
|
#include <winsock.h>
|
|
#endif
|
|
|
|
#include "unit_type.h"
|
|
#include <cassert>
|
|
#include "util.h"
|
|
#include "upgrade_type.h"
|
|
#include "resource_type.h"
|
|
#include "sound.h"
|
|
#include "logger.h"
|
|
#include "xml_parser.h"
|
|
#include "tech_tree.h"
|
|
#include "resource.h"
|
|
#include "renderer.h"
|
|
#include "game_util.h"
|
|
#include "unit_particle_type.h"
|
|
#include "faction.h"
|
|
#include "common_scoped_ptr.h"
|
|
#include "leak_dumper.h"
|
|
|
|
using namespace Shared::Xml;
|
|
using namespace Shared::Graphics;
|
|
using namespace Shared::Util;
|
|
|
|
namespace Glest{ namespace Game{
|
|
|
|
auto_ptr<CommandType> UnitType::ctHarvestEmergencyReturnCommandType(new HarvestEmergencyReturnCommandType());
|
|
// ===============================
|
|
// class Level
|
|
// ===============================
|
|
|
|
void Level::init(string name, int kills){
|
|
this->name= name;
|
|
this->kills= kills;
|
|
}
|
|
|
|
string Level::getName(bool translatedValue) const {
|
|
if(translatedValue == false) return name;
|
|
|
|
Lang &lang = Lang::getInstance();
|
|
return lang.getTechTreeString("LevelName_" + name,name.c_str());
|
|
}
|
|
|
|
void Level::saveGame(XmlNode *rootNode) const {
|
|
std::map<string,string> mapTagReplacements;
|
|
XmlNode *levelNode = rootNode->addChild("Level");
|
|
|
|
levelNode->addAttribute("name",name, mapTagReplacements);
|
|
levelNode->addAttribute("kills",intToStr(kills), mapTagReplacements);
|
|
}
|
|
|
|
const Level * Level::loadGame(const XmlNode *rootNode,const UnitType *ut) {
|
|
const Level *result = NULL;
|
|
if(rootNode->hasChild("Level") == true) {
|
|
const XmlNode *levelNode = rootNode->getChild("Level");
|
|
|
|
result = ut->getLevel(levelNode->getAttribute("name")->getValue());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// =====================================================
|
|
// class UnitType
|
|
// =====================================================
|
|
|
|
// ===================== PUBLIC ========================
|
|
|
|
const char *UnitType::propertyNames[]= {"burnable", "rotated_climb"};
|
|
|
|
// ==================== creation and loading ====================
|
|
|
|
UnitType::UnitType() : ProducibleType() {
|
|
|
|
countInVictoryConditions = ucvcNotSet;
|
|
meetingPointImage = NULL;
|
|
lightColor= Vec3f(0.f);
|
|
light= false;
|
|
healthbarheight= -100.0f;
|
|
healthbarthickness=-1.0f;
|
|
healthbarVisible=hbvUndefined;
|
|
multiSelect= false;
|
|
uniformSelect= false;
|
|
commandable= true;
|
|
armorType= NULL;
|
|
rotatedBuildPos=0;
|
|
|
|
field = fLand;
|
|
id = 0;
|
|
meetingPoint = false;
|
|
rotationAllowed = false;
|
|
|
|
countUnitDeathInStats=false;
|
|
countUnitProductionInStats=false;
|
|
countUnitKillInStats=false;
|
|
countKillForUnitUpgrade=false;
|
|
|
|
|
|
for(int i=0; i<ccCount; ++i){
|
|
firstCommandTypeOfClass[i]= NULL;
|
|
}
|
|
|
|
for(int i=0; i<scCount; ++i){
|
|
firstSkillTypeOfClass[i] = NULL;
|
|
}
|
|
|
|
for(int i=0; i<pCount; ++i){
|
|
properties[i]= false;
|
|
}
|
|
|
|
for(int i=0; i<fieldCount; ++i){
|
|
fields[i]= false;
|
|
}
|
|
|
|
cellMap= NULL;
|
|
allowEmptyCellMap=false;
|
|
hpRegeneration= 0;
|
|
epRegeneration= 0;
|
|
maxUnitCount= 0;
|
|
maxHp=0;
|
|
startHpValue=0;
|
|
startHpPercentage=1.0;
|
|
startHpType=stValue;
|
|
maxEp=0;
|
|
startEpValue=0;
|
|
startEpPercentage=0;
|
|
startEpType=stValue;
|
|
armor=0;
|
|
sight=0;
|
|
size=0;
|
|
aiBuildSize=-1;
|
|
renderSize=0;
|
|
height=0;
|
|
burnHeight=0;
|
|
targetHeight=0;
|
|
|
|
addItemToVault(&(this->maxHp),this->maxHp);
|
|
addItemToVault(&(this->hpRegeneration),this->hpRegeneration);
|
|
addItemToVault(&(this->maxEp),this->maxEp);
|
|
addItemToVault(&(this->epRegeneration),this->epRegeneration);
|
|
addItemToVault(&(this->maxUnitCount),this->maxUnitCount);
|
|
addItemToVault(&(this->armor),this->armor);
|
|
addItemToVault(&(this->sight),this->sight);
|
|
addItemToVault(&(this->size),this->size);
|
|
addItemToVault(&(this->height),this->height);
|
|
}
|
|
|
|
UnitType::~UnitType(){
|
|
deleteValues(commandTypes.begin(), commandTypes.end());
|
|
commandTypes.clear();
|
|
deleteValues(skillTypes.begin(), skillTypes.end());
|
|
skillTypes.clear();
|
|
deleteValues(selectionSounds.getSounds().begin(), selectionSounds.getSounds().end());
|
|
selectionSounds.clearSounds();
|
|
deleteValues(commandSounds.getSounds().begin(), commandSounds.getSounds().end());
|
|
commandSounds.clearSounds();
|
|
delete [] cellMap;
|
|
cellMap=NULL;
|
|
//remove damageParticleSystemTypes
|
|
while(!damageParticleSystemTypes.empty()){
|
|
delete damageParticleSystemTypes.back();
|
|
damageParticleSystemTypes.pop_back();
|
|
}
|
|
}
|
|
|
|
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,
|
|
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;
|
|
endPathWithSlash(currentPath);
|
|
string path = currentPath + name + ".xml";
|
|
string sourceXMLFile = path;
|
|
|
|
this->id= id;
|
|
|
|
try {
|
|
//Lang &lang= Lang::getInstance();
|
|
|
|
char szBuf[8096]="";
|
|
snprintf(szBuf,8096,Lang::getInstance().getString("LogScreenGameLoadingUnitType","",true).c_str(),formatString(this->getName(true)).c_str());
|
|
Logger::getInstance().add(szBuf, true);
|
|
|
|
//file load
|
|
checksum->addFile(path);
|
|
techtreeChecksum->addFile(path);
|
|
|
|
XmlTree xmlTree;
|
|
std::map<string,string> mapExtraTagReplacementValues;
|
|
mapExtraTagReplacementValues["$COMMONDATAPATH"] = techTreePath + "/commondata/";
|
|
xmlTree.load(path, Properties::getTagReplacementValues(&mapExtraTagReplacementValues));
|
|
loadedFileList[path].push_back(make_pair(dir,dir));
|
|
|
|
const XmlNode *unitNode= xmlTree.getRootNode();
|
|
|
|
const XmlNode *parametersNode= unitNode->getChild("parameters");
|
|
|
|
if(parametersNode->hasChild("count-in-victory-conditions") == true) {
|
|
bool countUnit = parametersNode->getChild("count-in-victory-conditions")->getAttribute("value")->getBoolValue();
|
|
if(countUnit == true) {
|
|
countInVictoryConditions = ucvcTrue;
|
|
}
|
|
else {
|
|
countInVictoryConditions = ucvcFalse;
|
|
}
|
|
}
|
|
|
|
//size
|
|
//checkItemInVault(&(this->size),this->size);
|
|
size= parametersNode->getChild("size")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->size),this->size);
|
|
renderSize=size;
|
|
if(parametersNode->hasChild("render-size")){
|
|
renderSize=parametersNode->getChild("render-size")->getAttribute("value")->getIntValue();
|
|
}
|
|
aiBuildSize=size;
|
|
if(parametersNode->hasChild("ai-build-size")){
|
|
aiBuildSize= parametersNode->getChild("ai-build-size")->getAttribute("value")->getIntValue();
|
|
}
|
|
|
|
//height
|
|
//checkItemInVault(&(this->height),this->height);
|
|
height= parametersNode->getChild("height")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->height),this->height);
|
|
|
|
//targetHeight
|
|
if(parametersNode->hasChild("target-height")){
|
|
targetHeight= parametersNode->getChild("target-height")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->targetHeight),this->targetHeight);
|
|
} else {
|
|
targetHeight=height;
|
|
}
|
|
//burnHeight
|
|
if(parametersNode->hasChild("target-height")){
|
|
burnHeight= parametersNode->getChild("burn-height")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->burnHeight),this->burnHeight);
|
|
} else {
|
|
burnHeight=height;
|
|
}
|
|
|
|
|
|
//maxHp
|
|
//checkItemInVault(&(this->maxHp),this->maxHp);
|
|
maxHp = parametersNode->getChild("max-hp")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->maxHp),this->maxHp);
|
|
|
|
//hpRegeneration
|
|
//checkItemInVault(&(this->hpRegeneration),this->hpRegeneration);
|
|
hpRegeneration= parametersNode->getChild("max-hp")->getAttribute("regeneration")->getIntValue();
|
|
addItemToVault(&(this->hpRegeneration),this->hpRegeneration);
|
|
|
|
//maxEp
|
|
//checkItemInVault(&(this->maxEp),this->maxEp);
|
|
maxEp= parametersNode->getChild("max-ep")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->maxEp),this->maxEp);
|
|
|
|
if(maxEp != 0) {
|
|
//epRegeneration
|
|
//checkItemInVault(&(this->epRegeneration),this->epRegeneration);
|
|
epRegeneration= parametersNode->getChild("max-ep")->getAttribute("regeneration")->getIntValue();
|
|
}
|
|
addItemToVault(&(this->epRegeneration),this->epRegeneration);
|
|
|
|
// Check that we don't use both start-value and start-percentage, as they are mutually
|
|
// exclusive
|
|
if(parametersNode->getChild("max-hp")->hasAttribute("start-value") &&
|
|
parametersNode->getChild("max-hp")->hasAttribute("start-percentage")) {
|
|
throw megaglest_runtime_error("Unit " + name +
|
|
" has both start-value and start-percentage for HP", true);
|
|
}
|
|
|
|
//startHpValue -- the *absolute* value to use for starting HP
|
|
if(parametersNode->getChild("max-hp")->hasAttribute("start-value")) {
|
|
//checkItemInVault(&(this->startEp),this->startEp);
|
|
startHpValue= parametersNode->getChild("max-hp")->getAttribute("start-value")->getIntValue();
|
|
startHpType= stValue;
|
|
}
|
|
addItemToVault(&(this->startHpValue),this->startHpValue);
|
|
|
|
//startHpPercentage -- the *relative* value to use for starting HP
|
|
if(parametersNode->getChild("max-hp")->hasAttribute("start-percentage")) {
|
|
startHpPercentage= parametersNode->getChild("max-hp")->getAttribute("start-percentage")->getIntValue();
|
|
startHpType= stPercentage;
|
|
}
|
|
|
|
// No start value is set; use 100% of the current Max
|
|
if(!parametersNode->getChild("max-hp")->hasAttribute("start-value") &&
|
|
!parametersNode->getChild("max-hp")->hasAttribute("start-percentage")) {
|
|
startHpPercentage=100;
|
|
startHpType= stPercentage;
|
|
}
|
|
addItemToVault(&(this->startHpPercentage),this->startHpPercentage);
|
|
|
|
// Check that we don't use both start-value and start-percentage, as they are mutually
|
|
// exclusive
|
|
if(parametersNode->getChild("max-ep")->hasAttribute("start-value") &&
|
|
parametersNode->getChild("max-ep")->hasAttribute("start-percentage")) {
|
|
throw megaglest_runtime_error("Unit " + name +
|
|
" has both start-value and start-percentage for EP", true);
|
|
}
|
|
|
|
//startEpValue -- the *absolute* value to use for starting EP
|
|
if(parametersNode->getChild("max-ep")->hasAttribute("start-value")) {
|
|
//checkItemInVault(&(this->startEp),this->startEp);
|
|
startEpValue= parametersNode->getChild("max-ep")->getAttribute("start-value")->getIntValue();
|
|
startEpType= stValue;
|
|
}
|
|
addItemToVault(&(this->startEpValue),this->startEpValue);
|
|
|
|
//startEpPercentage -- the *relative* value to use for starting EP
|
|
if(parametersNode->getChild("max-ep")->hasAttribute("start-percentage")) {
|
|
startEpPercentage= parametersNode->getChild("max-ep")->getAttribute("start-percentage")->getIntValue();
|
|
startEpType= stPercentage;
|
|
}
|
|
addItemToVault(&(this->startEpPercentage),this->startEpPercentage);
|
|
|
|
//maxUnitCount
|
|
if(parametersNode->hasChild("max-unit-count")) {
|
|
//checkItemInVault(&(this->maxUnitCount),this->maxUnitCount);
|
|
maxUnitCount= parametersNode->getChild("max-unit-count")->getAttribute("value")->getIntValue();
|
|
}
|
|
addItemToVault(&(this->maxUnitCount),this->maxUnitCount);
|
|
|
|
//armor
|
|
//checkItemInVault(&(this->armor),this->armor);
|
|
armor= parametersNode->getChild("armor")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->armor),this->armor);
|
|
|
|
//armor type string
|
|
string armorTypeName= parametersNode->getChild("armor-type")->getAttribute("value")->getRestrictedValue();
|
|
armorType= techTree->getArmorType(armorTypeName);
|
|
|
|
//sight
|
|
//checkItemInVault(&(this->sight),this->sight);
|
|
sight= parametersNode->getChild("sight")->getAttribute("value")->getIntValue();
|
|
addItemToVault(&(this->sight),this->sight);
|
|
|
|
//prod time
|
|
productionTime= parametersNode->getChild("time")->getAttribute("value")->getIntValue();
|
|
|
|
//multi selection
|
|
multiSelect= parametersNode->getChild("multi-selection")->getAttribute("value")->getBoolValue();
|
|
|
|
//uniform selection
|
|
if(parametersNode->hasChild("uniform-selection")) {
|
|
uniformSelect= parametersNode->getChild("uniform-selection")->getAttribute("value")->getBoolValue();
|
|
}
|
|
|
|
//commandable
|
|
if(parametersNode->hasChild("commandable")){
|
|
commandable= parametersNode->getChild("commandable")->getAttribute("value")->getBoolValue();
|
|
}
|
|
//cellmap
|
|
allowEmptyCellMap = false;
|
|
const XmlNode *cellMapNode= parametersNode->getChild("cellmap");
|
|
bool hasCellMap= cellMapNode->getAttribute("value")->getBoolValue();
|
|
if(hasCellMap == true) {
|
|
if(cellMapNode->getAttribute("allowEmpty",false) != NULL) {
|
|
allowEmptyCellMap = cellMapNode->getAttribute("allowEmpty")->getBoolValue();
|
|
}
|
|
|
|
cellMap= new bool[size*size];
|
|
for(int i=0; i<size; ++i){
|
|
const XmlNode *rowNode= cellMapNode->getChild("row", i);
|
|
string row= rowNode->getAttribute("value")->getRestrictedValue();
|
|
if((int)row.size() != size){
|
|
throw megaglest_runtime_error("Cellmap row has not the same length as unit size",true);
|
|
}
|
|
for(int j=0; j < (int)row.size(); ++j){
|
|
cellMap[i*size+j]= row[j]=='0'? false: true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//levels
|
|
const XmlNode *levelsNode= parametersNode->getChild("levels");
|
|
levels.resize(levelsNode->getChildCount());
|
|
for(int i=0; i < (int)levels.size(); ++i){
|
|
const XmlNode *levelNode= levelsNode->getChild("level", i);
|
|
|
|
levels[i].init(
|
|
levelNode->getAttribute("name")->getRestrictedValue(),
|
|
levelNode->getAttribute("kills")->getIntValue());
|
|
}
|
|
|
|
//fields
|
|
const XmlNode *fieldsNode= parametersNode->getChild("fields");
|
|
for(int i=0; i < (int)fieldsNode->getChildCount(); ++i){
|
|
const XmlNode *fieldNode= fieldsNode->getChild("field", i);
|
|
string fieldName= fieldNode->getAttribute("value")->getRestrictedValue();
|
|
if(fieldName=="land"){
|
|
fields[fLand]= true;
|
|
}
|
|
else if(fieldName=="air"){
|
|
fields[fAir]= true;
|
|
}
|
|
else{
|
|
throw megaglest_runtime_error("Not a valid field: "+fieldName+": "+ path, true);
|
|
}
|
|
}
|
|
|
|
if (fields[fLand]) {
|
|
field = fLand;
|
|
}
|
|
else if (fields[fAir]) {
|
|
field = fAir;
|
|
}
|
|
else {
|
|
throw megaglest_runtime_error("Unit has no field: " + path, true);
|
|
}
|
|
|
|
//properties
|
|
const XmlNode *propertiesNode= parametersNode->getChild("properties");
|
|
for(int i = 0; i < (int)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]) {
|
|
properties[i]= true;
|
|
found= true;
|
|
break;
|
|
}
|
|
}
|
|
if(!found) {
|
|
throw megaglest_runtime_error("Unknown property: " + propertyName, true);
|
|
}
|
|
}
|
|
//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 < (int)particleNode->getChildCount(); ++i) {
|
|
const XmlNode *particleFileNode= particleNode->getChild("particle-file", i);
|
|
string path= particleFileNode->getAttribute("path")->getRestrictedValue();
|
|
UnitParticleSystemType *unitParticleSystemType= new UnitParticleSystemType();
|
|
|
|
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(particleFileNode->getAttribute("minHp",false) != NULL && particleFileNode->getAttribute("maxHp",false) != NULL) {
|
|
unitParticleSystemType->setMinmaxEnabled(true);
|
|
unitParticleSystemType->setMinHp(particleFileNode->getAttribute("minHp")->getIntValue());
|
|
unitParticleSystemType->setMaxHp(particleFileNode->getAttribute("maxHp")->getIntValue());
|
|
|
|
if(particleFileNode->getAttribute("ispercentbased",false) != NULL) {
|
|
unitParticleSystemType->setMinmaxIsPercent(particleFileNode->getAttribute("ispercentbased")->getBoolValue());
|
|
}
|
|
|
|
}
|
|
|
|
damageParticleSystemTypes.push_back(unitParticleSystemType);
|
|
}
|
|
}
|
|
}
|
|
|
|
//healthbar
|
|
if(parametersNode->hasChild("healthbar")) {
|
|
const XmlNode *healthbarNode= parametersNode->getChild("healthbar");
|
|
if(healthbarNode->hasChild("height")) {
|
|
healthbarheight= healthbarNode->getChild("height")->getAttribute("value")->getFloatValue();
|
|
}
|
|
if(healthbarNode->hasChild("thickness")) {
|
|
healthbarthickness= healthbarNode->getChild("thickness")->getAttribute("value")->getFloatValue(0.f, 1.f);
|
|
}
|
|
if(healthbarNode->hasChild("visible")) {
|
|
string healthbarVisibleString=healthbarNode->getChild("visible")->getAttribute("value")->getValue();
|
|
vector<string> v=split(healthbarVisibleString,"|");
|
|
for (int i = 0; i < (int)v.size(); ++i) {
|
|
string current=trim(v[i]);
|
|
if(current=="always") {
|
|
healthbarVisible=healthbarVisible|hbvAlways;
|
|
} else if(current=="selected") {
|
|
healthbarVisible=healthbarVisible|hbvSelected;
|
|
} else if(current=="ifNeeded") {
|
|
healthbarVisible=healthbarVisible|hbvIfNeeded;
|
|
} else if(current=="off") {
|
|
healthbarVisible=healthbarVisible|hbvOff;
|
|
} else {
|
|
throw megaglest_runtime_error("Unknown Healthbar Visible Option: " + current, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//light
|
|
const XmlNode *lightNode= parametersNode->getChild("light");
|
|
light= lightNode->getAttribute("enabled")->getBoolValue();
|
|
if(light){
|
|
lightColor.x= lightNode->getAttribute("red")->getFloatValue(0.f, 1.f);
|
|
lightColor.y= lightNode->getAttribute("green")->getFloatValue(0.f, 1.f);
|
|
lightColor.z= lightNode->getAttribute("blue")->getFloatValue(0.f, 1.f);
|
|
}
|
|
|
|
//rotationAllowed
|
|
if(parametersNode->hasChild("rotationAllowed")) {
|
|
const XmlNode *rotationAllowedNode= parametersNode->getChild("rotationAllowed");
|
|
rotationAllowed= rotationAllowedNode->getAttribute("value")->getBoolValue();
|
|
}
|
|
else
|
|
{
|
|
rotationAllowed=true;
|
|
}
|
|
|
|
std::map<string,int> sortedItems;
|
|
|
|
//unit requirements
|
|
bool hasDup = false;
|
|
const XmlNode *unitRequirementsNode= parametersNode->getChild("unit-requirements");
|
|
for(int i=0; i < (int)unitRequirementsNode->getChildCount(); ++i){
|
|
const XmlNode *unitNode= unitRequirementsNode->getChild("unit", i);
|
|
string name= unitNode->getAttribute("name")->getRestrictedValue();
|
|
|
|
if(sortedItems.find(name) != sortedItems.end()) {
|
|
hasDup = true;
|
|
}
|
|
|
|
sortedItems[name] = 0;
|
|
}
|
|
if(hasDup) {
|
|
printf("WARNING, unit type [%s] has one or more duplicate unit requirements\n",this->getName(false).c_str());
|
|
}
|
|
|
|
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
|
|
iterMap != sortedItems.end(); ++iterMap) {
|
|
unitReqs.push_back(factionType->getUnitType(iterMap->first));
|
|
}
|
|
sortedItems.clear();
|
|
hasDup = false;
|
|
|
|
//upgrade requirements
|
|
const XmlNode *upgradeRequirementsNode= parametersNode->getChild("upgrade-requirements");
|
|
for(int i=0; i < (int)upgradeRequirementsNode->getChildCount(); ++i){
|
|
const XmlNode *upgradeReqNode= upgradeRequirementsNode->getChild("upgrade", i);
|
|
string name= upgradeReqNode->getAttribute("name")->getRestrictedValue();
|
|
|
|
if(sortedItems.find(name) != sortedItems.end()) {
|
|
hasDup = true;
|
|
}
|
|
|
|
sortedItems[name] = 0;
|
|
}
|
|
|
|
if(hasDup) {
|
|
printf("WARNING, unit type [%s] has one or more duplicate upgrade requirements\n",this->getName(false).c_str());
|
|
}
|
|
|
|
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
|
|
iterMap != sortedItems.end(); ++iterMap) {
|
|
upgradeReqs.push_back(factionType->getUpgradeType(iterMap->first));
|
|
}
|
|
sortedItems.clear();
|
|
hasDup = false;
|
|
|
|
//resource requirements
|
|
const XmlNode *resourceRequirementsNode= parametersNode->getChild("resource-requirements");
|
|
costs.resize(resourceRequirementsNode->getChildCount());
|
|
for(int i = 0; i < (int)costs.size(); ++i) {
|
|
const XmlNode *resourceNode= resourceRequirementsNode->getChild("resource", i);
|
|
string name= resourceNode->getAttribute("name")->getRestrictedValue();
|
|
int amount= resourceNode->getAttribute("amount")->getIntValue();
|
|
|
|
if(sortedItems.find(name) != sortedItems.end()) {
|
|
hasDup = true;
|
|
}
|
|
sortedItems[name] = amount;
|
|
}
|
|
//if(hasDup || sortedItems.size() != costs.size()) printf("Found duplicate resource requirement, costs.size() = %d sortedItems.size() = %d\n",costs.size(),sortedItems.size());
|
|
|
|
if(hasDup) {
|
|
printf("WARNING, unit type [%s] has one or more duplicate resource requirements\n",this->getName(false).c_str());
|
|
}
|
|
|
|
if(sortedItems.size() < costs.size()) {
|
|
costs.resize(sortedItems.size());
|
|
}
|
|
int index = 0;
|
|
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
|
|
iterMap != sortedItems.end(); ++iterMap) {
|
|
try {
|
|
costs[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
|
|
index++;
|
|
}
|
|
catch(megaglest_runtime_error& ex) {
|
|
if(validationMode == false) {
|
|
throw;
|
|
}
|
|
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;
|
|
|
|
//resources stored
|
|
const XmlNode *resourcesStoredNode= parametersNode->getChild("resources-stored");
|
|
storedResources.resize(resourcesStoredNode->getChildCount());
|
|
for(int i=0; i < (int)storedResources.size(); ++i){
|
|
const XmlNode *resourceNode= resourcesStoredNode->getChild("resource", i);
|
|
string name= resourceNode->getAttribute("name")->getRestrictedValue();
|
|
int amount= resourceNode->getAttribute("amount")->getIntValue();
|
|
|
|
if(sortedItems.find(name) != sortedItems.end()) {
|
|
hasDup = true;
|
|
}
|
|
|
|
sortedItems[name] = amount;
|
|
}
|
|
|
|
if(hasDup) {
|
|
printf("WARNING, unit type [%s] has one or more duplicate stored resources\n",this->getName(false).c_str());
|
|
}
|
|
|
|
if(sortedItems.size() < storedResources.size()) {
|
|
storedResources.resize(sortedItems.size());
|
|
}
|
|
|
|
index = 0;
|
|
for(std::map<string,int>::iterator iterMap = sortedItems.begin();
|
|
iterMap != sortedItems.end(); ++iterMap) {
|
|
try {
|
|
storedResources[index].init(techTree->getResourceType(iterMap->first), iterMap->second);
|
|
index++;
|
|
}
|
|
catch(megaglest_runtime_error& ex) {
|
|
if(validationMode == false) {
|
|
throw;
|
|
}
|
|
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();
|
|
//hasDup = false;
|
|
|
|
// Lootable resources (resources given/lost on death)
|
|
if(parametersNode->hasChild("resources-death")) {
|
|
const XmlNode *deathResourcesNode= parametersNode->getChild("resources-death");
|
|
|
|
for(unsigned int i = 0; i < deathResourcesNode->getChildCount(); ++i){
|
|
const XmlNode *resourceNode= deathResourcesNode->getChild("resource", i);
|
|
string name= resourceNode->getAttribute("name")->getRestrictedValue();
|
|
|
|
LootableResource resource;
|
|
resource.setResourceType(techTree->getResourceType(name));
|
|
|
|
// All attributes are optional, although nothing happens if they aren't used. They can
|
|
// be combined freely. Percentages will take affect before absolute values.
|
|
if(resourceNode->hasAttribute("amount-value")) {
|
|
resource.setAmountValue(resourceNode->getAttribute("amount-value")->getIntValue());
|
|
}
|
|
else {
|
|
resource.setAmountValue(0);
|
|
}
|
|
|
|
if(resourceNode->hasAttribute("amount-faction-percent")) {
|
|
resource.setAmountFactionPercent(resourceNode->getAttribute("amount-faction-percent")->getIntValue());
|
|
}
|
|
else {
|
|
resource.setAmountFactionPercent(0);
|
|
}
|
|
|
|
if(resourceNode->hasAttribute("loss-value")) {
|
|
resource.setLossValue(resourceNode->getAttribute("loss-value")->getIntValue());
|
|
}
|
|
else {
|
|
resource.setLossValue(0);
|
|
}
|
|
|
|
if(resourceNode->hasAttribute("loss-faction-percent")) {
|
|
resource.setLossFactionPercent(resourceNode->getAttribute("loss-faction-percent")->getIntValue());
|
|
}
|
|
else {
|
|
resource.setLossFactionPercent(0);
|
|
}
|
|
|
|
if(resourceNode->hasAttribute("allow-negative")) {
|
|
resource.setNegativeAllowed(resourceNode->getAttribute("allow-negative")->getBoolValue());
|
|
}
|
|
else {
|
|
resource.setNegativeAllowed(false);
|
|
}
|
|
|
|
// Figure out if there are duplicate resources. The value stored in the map is arbitrary,
|
|
// and exists solely because
|
|
if(std::find(lootableResources.begin(), lootableResources.end(), resource) != lootableResources.end()) {
|
|
printf("WARNING, unit type [%s] has one or more duplicate lootable resources\n", this->getName(false).c_str());
|
|
}
|
|
|
|
lootableResources.push_back(resource);
|
|
}
|
|
}
|
|
|
|
// Tags
|
|
if(parametersNode->hasChild("tags")) {
|
|
const XmlNode *tagsNode= parametersNode->getChild("tags");
|
|
|
|
for(unsigned int i = 0; i < tagsNode->getChildCount(); ++i){
|
|
const XmlNode *resourceNode= tagsNode->getChild("tag", i);
|
|
string tag= resourceNode->getAttribute("value")->getRestrictedValue();
|
|
tags.insert(tag);
|
|
}
|
|
}
|
|
|
|
//image
|
|
const XmlNode *imageNode= parametersNode->getChild("image");
|
|
image= Renderer::getInstance().newTexture2D(rsGame);
|
|
if(image) {
|
|
image->load(imageNode->getAttribute("path")->getRestrictedValue(currentPath));
|
|
}
|
|
loadedFileList[imageNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,imageNode->getAttribute("path")->getRestrictedValue()));
|
|
|
|
//image cancel
|
|
const XmlNode *imageCancelNode= parametersNode->getChild("image-cancel");
|
|
cancelImage= Renderer::getInstance().newTexture2D(rsGame);
|
|
if(cancelImage) {
|
|
cancelImage->load(imageCancelNode->getAttribute("path")->getRestrictedValue(currentPath));
|
|
}
|
|
loadedFileList[imageCancelNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,imageCancelNode->getAttribute("path")->getRestrictedValue()));
|
|
|
|
//meeting point
|
|
const XmlNode *meetingPointNode= parametersNode->getChild("meeting-point");
|
|
meetingPoint= meetingPointNode->getAttribute("value")->getBoolValue();
|
|
if(meetingPoint) {
|
|
meetingPointImage= Renderer::getInstance().newTexture2D(rsGame);
|
|
if(meetingPointImage) {
|
|
meetingPointImage->load(meetingPointNode->getAttribute("image-path")->getRestrictedValue(currentPath));
|
|
}
|
|
loadedFileList[meetingPointNode->getAttribute("image-path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,meetingPointNode->getAttribute("image-path")->getRestrictedValue()));
|
|
}
|
|
|
|
//countUnitDeathInStats
|
|
if(parametersNode->hasChild("count-unit-death-in-stats")){
|
|
const XmlNode *countUnitDeathInStatsNode= parametersNode->getChild("count-unit-death-in-stats");
|
|
countUnitDeathInStats= countUnitDeathInStatsNode->getAttribute("value")->getBoolValue();
|
|
}
|
|
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 {
|
|
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 {
|
|
countUnitKillInStats=true;
|
|
}
|
|
|
|
//countKillForUnitUpgrade
|
|
if(parametersNode->hasChild("count-kill-for-unit-upgrade")){
|
|
const XmlNode *countKillForUnitUpgradeNode= parametersNode->getChild("count-kill-for-unit-upgrade");
|
|
countKillForUnitUpgrade= countKillForUnitUpgradeNode->getAttribute("value")->getBoolValue();
|
|
} else {
|
|
countKillForUnitUpgrade=true;
|
|
}
|
|
|
|
if(countKillForUnitUpgrade == false){
|
|
// it makes no sense if we count it in stats but not for upgrades
|
|
countUnitKillInStats=false;
|
|
}
|
|
|
|
//selection sounds
|
|
const XmlNode *selectionSoundNode= parametersNode->getChild("selection-sounds");
|
|
if(selectionSoundNode->getAttribute("enabled")->getBoolValue()){
|
|
selectionSounds.resize((int)selectionSoundNode->getChildCount());
|
|
for(int i = 0; i < (int)selectionSounds.getSounds().size(); ++i) {
|
|
const XmlNode *soundNode= selectionSoundNode->getChild("sound", i);
|
|
string path= soundNode->getAttribute("path")->getRestrictedValue(currentPath);
|
|
StaticSound *sound= new StaticSound();
|
|
sound->load(path);
|
|
loadedFileList[path].push_back(make_pair(sourceXMLFile,soundNode->getAttribute("path")->getRestrictedValue()));
|
|
selectionSounds[i]= sound;
|
|
}
|
|
}
|
|
|
|
//command sounds
|
|
const XmlNode *commandSoundNode= parametersNode->getChild("command-sounds");
|
|
if(commandSoundNode->getAttribute("enabled")->getBoolValue()) {
|
|
commandSounds.resize((int)commandSoundNode->getChildCount());
|
|
for(int i = 0; i < (int)commandSoundNode->getChildCount(); ++i) {
|
|
const XmlNode *soundNode= commandSoundNode->getChild("sound", i);
|
|
string path= soundNode->getAttribute("path")->getRestrictedValue(currentPath);
|
|
StaticSound *sound= new StaticSound();
|
|
sound->load(path);
|
|
loadedFileList[path].push_back(make_pair(sourceXMLFile,soundNode->getAttribute("path")->getRestrictedValue()));
|
|
commandSounds[i]= sound;
|
|
}
|
|
}
|
|
|
|
//skills
|
|
|
|
const XmlNode *attackBoostsNode= NULL;
|
|
if(unitNode->hasChild("attack-boosts") == true) {
|
|
attackBoostsNode=unitNode->getChild("attack-boosts");
|
|
}
|
|
|
|
const XmlNode *skillsNode= unitNode->getChild("skills");
|
|
skillTypes.resize(skillsNode->getChildCount());
|
|
|
|
snprintf(szBuf,8096,Lang::getInstance().getString("LogScreenGameLoadingUnitTypeSkills","",true).c_str(),formatString(this->getName(true)).c_str(),skillTypes.size());
|
|
Logger::getInstance().add(szBuf, true);
|
|
|
|
for(int i = 0; i < (int)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);
|
|
|
|
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;
|
|
}
|
|
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
|
|
const XmlNode *commandsNode= unitNode->getChild("commands");
|
|
commandTypes.resize(commandsNode->getChildCount());
|
|
for(int i = 0; i < (int)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);
|
|
|
|
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;
|
|
}
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
sortCommandTypes(commandTypes);
|
|
|
|
computeFirstStOfClass();
|
|
computeFirstCtOfClass();
|
|
|
|
if(getFirstStOfClass(scStop)==NULL){
|
|
throw megaglest_runtime_error("Every unit must have at least one stop skill: "+ path,true);
|
|
}
|
|
if(getFirstStOfClass(scDie)==NULL){
|
|
throw megaglest_runtime_error("Every unit must have at least one die skill: "+ path,true);
|
|
}
|
|
|
|
}
|
|
//Exception handling (conversions and so on);
|
|
catch(megaglest_runtime_error& ex) {
|
|
SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,ex.what());
|
|
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 + "\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__);
|
|
}
|
|
|
|
// ==================== get ====================
|
|
|
|
const Level *UnitType::getLevel(string name) const {
|
|
const Level *result = NULL;
|
|
for(unsigned int i = 0; i < levels.size(); ++i) {
|
|
const Level &level = levels[i];
|
|
if(level.getName() == name) {
|
|
result = &level;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
const CommandType *UnitType::getFirstCtOfClass(CommandClass commandClass) const{
|
|
if(firstCommandTypeOfClass[commandClass] == NULL) {
|
|
return NULL;
|
|
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] commandClass = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,commandClass);
|
|
|
|
/*
|
|
for(int j=0; j<ccCount; ++j){
|
|
for(int i=0; i<commandTypes.size(); ++i){
|
|
if(commandTypes[i]->getClass()== CommandClass(j)){
|
|
return commandTypes[i];
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
|
|
}
|
|
return firstCommandTypeOfClass[commandClass];
|
|
}
|
|
|
|
const SkillType *UnitType::getFirstStOfClass(SkillClass skillClass) const{
|
|
if(firstSkillTypeOfClass[skillClass] == NULL) {
|
|
/*
|
|
for(int j= 0; j<scCount; ++j){
|
|
for(int i= 0; i<skillTypes.size(); ++i){
|
|
if(skillTypes[i]->getClass()== SkillClass(j)){
|
|
return skillTypes[i];
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
|
|
}
|
|
return firstSkillTypeOfClass[skillClass];
|
|
}
|
|
|
|
const HarvestCommandType *UnitType::getFirstHarvestCommand(const ResourceType *resourceType, const Faction *faction) const {
|
|
for(int i = 0; i < (int)commandTypes.size(); ++i) {
|
|
if(commandTypes[i]->getClass() == ccHarvest) {
|
|
const HarvestCommandType *hct = static_cast<const HarvestCommandType*>(commandTypes[i]);
|
|
|
|
if (faction->reqsOk(hct) == false) {
|
|
continue;
|
|
}
|
|
|
|
if(hct->canHarvest(resourceType)) {
|
|
return hct;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const HarvestEmergencyReturnCommandType *UnitType::getFirstHarvestEmergencyReturnCommand() const {
|
|
const HarvestEmergencyReturnCommandType *result = dynamic_cast<const HarvestEmergencyReturnCommandType *>(ctHarvestEmergencyReturnCommandType.get());
|
|
return result;
|
|
}
|
|
|
|
const AttackCommandType *UnitType::getFirstAttackCommand(Field field) const{
|
|
//printf("$$$ Unit [%s] commandTypes.size() = %d\n",this->getName().c_str(),(int)commandTypes.size());
|
|
|
|
for(int i = 0; i < (int)commandTypes.size(); ++i){
|
|
if(commandTypes[i] == NULL) {
|
|
throw megaglest_runtime_error("commandTypes[i] == NULL");
|
|
}
|
|
|
|
//printf("$$$ Unit [%s] i = %d, commandTypes[i] [%s]\n",this->getName().c_str(),(int)i, commandTypes[i]->toString().c_str());
|
|
if(commandTypes[i]->getClass()== ccAttack){
|
|
const AttackCommandType *act= dynamic_cast<const AttackCommandType*>(commandTypes[i]);
|
|
if(act != NULL && act->getAttackSkillType()->getAttackField(field)) {
|
|
//printf("## Unit [%s] i = %d, is found\n",this->getName().c_str(),(int)i);
|
|
return act;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const AttackStoppedCommandType *UnitType::getFirstAttackStoppedCommand(Field field) const{
|
|
//printf("$$$ Unit [%s] commandTypes.size() = %d\n",this->getName().c_str(),(int)commandTypes.size());
|
|
|
|
for(int i = 0; i < (int)commandTypes.size(); ++i){
|
|
if(commandTypes[i] == NULL) {
|
|
throw megaglest_runtime_error("commandTypes[i] == NULL");
|
|
}
|
|
|
|
//printf("$$$ Unit [%s] i = %d, commandTypes[i] [%s]\n",this->getName().c_str(),(int)i, commandTypes[i]->toString().c_str());
|
|
if(commandTypes[i]->getClass()== ccAttackStopped){
|
|
const AttackStoppedCommandType *act= dynamic_cast<const AttackStoppedCommandType*>(commandTypes[i]);
|
|
if(act != NULL && act->getAttackSkillType()->getAttackField(field)) {
|
|
//printf("## Unit [%s] i = %d, is found\n",this->getName().c_str(),(int)i);
|
|
return act;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const RepairCommandType *UnitType::getFirstRepairCommand(const UnitType *repaired) const{
|
|
for(int i=0; i < (int)commandTypes.size(); ++i){
|
|
if(commandTypes[i]->getClass()== ccRepair){
|
|
const RepairCommandType *rct= static_cast<const RepairCommandType*>(commandTypes[i]);
|
|
if(rct->isRepairableUnitType(repaired)){
|
|
return rct;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool UnitType::hasEmptyCellMap() const {
|
|
//checkItemInVault(&(this->size),this->size);
|
|
bool result = (size > 0);
|
|
for(int i = 0; result == true && i < size; ++i) {
|
|
for(int j = 0; j < size; ++j){
|
|
if(cellMap[i*size+j] == true) {
|
|
result = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Vec2i UnitType::getFirstOccupiedCellInCellMap(Vec2i currentPos) const {
|
|
Vec2i cell = currentPos;
|
|
//printf("\n\n\n\n^^^^^^^^^^ currentPos [%s] size [%d]\n",currentPos.getString().c_str(),size);
|
|
|
|
//checkItemInVault(&(this->size),this->size);
|
|
if(hasCellMap() == true) {
|
|
for(int i = 0; i < size; ++i) {
|
|
for(int j = 0; j < size; ++j){
|
|
if(cellMap[i*size+j] == true) {
|
|
cell.x += i;
|
|
cell.y += j;
|
|
//printf("\n^^^^^^^^^^ cell [%s] i [%d] j [%d]\n",cell.getString().c_str(),i,j);
|
|
return cell;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return cell;
|
|
}
|
|
|
|
bool UnitType::getCellMapCell(int x, int y, CardinalDir facing) const {
|
|
assert(cellMap);
|
|
if(cellMap == NULL) {
|
|
throw megaglest_runtime_error("cellMap == NULL");
|
|
}
|
|
|
|
//checkItemInVault(&(this->size),this->size);
|
|
int tmp=0;
|
|
switch (facing) {
|
|
case CardinalDir::EAST:
|
|
tmp = y;
|
|
y = x;
|
|
x = size - tmp - 1;
|
|
break;
|
|
case CardinalDir::SOUTH:
|
|
x = size - x - 1;
|
|
y = size - y - 1;
|
|
break;
|
|
case CardinalDir::WEST:
|
|
tmp = x;
|
|
x = y;
|
|
y = size - tmp - 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return cellMap[y * size + x];
|
|
}
|
|
|
|
int UnitType::getStore(const ResourceType *rt) const{
|
|
for(int i=0; i < (int)storedResources.size(); ++i){
|
|
if(storedResources[i].getType()==rt){
|
|
return storedResources[i].getAmount();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const SkillType *UnitType::getSkillType(const string &skillName, SkillClass skillClass) const{
|
|
for(int i=0; i < (int)skillTypes.size(); ++i){
|
|
if(skillTypes[i]->getName()==skillName){
|
|
if(skillTypes[i]->getClass()==skillClass){
|
|
return skillTypes[i];
|
|
}
|
|
else{
|
|
throw megaglest_runtime_error("Skill \""+skillName+"\" is not of class \""+SkillType::skillClassToStr(skillClass));
|
|
}
|
|
}
|
|
}
|
|
throw megaglest_runtime_error("No skill named \""+skillName+"\"");
|
|
}
|
|
|
|
// ==================== totals ====================
|
|
|
|
int UnitType::getTotalMaxHp(const TotalUpgrade *totalUpgrade) const {
|
|
checkItemInVault(&(this->maxHp),this->maxHp);
|
|
int result = maxHp + totalUpgrade->getMaxHp();
|
|
result = max(0,result);
|
|
return result;
|
|
}
|
|
|
|
int UnitType::getTotalMaxHpRegeneration(const TotalUpgrade *totalUpgrade) const {
|
|
checkItemInVault(&(this->hpRegeneration),this->hpRegeneration);
|
|
int result = hpRegeneration + totalUpgrade->getMaxHpRegeneration();
|
|
//result = max(0,result);
|
|
return result;
|
|
}
|
|
|
|
int UnitType::getTotalMaxEp(const TotalUpgrade *totalUpgrade) const {
|
|
checkItemInVault(&(this->maxEp),this->maxEp);
|
|
int result = maxEp + totalUpgrade->getMaxEp();
|
|
result = max(0,result);
|
|
return result;
|
|
}
|
|
|
|
int UnitType::getTotalMaxEpRegeneration(const TotalUpgrade *totalUpgrade) const {
|
|
checkItemInVault(&(this->epRegeneration),this->epRegeneration);
|
|
int result = epRegeneration + totalUpgrade->getMaxEpRegeneration();
|
|
//result = max(0,result);
|
|
return result;
|
|
}
|
|
|
|
int UnitType::getTotalArmor(const TotalUpgrade *totalUpgrade) const {
|
|
checkItemInVault(&(this->armor),this->armor);
|
|
int result = armor + totalUpgrade->getArmor();
|
|
result = max(0,result);
|
|
return result;
|
|
}
|
|
|
|
int UnitType::getTotalSight(const TotalUpgrade *totalUpgrade) const {
|
|
checkItemInVault(&(this->sight),this->sight);
|
|
int result = sight + totalUpgrade->getSight();
|
|
result = max(0,result);
|
|
return result;
|
|
}
|
|
|
|
// ==================== has ====================
|
|
|
|
bool UnitType::hasSkillClass(SkillClass skillClass) const {
|
|
return firstSkillTypeOfClass[skillClass]!=NULL;
|
|
}
|
|
|
|
bool UnitType::hasCommandType(const CommandType *commandType) const {
|
|
assert(commandType!=NULL);
|
|
|
|
const HarvestEmergencyReturnCommandType *result = dynamic_cast<const HarvestEmergencyReturnCommandType *>(ctHarvestEmergencyReturnCommandType.get());
|
|
if(commandType == result) {
|
|
return true;
|
|
}
|
|
|
|
for(int i=0; i < (int)commandTypes.size(); ++i) {
|
|
if(commandTypes[i]==commandType) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//bool UnitType::hasSkillType(const SkillType *skillType) const {
|
|
// assert(skillType!=NULL);
|
|
// for(int i=0; i < (int)skillTypes.size(); ++i) {
|
|
// if(skillTypes[i]==skillType) {
|
|
// return true;
|
|
// }
|
|
// }
|
|
// return false;
|
|
//}
|
|
|
|
bool UnitType::isOfClass(UnitClass uc) const{
|
|
switch(uc){
|
|
case ucWarrior:
|
|
return hasSkillClass(scAttack) && !hasSkillClass(scHarvest);
|
|
case ucWorker:
|
|
return hasSkillClass(scBuild) || hasSkillClass(scRepair)|| hasSkillClass(scHarvest);
|
|
case ucBuilding:
|
|
return hasSkillClass(scBeBuilt);
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ==================== PRIVATE ====================
|
|
|
|
void UnitType::computeFirstStOfClass() {
|
|
for(int j= 0; j < scCount; ++j) {
|
|
firstSkillTypeOfClass[j]= NULL;
|
|
for(int i= 0; i < (int)skillTypes.size(); ++i) {
|
|
if(skillTypes[i] != NULL && skillTypes[i]->getClass()== SkillClass(j)) {
|
|
firstSkillTypeOfClass[j]= skillTypes[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UnitType::computeFirstCtOfClass() {
|
|
for(int j = 0; j < ccCount; ++j) {
|
|
firstCommandTypeOfClass[j]= NULL;
|
|
for(int i = 0; i < (int)commandTypes.size(); ++i) {
|
|
if(commandTypes[i] != NULL && commandTypes[i]->getClass() == CommandClass(j)) {
|
|
firstCommandTypeOfClass[j] = commandTypes[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UnitType::sortCommandTypes(CommandTypes cts){
|
|
try{
|
|
CommandTypes ctCores, ctBasics = {NULL,NULL,NULL,NULL}, ctMorphs, ctAttack;
|
|
vector<int> basicNulls = {0,1,2,3};
|
|
|
|
//Morphs
|
|
for(int i = (int)cts.size(); i --> 0; ) {
|
|
if(cts[i]->getClass() == ccMorph) {
|
|
ctMorphs.insert(ctMorphs.begin(), cts[i]);
|
|
cts.erase(cts.begin() + i);
|
|
}
|
|
}
|
|
|
|
//Attacks
|
|
CommandTypeFilter(cts, ctAttack, ccAttack);
|
|
if(ctAttack.size() > 0) {
|
|
ctBasics[CommandHelper::getBasicPos(ccAttack)] = ctAttack[0];// first attack to basics
|
|
basicNulls.erase(basicNulls.begin());
|
|
ctAttack.erase(ctAttack.begin());// another to cores, see below
|
|
}
|
|
|
|
//Basics
|
|
for(int i = (int)cts.size(); i --> 0; ) {
|
|
for(auto &&cc : CommandHelper::getBasicsCC()){
|
|
if(cc == ccAttack) continue;// we catch all attacks above
|
|
if(cts[i]->getClass() == cc) {
|
|
auto ccPos = CommandHelper::getBasicPos(cc);
|
|
ctBasics[ccPos] = cts[i];
|
|
cts.erase(cts.begin() + i);
|
|
basicNulls.erase(std::remove(basicNulls.begin(), basicNulls.end(), ccPos), basicNulls.end());
|
|
}
|
|
}
|
|
}
|
|
|
|
//Cores
|
|
for(auto &&cc : CommandHelper::getCoresCC()){
|
|
if(cc == ccAttack) ctCores.insert(ctCores.end(), ctAttack.begin(), ctAttack.end());
|
|
else CommandTypeFilter(cts, ctCores, cc);
|
|
}
|
|
int nullCount = 4 - ctCores.size();
|
|
for(int i=0; i<nullCount; i++){
|
|
ctCores.push_back(NULL);
|
|
}
|
|
|
|
if(nullCount < 0) {//magic: if we cant push all commands to cores
|
|
CommandTypes ctToBasics(ctCores.end() + nullCount, ctCores.end());
|
|
ctCores.resize(4);
|
|
for(int i = (int)ctToBasics.size(); i --> 0; ) {// we push it to basics
|
|
ctBasics[basicNulls[i]] = ctToBasics[i];
|
|
basicNulls.erase(basicNulls.begin() + i);
|
|
}
|
|
}
|
|
|
|
commandTypesSorted.insert(commandTypesSorted.end(), ctCores.begin(), ctCores.end());
|
|
commandTypesSorted.insert(commandTypesSorted.end(), ctBasics.begin(), ctBasics.end());
|
|
commandTypesSorted.insert(commandTypesSorted.end(), ctMorphs.begin(), ctMorphs.end());
|
|
} catch(exception &ex){
|
|
|
|
}
|
|
}
|
|
|
|
void UnitType::CommandTypeFilter(CommandTypes &input, CommandTypes &output, CommandClass cc){
|
|
std::copy_if(input.begin(), input.end(), std::back_inserter(output), [cc](CommandType* i) {
|
|
if(i->getClass() == cc)
|
|
return true;
|
|
else return false;
|
|
});
|
|
}
|
|
|
|
const CommandType* UnitType::findCommandTypeById(int id) const{
|
|
const HarvestEmergencyReturnCommandType *result = dynamic_cast<const HarvestEmergencyReturnCommandType *>(ctHarvestEmergencyReturnCommandType.get());
|
|
if(result != NULL && id == result->getId()) {
|
|
return result;
|
|
}
|
|
|
|
for(int i=0; i < getCommandTypeCount(); ++i) {
|
|
const CommandType *commandType= getCommandType(i);
|
|
if(commandType->getId() == id){
|
|
return commandType;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const CommandType *UnitType::getCommandType(int i) const {
|
|
if(i >= (int)commandTypes.size()) {
|
|
char szBuf[8096]="";
|
|
snprintf(szBuf,8096,"In [%s::%s Line: %d] i >= commandTypes.size(), i = %d, commandTypes.size() = " MG_SIZE_T_SPECIFIER "",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,i,commandTypes.size());
|
|
throw megaglest_runtime_error(szBuf);
|
|
}
|
|
return commandTypes[i];
|
|
}
|
|
|
|
const CommandType *UnitType::getCommandTypeSorted(int i) const {
|
|
if(i >= (int)commandTypesSorted.size()) {
|
|
char szBuf[8096]="";
|
|
snprintf(szBuf,8096,"In [%s::%s Line: %d] i >= commandTypesSorted.size(), i = %d, commandTypesSorted.size() = " MG_SIZE_T_SPECIFIER "",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,i,commandTypesSorted.size());
|
|
throw megaglest_runtime_error(szBuf);
|
|
}
|
|
return commandTypesSorted[i];
|
|
}
|
|
|
|
string UnitType::getCommandTypeListDesc() const {
|
|
string desc = "Commands: ";
|
|
for(int i=0; i<getCommandTypeCount(); ++i){
|
|
const CommandType* commandType= getCommandType(i);
|
|
desc += " id = " + intToStr(commandType->getId()); + " toString: " + commandType->toString(false);
|
|
}
|
|
return desc;
|
|
|
|
}
|
|
|
|
string UnitType::getReqDesc(bool translatedValue) const{
|
|
Lang &lang= Lang::getInstance();
|
|
//string desc = "Limits: ";
|
|
string resultTxt="";
|
|
|
|
checkItemInVault(&(this->maxUnitCount),this->maxUnitCount);
|
|
if(getMaxUnitCount() > 0) {
|
|
resultTxt += "\n" + lang.getString("MaxUnitCount") + " " + intToStr(getMaxUnitCount());
|
|
}
|
|
if(resultTxt == "")
|
|
return ProducibleType::getReqDesc(translatedValue);
|
|
else
|
|
return ProducibleType::getReqDesc(translatedValue)+"\n" + lang.getString("Limits") + " " + resultTxt;
|
|
}
|
|
|
|
string UnitType::getName(bool translatedValue) const {
|
|
if(translatedValue == false) return name;
|
|
|
|
Lang &lang = Lang::getInstance();
|
|
return lang.getTechTreeString("UnitTypeName_" + name,name.c_str());
|
|
}
|
|
|
|
std::string UnitType::toString() const {
|
|
std::string result = "Unit Name: [" + name + "] id = " + intToStr(id);
|
|
result += " maxHp = " + intToStr(maxHp);
|
|
result += " hpRegeneration = " + intToStr(hpRegeneration);
|
|
result += " maxEp = " + intToStr(maxEp);
|
|
result += " startEpValue = " + intToStr(startEpValue);
|
|
result += " startEpPercentage = " + intToStr(startEpPercentage);
|
|
result += " epRegeneration = " + intToStr(epRegeneration);
|
|
result += " maxUnitCount = " + intToStr(getMaxUnitCount());
|
|
|
|
|
|
for(int i = 0; i < fieldCount; i++) {
|
|
result += " fields index = " + intToStr(i) + " value = " + intToStr(fields[i]);
|
|
}
|
|
for(int i = 0; i < pCount; i++) {
|
|
result += " properties index = " + intToStr(i) + " value = " + intToStr(properties[i]);
|
|
}
|
|
|
|
result += " armor = " + intToStr(armor);
|
|
|
|
if(armorType != NULL) {
|
|
result += " armorType Name: [" + armorType->getName(false) + " id = " + intToStr(armorType->getId());
|
|
}
|
|
|
|
result += " light = " + intToStr(light);
|
|
result += " lightColor = " + lightColor.getString();
|
|
result += " multiSelect = " + intToStr(multiSelect);
|
|
result += " uniformSelect = " + intToStr(uniformSelect);
|
|
result += " commandable = " + intToStr(commandable);
|
|
result += " sight = " + intToStr(sight);
|
|
result += " size = " + intToStr(size);
|
|
result += " height = " + intToStr(height);
|
|
result += " rotatedBuildPos = " + floatToStr(rotatedBuildPos,6);
|
|
result += " rotationAllowed = " + intToStr(rotationAllowed);
|
|
|
|
if(cellMap != NULL) {
|
|
result += " cellMap: [" + intToStr(size) + "]";
|
|
for(int i = 0; i < size; ++i) {
|
|
for(int j = 0; j < size; ++j){
|
|
result += " i = " + intToStr(i) + " j = " + intToStr(j) + " value = " + intToStr(cellMap[i*size+j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
result += " skillTypes: [" + intToStr(skillTypes.size()) + "]";
|
|
for(int i = 0; i < (int)skillTypes.size(); ++i) {
|
|
result += " i = " + intToStr(i) + " " + skillTypes[i]->toString(false);
|
|
}
|
|
|
|
result += " commandTypes: [" + intToStr(commandTypes.size()) + "]";
|
|
for(int i = 0; i < (int)commandTypes.size(); ++i) {
|
|
result += " i = " + intToStr(i) + " " + commandTypes[i]->toString(false);
|
|
}
|
|
|
|
result += " storedResources: [" + intToStr(storedResources.size()) + "]";
|
|
for(int i = 0; i < (int)storedResources.size(); ++i) {
|
|
result += " i = " + intToStr(i) + " " + storedResources[i].getDescription(false);
|
|
}
|
|
|
|
result += " levels: [" + intToStr(levels.size()) + "]";
|
|
for(int i = 0; i < (int)levels.size(); ++i) {
|
|
result += " i = " + intToStr(i) + " " + levels[i].getName();
|
|
}
|
|
|
|
result += " meetingPoint = " + intToStr(meetingPoint);
|
|
|
|
result += " countInVictoryConditions = " + intToStr(countInVictoryConditions);
|
|
|
|
return result;
|
|
}
|
|
|
|
}}//end namespace
|