- bugfix for game save and load (string buffer was too small for one item)
This commit is contained in:
parent
38bd33acf9
commit
917adc8c98
|
@ -3833,6 +3833,7 @@ Unit * Unit::loadGame(const XmlNode *rootNode, GameSettings *settings, Faction *
|
||||||
// UnitParticleSystem *ups= unitParticleSystems[i];
|
// UnitParticleSystem *ups= unitParticleSystems[i];
|
||||||
// ups->saveGame(unitNode);
|
// ups->saveGame(unitNode);
|
||||||
// }
|
// }
|
||||||
|
|
||||||
// vector<UnitParticleSystemType*> queuedUnitParticleSystemTypes;
|
// vector<UnitParticleSystemType*> queuedUnitParticleSystemTypes;
|
||||||
// for(unsigned int i = 0; i < queuedUnitParticleSystemTypes.size(); ++i) {
|
// for(unsigned int i = 0; i < queuedUnitParticleSystemTypes.size(); ++i) {
|
||||||
// UnitParticleSystemType *upst= queuedUnitParticleSystemTypes[i];
|
// UnitParticleSystemType *upst= queuedUnitParticleSystemTypes[i];
|
||||||
|
|
|
@ -1864,6 +1864,10 @@ void Map::saveGame(XmlNode *rootNode) const {
|
||||||
for(unsigned int i = 0; i < getSurfaceCellArraySize(); ++i) {
|
for(unsigned int i = 0; i < getSurfaceCellArraySize(); ++i) {
|
||||||
SurfaceCell &surfaceCell = surfaceCells[i];
|
SurfaceCell &surfaceCell = surfaceCells[i];
|
||||||
|
|
||||||
|
if(exploredList != "") {
|
||||||
|
exploredList += ",";
|
||||||
|
}
|
||||||
|
|
||||||
for(unsigned int j = 0; j < GameConstants::maxPlayers; ++j) {
|
for(unsigned int j = 0; j < GameConstants::maxPlayers; ++j) {
|
||||||
if(exploredList != "") {
|
if(exploredList != "") {
|
||||||
exploredList += "|";
|
exploredList += "|";
|
||||||
|
@ -1871,7 +1875,11 @@ void Map::saveGame(XmlNode *rootNode) const {
|
||||||
|
|
||||||
exploredList += intToStr(surfaceCell.isExplored(j));
|
exploredList += intToStr(surfaceCell.isExplored(j));
|
||||||
}
|
}
|
||||||
exploredList += ",";
|
|
||||||
|
if(visibleList != "") {
|
||||||
|
visibleList += ",";
|
||||||
|
}
|
||||||
|
|
||||||
for(unsigned int j = 0; j < GameConstants::maxPlayers; ++j) {
|
for(unsigned int j = 0; j < GameConstants::maxPlayers; ++j) {
|
||||||
if(visibleList != "") {
|
if(visibleList != "") {
|
||||||
visibleList += "|";
|
visibleList += "|";
|
||||||
|
@ -1879,14 +1887,24 @@ void Map::saveGame(XmlNode *rootNode) const {
|
||||||
|
|
||||||
visibleList += intToStr(surfaceCell.isVisible(j));
|
visibleList += intToStr(surfaceCell.isVisible(j));
|
||||||
}
|
}
|
||||||
visibleList += ",";
|
|
||||||
|
|
||||||
surfaceCell.saveGame(mapNode,i);
|
surfaceCell.saveGame(mapNode,i);
|
||||||
|
|
||||||
|
if(i % 100 == 0) {
|
||||||
|
XmlNode *surfaceCellNode = mapNode->addChild("SurfaceCell");
|
||||||
|
surfaceCellNode->addAttribute("exploredList",exploredList, mapTagReplacements);
|
||||||
|
surfaceCellNode->addAttribute("visibleList",visibleList, mapTagReplacements);
|
||||||
|
|
||||||
|
exploredList = "";
|
||||||
|
visibleList = "";
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
XmlNode *surfaceCellNode = mapNode->addChild("SurfaceCell");
|
if(exploredList != "") {
|
||||||
surfaceCellNode->addAttribute("exploredList",exploredList, mapTagReplacements);
|
XmlNode *surfaceCellNode = mapNode->addChild("SurfaceCell");
|
||||||
surfaceCellNode->addAttribute("visibleList",visibleList, mapTagReplacements);
|
surfaceCellNode->addAttribute("exploredList",exploredList, mapTagReplacements);
|
||||||
|
surfaceCellNode->addAttribute("visibleList",visibleList, mapTagReplacements);
|
||||||
|
}
|
||||||
|
|
||||||
// Vec2i *startLocations;
|
// Vec2i *startLocations;
|
||||||
for(unsigned int i = 0; i < maxPlayers; ++i) {
|
for(unsigned int i = 0; i < maxPlayers; ++i) {
|
||||||
|
@ -1927,40 +1945,44 @@ void Map::loadGame(const XmlNode *rootNode, World *world) {
|
||||||
surfaceCell.loadGame(mapNode,i,world);
|
surfaceCell.loadGame(mapNode,i,world);
|
||||||
}
|
}
|
||||||
|
|
||||||
XmlNode *surfaceCellNode = mapNode->getChild("SurfaceCell");
|
vector<XmlNode *> surfaceCellNodeList = mapNode->getChildList("SurfaceCell");
|
||||||
string exploredList = surfaceCellNode->getAttribute("exploredList")->getValue();
|
for(unsigned int i = 0; i < surfaceCellNodeList.size(); ++i) {
|
||||||
string visibleList = surfaceCellNode->getAttribute("visibleList")->getValue();
|
XmlNode *surfaceCellNode = surfaceCellNodeList[i];
|
||||||
|
|
||||||
vector<string> tokensExplored;
|
//XmlNode *surfaceCellNode = mapNode->getChild("SurfaceCell");
|
||||||
Tokenize(exploredList,tokensExplored,",");
|
string exploredList = surfaceCellNode->getAttribute("exploredList")->getValue();
|
||||||
for(unsigned int i = 0; i < tokensExplored.size(); ++i) {
|
string visibleList = surfaceCellNode->getAttribute("visibleList")->getValue();
|
||||||
string valueList = tokensExplored[i];
|
|
||||||
|
|
||||||
vector<string> tokensExploredValue;
|
vector<string> tokensExplored;
|
||||||
Tokenize(valueList,tokensExploredValue,"|");
|
Tokenize(exploredList,tokensExplored,",");
|
||||||
for(unsigned int j = 0; j < tokensExploredValue.size(); ++j) {
|
for(unsigned int i = 0; i < tokensExplored.size(); ++i) {
|
||||||
string value = tokensExploredValue[j];
|
string valueList = tokensExplored[i];
|
||||||
|
|
||||||
SurfaceCell &surfaceCell = surfaceCells[i];
|
vector<string> tokensExploredValue;
|
||||||
surfaceCell.setExplored(j,strToInt(value));
|
Tokenize(valueList,tokensExploredValue,"|");
|
||||||
|
for(unsigned int j = 0; j < tokensExploredValue.size(); ++j) {
|
||||||
|
string value = tokensExploredValue[j];
|
||||||
|
|
||||||
|
SurfaceCell &surfaceCell = surfaceCells[i];
|
||||||
|
surfaceCell.setExplored(j,strToInt(value));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<string> tokensVisible;
|
||||||
|
Tokenize(visibleList,tokensVisible,",");
|
||||||
|
for(unsigned int i = 0; i < tokensVisible.size(); ++i) {
|
||||||
|
string valueList = tokensVisible[i];
|
||||||
|
|
||||||
|
vector<string> tokensVisibleValue;
|
||||||
|
Tokenize(valueList,tokensVisibleValue,"|");
|
||||||
|
for(unsigned int j = 0; j < tokensVisibleValue.size(); ++j) {
|
||||||
|
string value = tokensVisibleValue[j];
|
||||||
|
|
||||||
|
SurfaceCell &surfaceCell = surfaceCells[i];
|
||||||
|
surfaceCell.setVisible(j,strToInt(value));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
vector<string> tokensVisible;
|
|
||||||
Tokenize(visibleList,tokensVisible,",");
|
|
||||||
for(unsigned int i = 0; i < tokensVisible.size(); ++i) {
|
|
||||||
string valueList = tokensVisible[i];
|
|
||||||
|
|
||||||
vector<string> tokensVisibleValue;
|
|
||||||
Tokenize(valueList,tokensVisibleValue,"|");
|
|
||||||
for(unsigned int j = 0; j < tokensVisibleValue.size(); ++j) {
|
|
||||||
string value = tokensVisibleValue[j];
|
|
||||||
|
|
||||||
SurfaceCell &surfaceCell = surfaceCells[i];
|
|
||||||
surfaceCell.setVisible(j,strToInt(value));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// =====================================================
|
// =====================================================
|
||||||
|
|
|
@ -2645,6 +2645,8 @@ void ParticleDamager::saveGame(XmlNode *rootNode) {
|
||||||
attackerRef.saveGame(particleDamagerNode);
|
attackerRef.saveGame(particleDamagerNode);
|
||||||
|
|
||||||
// const AttackSkillType* ast;
|
// const AttackSkillType* ast;
|
||||||
|
particleDamagerNode->addAttribute("astName",ast->getName(), mapTagReplacements);
|
||||||
|
particleDamagerNode->addAttribute("astClass",intToStr(ast->getClass()), mapTagReplacements);
|
||||||
// UnitUpdater *unitUpdater;
|
// UnitUpdater *unitUpdater;
|
||||||
// const GameCamera *gameCamera;
|
// const GameCamera *gameCamera;
|
||||||
// Vec2i targetPos;
|
// Vec2i targetPos;
|
||||||
|
@ -2653,4 +2655,27 @@ void ParticleDamager::saveGame(XmlNode *rootNode) {
|
||||||
particleDamagerNode->addAttribute("targetField",intToStr(targetField), mapTagReplacements);
|
particleDamagerNode->addAttribute("targetField",intToStr(targetField), mapTagReplacements);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void ParticleDamager::loadGame(const XmlNode *rootNode, void *genericData) {
|
||||||
|
const XmlNode *particleDamagerNode = rootNode->getChild("ParticleDamager");
|
||||||
|
|
||||||
|
std::pair<Game *,Unit *> *pairData = (std::pair<Game *,Unit *>*)genericData;
|
||||||
|
//UnitType *ut, Game *game
|
||||||
|
attackerRef.loadGame(particleDamagerNode,pairData->first->getWorld());
|
||||||
|
|
||||||
|
//random.setLastNumber(particleSystemNode->getAttribute("random")->getIntValue());
|
||||||
|
|
||||||
|
// const AttackSkillType* ast;
|
||||||
|
string astName = particleDamagerNode->getAttribute("astName")->getValue();
|
||||||
|
SkillClass astClass = static_cast<SkillClass>(particleDamagerNode->getAttribute("astClass")->getIntValue());
|
||||||
|
ast = dynamic_cast<const AttackSkillType*>(pairData->second->getType()->getSkillType(astName,astClass));
|
||||||
|
// UnitUpdater *unitUpdater;
|
||||||
|
unitUpdater = pairData->first->getWorld()->getUnitUpdater();
|
||||||
|
// const GameCamera *gameCamera;
|
||||||
|
gameCamera = pairData->first->getGameCamera();
|
||||||
|
// Vec2i targetPos;
|
||||||
|
targetPos = Vec2i::strToVec2(particleDamagerNode->getAttribute("targetPos")->getValue());
|
||||||
|
// Field targetField;
|
||||||
|
targetField = static_cast<Field>(particleDamagerNode->getAttribute("targetField")->getIntValue());
|
||||||
|
}
|
||||||
|
|
||||||
}}//end namespace
|
}}//end namespace
|
||||||
|
|
|
@ -157,7 +157,8 @@ private:
|
||||||
// class ParticleDamager
|
// class ParticleDamager
|
||||||
// =====================================================
|
// =====================================================
|
||||||
|
|
||||||
class ParticleDamager: public ParticleObserver{
|
class ParticleDamager: public ParticleObserver {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
UnitReference attackerRef;
|
UnitReference attackerRef;
|
||||||
const AttackSkillType* ast;
|
const AttackSkillType* ast;
|
||||||
|
@ -169,7 +170,9 @@ public:
|
||||||
public:
|
public:
|
||||||
ParticleDamager(Unit *attacker, UnitUpdater *unitUpdater, const GameCamera *gameCamera);
|
ParticleDamager(Unit *attacker, UnitUpdater *unitUpdater, const GameCamera *gameCamera);
|
||||||
virtual void update(ParticleSystem *particleSystem);
|
virtual void update(ParticleSystem *particleSystem);
|
||||||
|
|
||||||
virtual void saveGame(XmlNode *rootNode);
|
virtual void saveGame(XmlNode *rootNode);
|
||||||
|
virtual void loadGame(const XmlNode *rootNode,void *genericData);
|
||||||
};
|
};
|
||||||
|
|
||||||
}}//end namespace
|
}}//end namespace
|
||||||
|
|
|
@ -68,6 +68,7 @@ public:
|
||||||
int getEnergy() const {return energy;}
|
int getEnergy() const {return energy;}
|
||||||
|
|
||||||
void saveGame(XmlNode *rootNode);
|
void saveGame(XmlNode *rootNode);
|
||||||
|
void loadGame(const XmlNode *rootNode);
|
||||||
};
|
};
|
||||||
|
|
||||||
// =====================================================
|
// =====================================================
|
||||||
|
@ -79,6 +80,7 @@ public:
|
||||||
virtual ~ParticleObserver(){};
|
virtual ~ParticleObserver(){};
|
||||||
virtual void update(ParticleSystem *particleSystem)= 0;
|
virtual void update(ParticleSystem *particleSystem)= 0;
|
||||||
virtual void saveGame(XmlNode *rootNode) = 0;
|
virtual void saveGame(XmlNode *rootNode) = 0;
|
||||||
|
virtual void loadGame(const XmlNode *rootNode, void *genericData) = 0;
|
||||||
};
|
};
|
||||||
|
|
||||||
// =====================================================
|
// =====================================================
|
||||||
|
@ -191,7 +193,8 @@ public:
|
||||||
virtual int getChildCount() { return 0; }
|
virtual int getChildCount() { return 0; }
|
||||||
virtual ParticleSystem* getChild(int i);
|
virtual ParticleSystem* getChild(int i);
|
||||||
|
|
||||||
void saveGame(XmlNode *rootNode);
|
virtual void saveGame(XmlNode *rootNode);
|
||||||
|
virtual void loadGame(const XmlNode *rootNode);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
//protected
|
//protected
|
||||||
|
@ -225,6 +228,9 @@ public:
|
||||||
//set params
|
//set params
|
||||||
void setRadius(float radius);
|
void setRadius(float radius);
|
||||||
void setWind(float windAngle, float windSpeed);
|
void setWind(float windAngle, float windSpeed);
|
||||||
|
|
||||||
|
virtual void saveGame(XmlNode *rootNode);
|
||||||
|
virtual void loadGame(const XmlNode *rootNode);
|
||||||
};
|
};
|
||||||
|
|
||||||
// =====================================================
|
// =====================================================
|
||||||
|
@ -256,6 +262,10 @@ public:
|
||||||
void setPrimitive(Primitive primitive) {this->primitive= primitive;}
|
void setPrimitive(Primitive primitive) {this->primitive= primitive;}
|
||||||
Vec3f getDirection() const {return direction;}
|
Vec3f getDirection() const {return direction;}
|
||||||
void setModelCycle(float modelCycle) {this->modelCycle= modelCycle;}
|
void setModelCycle(float modelCycle) {this->modelCycle= modelCycle;}
|
||||||
|
|
||||||
|
virtual void saveGame(XmlNode *rootNode);
|
||||||
|
virtual void loadGame(const XmlNode *rootNode);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
typedef std::vector<UnitParticleSystem*> Children;
|
typedef std::vector<UnitParticleSystem*> Children;
|
||||||
Children children;
|
Children children;
|
||||||
|
@ -362,6 +372,10 @@ public:
|
||||||
void setParentDirection(Vec3f parentDirection);
|
void setParentDirection(Vec3f parentDirection);
|
||||||
|
|
||||||
static Shape strToShape(const string& str);
|
static Shape strToShape(const string& str);
|
||||||
|
|
||||||
|
virtual void saveGame(XmlNode *rootNode);
|
||||||
|
virtual void loadGame(const XmlNode *rootNode);
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
// =====================================================
|
// =====================================================
|
||||||
|
|
|
@ -658,6 +658,48 @@ public:
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// playerColor="x [1] y [0] z [0] w [0]"
|
||||||
|
static inline Vec4<T> strToVec4(std::string value) {
|
||||||
|
Vec4<T> result;
|
||||||
|
|
||||||
|
std::vector<std::string> tokens = TokenizeString(value,"[");
|
||||||
|
//for(unsigned int i = 0; i < tokens.size(); ++i) {
|
||||||
|
//printf("#1 Vec2T i = %d [%s]\n",i,tokens[i].c_str());
|
||||||
|
//}
|
||||||
|
if(tokens.size() == 5) {
|
||||||
|
std::vector<std::string> tokens2 = TokenizeString(tokens[1],"]");
|
||||||
|
//for(unsigned int i = 0; i < tokens2.size(); ++i) {
|
||||||
|
//printf("#2 Vec2T i = %d [%s]\n",i,tokens2[i].c_str());
|
||||||
|
//}
|
||||||
|
std::vector<std::string> tokens3 = TokenizeString(tokens[2],"]");
|
||||||
|
//for(unsigned int i = 0; i < tokens3.size(); ++i) {
|
||||||
|
//printf("#3 Vec2T i = %d [%s]\n",i,tokens3[i].c_str());
|
||||||
|
//}
|
||||||
|
|
||||||
|
std::vector<std::string> tokens4 = TokenizeString(tokens[3],"]");
|
||||||
|
//for(unsigned int i = 0; i < tokens3.size(); ++i) {
|
||||||
|
//printf("#3 Vec2T i = %d [%s]\n",i,tokens3[i].c_str());
|
||||||
|
//}
|
||||||
|
|
||||||
|
std::vector<std::string> tokens5 = TokenizeString(tokens[4],"]");
|
||||||
|
//for(unsigned int i = 0; i < tokens3.size(); ++i) {
|
||||||
|
//printf("#3 Vec2T i = %d [%s]\n",i,tokens3[i].c_str());
|
||||||
|
//}
|
||||||
|
|
||||||
|
if(tokens2.size() == 2 && tokens3.size() == 2 &&
|
||||||
|
tokens4.size() == 2 && tokens5.size() == 2) {
|
||||||
|
result.x = (T)strToType<T>(tokens2[0]);
|
||||||
|
result.y = (T)strToType<T>(tokens3[0]);
|
||||||
|
result.z = (T)strToType<T>(tokens4[0]);
|
||||||
|
result.w = (T)strToType<T>(tokens5[0]);
|
||||||
|
|
||||||
|
//printf("#3 Vec2T [%s]\n",result.getString().c_str());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
typedef Vec4<int> Vec4i;
|
typedef Vec4<int> Vec4i;
|
||||||
|
|
|
@ -29,7 +29,7 @@ namespace XERCES_CPP_NAMESPACE{
|
||||||
|
|
||||||
namespace Shared{ namespace Xml{
|
namespace Shared{ namespace Xml{
|
||||||
|
|
||||||
const int strSize= 4096;
|
const int strSize= 8094;
|
||||||
|
|
||||||
class XmlIo;
|
class XmlIo;
|
||||||
class XmlTree;
|
class XmlTree;
|
||||||
|
|
|
@ -21,6 +21,7 @@
|
||||||
#include "math_util.h"
|
#include "math_util.h"
|
||||||
#include "platform_common.h"
|
#include "platform_common.h"
|
||||||
#include "conversion.h"
|
#include "conversion.h"
|
||||||
|
#include "model.h"
|
||||||
#include "leak_dumper.h"
|
#include "leak_dumper.h"
|
||||||
|
|
||||||
using namespace std;
|
using namespace std;
|
||||||
|
@ -58,6 +59,26 @@ void Particle::saveGame(XmlNode *rootNode) {
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void Particle::loadGame(const XmlNode *rootNode) {
|
||||||
|
const XmlNode *particleNode = rootNode;
|
||||||
|
|
||||||
|
//particleNode = aiNode->getAttribute("startLoc")->getIntValue();
|
||||||
|
// Vec3f pos;
|
||||||
|
pos = Vec3f::strToVec3(particleNode->getAttribute("pos")->getValue());
|
||||||
|
// Vec3f lastPos;
|
||||||
|
lastPos = Vec3f::strToVec3(particleNode->getAttribute("lastPos")->getValue());
|
||||||
|
// Vec3f speed;
|
||||||
|
speed = Vec3f::strToVec3(particleNode->getAttribute("speed")->getValue());
|
||||||
|
// Vec3f accel;
|
||||||
|
accel = Vec3f::strToVec3(particleNode->getAttribute("accel")->getValue());
|
||||||
|
// Vec4f color;
|
||||||
|
color = Vec4f::strToVec4(particleNode->getAttribute("color")->getValue());
|
||||||
|
// float size;
|
||||||
|
size = particleNode->getAttribute("size")->getFloatValue();
|
||||||
|
// int energy;
|
||||||
|
energy = particleNode->getAttribute("energy")->getIntValue();
|
||||||
|
}
|
||||||
|
|
||||||
ParticleSystem::ParticleSystem(int particleCount) {
|
ParticleSystem::ParticleSystem(int particleCount) {
|
||||||
if(checkMemory) {
|
if(checkMemory) {
|
||||||
printf("++ Create ParticleSystem [%p]\n",this);
|
printf("++ Create ParticleSystem [%p]\n",this);
|
||||||
|
@ -294,6 +315,75 @@ void ParticleSystem::saveGame(XmlNode *rootNode) {
|
||||||
particleObserver->saveGame(particleSystemNode);
|
particleObserver->saveGame(particleSystemNode);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void ParticleSystem::loadGame(const XmlNode *rootNode) {
|
||||||
|
const XmlNode *particleSystemNode = rootNode->getChild("ParticleSystem");
|
||||||
|
|
||||||
|
// std::vector<Particle> particles;
|
||||||
|
// for(unsigned int i = 0; i < particles.size(); ++i) {
|
||||||
|
// Particle &particle = particles[i];
|
||||||
|
// particle.saveGame(particleSystemNode);
|
||||||
|
// }
|
||||||
|
vector<XmlNode *> particleNodeList = particleSystemNode->getChildList("Particle");
|
||||||
|
for(unsigned int i = 0; i < particleNodeList.size(); ++i) {
|
||||||
|
XmlNode *node = particleNodeList[i];
|
||||||
|
|
||||||
|
Particle particle;
|
||||||
|
particle.loadGame(node);
|
||||||
|
particles.push_back(particle);
|
||||||
|
}
|
||||||
|
|
||||||
|
// RandomGen random;
|
||||||
|
random.setLastNumber(particleSystemNode->getAttribute("random")->getIntValue());
|
||||||
|
|
||||||
|
// BlendMode blendMode;
|
||||||
|
blendMode = static_cast<BlendMode>(particleSystemNode->getAttribute("blendMode")->getIntValue());
|
||||||
|
// State state;
|
||||||
|
state = static_cast<State>(particleSystemNode->getAttribute("state")->getIntValue());
|
||||||
|
// bool active;
|
||||||
|
active = particleSystemNode->getAttribute("active")->getIntValue();
|
||||||
|
// bool visible;
|
||||||
|
visible = particleSystemNode->getAttribute("visible")->getIntValue();
|
||||||
|
// int aliveParticleCount;
|
||||||
|
aliveParticleCount = particleSystemNode->getAttribute("aliveParticleCount")->getIntValue();
|
||||||
|
// int particleCount;
|
||||||
|
particleCount = particleSystemNode->getAttribute("particleCount")->getIntValue();
|
||||||
|
//
|
||||||
|
// Texture *texture;
|
||||||
|
// Vec3f pos;
|
||||||
|
pos = Vec3f::strToVec3(particleSystemNode->getAttribute("pos")->getValue());
|
||||||
|
// Vec4f color;
|
||||||
|
color = Vec4f::strToVec4(particleSystemNode->getAttribute("color")->getValue());
|
||||||
|
// Vec4f colorNoEnergy;
|
||||||
|
colorNoEnergy = Vec4f::strToVec4(particleSystemNode->getAttribute("colorNoEnergy")->getValue());
|
||||||
|
// float emissionRate;
|
||||||
|
emissionRate = particleSystemNode->getAttribute("emissionRate")->getFloatValue();
|
||||||
|
// float emissionState;
|
||||||
|
emissionState = particleSystemNode->getAttribute("emissionState")->getFloatValue();
|
||||||
|
// int maxParticleEnergy;
|
||||||
|
maxParticleEnergy = particleSystemNode->getAttribute("maxParticleEnergy")->getIntValue();
|
||||||
|
// int varParticleEnergy;
|
||||||
|
varParticleEnergy = particleSystemNode->getAttribute("varParticleEnergy")->getIntValue();
|
||||||
|
// float particleSize;
|
||||||
|
particleSize = particleSystemNode->getAttribute("particleSize")->getFloatValue();
|
||||||
|
// float speed;
|
||||||
|
speed = particleSystemNode->getAttribute("speed")->getFloatValue();
|
||||||
|
// Vec3f factionColor;
|
||||||
|
factionColor = Vec3f::strToVec3(particleSystemNode->getAttribute("factionColor")->getValue());
|
||||||
|
// bool teamcolorNoEnergy;
|
||||||
|
teamcolorNoEnergy = particleSystemNode->getAttribute("teamcolorNoEnergy")->getIntValue();
|
||||||
|
// bool teamcolorEnergy;
|
||||||
|
teamcolorEnergy = particleSystemNode->getAttribute("teamcolorEnergy")->getIntValue();
|
||||||
|
// int alternations;
|
||||||
|
alternations = particleSystemNode->getAttribute("alternations")->getIntValue();
|
||||||
|
// int particleSystemStartDelay;
|
||||||
|
particleSystemStartDelay = particleSystemNode->getAttribute("particleSystemStartDelay")->getIntValue();
|
||||||
|
// ParticleObserver *particleObserver;
|
||||||
|
//if(particleObserver != NULL) {
|
||||||
|
// particleObserver->loadGame(particleSystemNode);
|
||||||
|
//}
|
||||||
|
}
|
||||||
|
|
||||||
// =============== MISC =========================
|
// =============== MISC =========================
|
||||||
void ParticleSystem::fade(){
|
void ParticleSystem::fade(){
|
||||||
if(particleObserver != NULL){
|
if(particleObserver != NULL){
|
||||||
|
@ -483,6 +573,28 @@ void FireParticleSystem::setWind(float windAngle, float windSpeed){
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void FireParticleSystem::saveGame(XmlNode *rootNode) {
|
||||||
|
std::map<string,string> mapTagReplacements;
|
||||||
|
XmlNode *fireParticleSystemNode = rootNode->addChild("FireParticleSystem");
|
||||||
|
|
||||||
|
ParticleSystem::saveGame(fireParticleSystemNode);
|
||||||
|
|
||||||
|
// float radius;
|
||||||
|
fireParticleSystemNode->addAttribute("radius",floatToStr(radius), mapTagReplacements);
|
||||||
|
// Vec3f windSpeed;
|
||||||
|
fireParticleSystemNode->addAttribute("windSpeed",windSpeed.getString(), mapTagReplacements);
|
||||||
|
}
|
||||||
|
void FireParticleSystem::loadGame(const XmlNode *rootNode) {
|
||||||
|
const XmlNode *fireParticleSystemNode = rootNode;
|
||||||
|
|
||||||
|
ParticleSystem::loadGame(fireParticleSystemNode);
|
||||||
|
|
||||||
|
// float radius;
|
||||||
|
radius = fireParticleSystemNode->getAttribute("radius")->getFloatValue();
|
||||||
|
// Vec3f windSpeed;
|
||||||
|
windSpeed = Vec3f::strToVec3(fireParticleSystemNode->getAttribute("windSpeed")->getValue());
|
||||||
|
}
|
||||||
|
|
||||||
// ===========================================================================
|
// ===========================================================================
|
||||||
// GameParticleSystem
|
// GameParticleSystem
|
||||||
// ===========================================================================
|
// ===========================================================================
|
||||||
|
@ -607,6 +719,69 @@ void GameParticleSystem::setTween(float relative,float absolute) {
|
||||||
(*it)->setTween(relative,absolute);
|
(*it)->setTween(relative,absolute);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void GameParticleSystem::saveGame(XmlNode *rootNode) {
|
||||||
|
std::map<string,string> mapTagReplacements;
|
||||||
|
XmlNode *gameParticleSystemNode = rootNode->addChild("GameParticleSystem");
|
||||||
|
|
||||||
|
ParticleSystem::saveGame(gameParticleSystemNode);
|
||||||
|
|
||||||
|
// Children children;
|
||||||
|
for(unsigned int i = 0; i < children.size(); ++i) {
|
||||||
|
children[i]->saveGame(gameParticleSystemNode);
|
||||||
|
}
|
||||||
|
// Primitive primitive;
|
||||||
|
gameParticleSystemNode->addAttribute("primitive",intToStr(primitive), mapTagReplacements);
|
||||||
|
// Model *model;
|
||||||
|
if(model != NULL) {
|
||||||
|
gameParticleSystemNode->addAttribute("model",model->getFileName(), mapTagReplacements);
|
||||||
|
}
|
||||||
|
// float modelCycle;
|
||||||
|
gameParticleSystemNode->addAttribute("modelCycle",floatToStr(modelCycle), mapTagReplacements);
|
||||||
|
// Vec3f offset;
|
||||||
|
gameParticleSystemNode->addAttribute("offset",offset.getString(), mapTagReplacements);
|
||||||
|
// Vec3f direction;
|
||||||
|
gameParticleSystemNode->addAttribute("direction",direction.getString(), mapTagReplacements);
|
||||||
|
// float tween;
|
||||||
|
gameParticleSystemNode->addAttribute("tween",floatToStr(tween), mapTagReplacements);
|
||||||
|
}
|
||||||
|
void GameParticleSystem::loadGame(const XmlNode *rootNode) {
|
||||||
|
const XmlNode *gameParticleSystemNode = rootNode;
|
||||||
|
|
||||||
|
ParticleSystem::loadGame(gameParticleSystemNode);
|
||||||
|
|
||||||
|
//radius = fireParticleSystemNode->getAttribute("radius")->getFloatValue();
|
||||||
|
|
||||||
|
// Children children;
|
||||||
|
// for(unsigned int i = 0; i < children.size(); ++i) {
|
||||||
|
// children[i]->saveGame(gameParticleSystemNode);
|
||||||
|
// }
|
||||||
|
vector<XmlNode *> childrenNodeList = gameParticleSystemNode->getChildList("UnitParticleSystem");
|
||||||
|
for(unsigned int i = 0; i < childrenNodeList.size(); ++i) {
|
||||||
|
XmlNode *node = childrenNodeList[i];
|
||||||
|
|
||||||
|
UnitParticleSystem *ups = new UnitParticleSystem();
|
||||||
|
ups->loadGame(node);
|
||||||
|
|
||||||
|
children.push_back(ups);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Primitive primitive;
|
||||||
|
primitive = static_cast<Primitive>(gameParticleSystemNode->getAttribute("primitive")->getIntValue());
|
||||||
|
// Model *model;
|
||||||
|
//if(model != NULL) {
|
||||||
|
// gameParticleSystemNode->addAttribute("model",model->getFileName(), mapTagReplacements);
|
||||||
|
//}
|
||||||
|
// float modelCycle;
|
||||||
|
//gameParticleSystemNode->addAttribute("modelCycle",floatToStr(modelCycle), mapTagReplacements);
|
||||||
|
modelCycle = gameParticleSystemNode->getAttribute("modelCycle")->getFloatValue();
|
||||||
|
// Vec3f offset;
|
||||||
|
offset = Vec3f::strToVec3(gameParticleSystemNode->getAttribute("modelCycle")->getValue());
|
||||||
|
// Vec3f direction;
|
||||||
|
direction = Vec3f::strToVec3(gameParticleSystemNode->getAttribute("direction")->getValue());
|
||||||
|
// float tween;
|
||||||
|
tween = gameParticleSystemNode->getAttribute("tween")->getFloatValue();
|
||||||
|
}
|
||||||
|
|
||||||
// ===========================================================================
|
// ===========================================================================
|
||||||
// UnitParticleSystem
|
// UnitParticleSystem
|
||||||
// ===========================================================================
|
// ===========================================================================
|
||||||
|
@ -869,6 +1044,48 @@ void UnitParticleSystem::setWind(float windAngle, float windSpeed){
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void UnitParticleSystem::saveGame(XmlNode *rootNode) {
|
||||||
|
std::map<string,string> mapTagReplacements;
|
||||||
|
XmlNode *unitParticleSystemNode = rootNode->addChild("UnitParticleSystem");
|
||||||
|
|
||||||
|
GameParticleSystem::saveGame(unitParticleSystemNode);
|
||||||
|
|
||||||
|
//unitParticleSystemNode->addAttribute("radius",floatToStr(radius), mapTagReplacements);
|
||||||
|
|
||||||
|
// float radius;
|
||||||
|
// float minRadius;
|
||||||
|
// Vec3f windSpeed;
|
||||||
|
// Vec3f cRotation;
|
||||||
|
// Vec3f fixedAddition;
|
||||||
|
// Vec3f oldPosition;
|
||||||
|
// bool energyUp;
|
||||||
|
// float startTime;
|
||||||
|
// float endTime;
|
||||||
|
// bool relative;
|
||||||
|
// bool relativeDirection;
|
||||||
|
// bool fixed;
|
||||||
|
// Shape shape;
|
||||||
|
// float angle;
|
||||||
|
// float sizeNoEnergy;
|
||||||
|
// float gravity;
|
||||||
|
// float rotation;
|
||||||
|
// bool isVisibleAtNight;
|
||||||
|
// bool isVisibleAtDay;
|
||||||
|
// bool isDaylightAffected;
|
||||||
|
// bool radiusBasedStartenergy;
|
||||||
|
// int staticParticleCount;
|
||||||
|
// int delay;
|
||||||
|
// int lifetime;
|
||||||
|
// float emissionRateFade;
|
||||||
|
// GameParticleSystem* parent;
|
||||||
|
|
||||||
|
}
|
||||||
|
void UnitParticleSystem::loadGame(const XmlNode *rootNode) {
|
||||||
|
const XmlNode *unitParticleSystemNode = rootNode;
|
||||||
|
|
||||||
|
GameParticleSystem::loadGame(unitParticleSystemNode);
|
||||||
|
}
|
||||||
|
|
||||||
// ===========================================================================
|
// ===========================================================================
|
||||||
// RainParticleSystem
|
// RainParticleSystem
|
||||||
// ===========================================================================
|
// ===========================================================================
|
||||||
|
|
Loading…
Reference in New Issue