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

- bugfix for game save and load (string buffer was too small for one item)

This commit is contained in:
Mark Vejvoda 2012-03-13 21:58:31 +00:00
parent 38bd33acf9
commit 917adc8c98
8 changed files with 361 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/glest_game/type_instances/unit.cpp
View File

@ -3833,6 +3833,7 @@ Unit * Unit::loadGame(const XmlNode *rootNode, GameSettings *settings, Faction *
// UnitParticleSystem *ups= unitParticleSystems[i];
// ups->saveGame(unitNode);
// }
// vector<UnitParticleSystemType*> queuedUnitParticleSystemTypes;
// for(unsigned int i = 0; i < queuedUnitParticleSystemTypes.size(); ++i) {
// UnitParticleSystemType *upst= queuedUnitParticleSystemTypes[i];

90
source/glest_game/world/map.cpp
View File

@ -1864,6 +1864,10 @@ void Map::saveGame(XmlNode *rootNode) const {
for(unsigned int i = 0; i < getSurfaceCellArraySize(); ++i) {
SurfaceCell &surfaceCell = surfaceCells[i];
if(exploredList != "") {
exploredList += ",";
}
for(unsigned int j = 0; j < GameConstants::maxPlayers; ++j) {
if(exploredList != "") {
exploredList += "|";
@ -1871,7 +1875,11 @@ void Map::saveGame(XmlNode *rootNode) const {
exploredList += intToStr(surfaceCell.isExplored(j));
}
exploredList += ",";
if(visibleList != "") {
visibleList += ",";
}
for(unsigned int j = 0; j < GameConstants::maxPlayers; ++j) {
if(visibleList != "") {
visibleList += "|";
@ -1879,14 +1887,24 @@ void Map::saveGame(XmlNode *rootNode) const {
visibleList += intToStr(surfaceCell.isVisible(j));
}
visibleList += ",";
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");
surfaceCellNode->addAttribute("exploredList",exploredList, mapTagReplacements);
surfaceCellNode->addAttribute("visibleList",visibleList, mapTagReplacements);
if(exploredList != "") {
XmlNode *surfaceCellNode = mapNode->addChild("SurfaceCell");
surfaceCellNode->addAttribute("exploredList",exploredList, mapTagReplacements);
surfaceCellNode->addAttribute("visibleList",visibleList, mapTagReplacements);
}
// Vec2i *startLocations;
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);
}
XmlNode *surfaceCellNode = mapNode->getChild("SurfaceCell");
string exploredList = surfaceCellNode->getAttribute("exploredList")->getValue();
string visibleList = surfaceCellNode->getAttribute("visibleList")->getValue();
vector<XmlNode *> surfaceCellNodeList = mapNode->getChildList("SurfaceCell");
for(unsigned int i = 0; i < surfaceCellNodeList.size(); ++i) {
XmlNode *surfaceCellNode = surfaceCellNodeList[i];
vector<string> tokensExplored;
Tokenize(exploredList,tokensExplored,",");
for(unsigned int i = 0; i < tokensExplored.size(); ++i) {
string valueList = tokensExplored[i];
//XmlNode *surfaceCellNode = mapNode->getChild("SurfaceCell");
string exploredList = surfaceCellNode->getAttribute("exploredList")->getValue();
string visibleList = surfaceCellNode->getAttribute("visibleList")->getValue();
vector<string> tokensExploredValue;
Tokenize(valueList,tokensExploredValue,"|");
for(unsigned int j = 0; j < tokensExploredValue.size(); ++j) {
string value = tokensExploredValue[j];
vector<string> tokensExplored;
Tokenize(exploredList,tokensExplored,",");
for(unsigned int i = 0; i < tokensExplored.size(); ++i) {
string valueList = tokensExplored[i];
SurfaceCell &surfaceCell = surfaceCells[i];
surfaceCell.setExplored(j,strToInt(value));
vector<string> tokensExploredValue;
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));
}
}
}
// =====================================================

25
source/glest_game/world/unit_updater.cpp
View File

@ -2645,6 +2645,8 @@ void ParticleDamager::saveGame(XmlNode *rootNode) {
attackerRef.saveGame(particleDamagerNode);
// const AttackSkillType* ast;
particleDamagerNode->addAttribute("astName",ast->getName(), mapTagReplacements);
particleDamagerNode->addAttribute("astClass",intToStr(ast->getClass()), mapTagReplacements);
// UnitUpdater *unitUpdater;
// const GameCamera *gameCamera;
// Vec2i targetPos;
@ -2653,4 +2655,27 @@ void ParticleDamager::saveGame(XmlNode *rootNode) {
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

5
source/glest_game/world/unit_updater.h
View File

@ -157,7 +157,8 @@ private:
// class ParticleDamager
// =====================================================
class ParticleDamager: public ParticleObserver{
class ParticleDamager: public ParticleObserver {
public:
UnitReference attackerRef;
const AttackSkillType* ast;
@ -169,7 +170,9 @@ public:
public:
ParticleDamager(Unit *attacker, UnitUpdater *unitUpdater, const GameCamera *gameCamera);
virtual void update(ParticleSystem *particleSystem);
virtual void saveGame(XmlNode *rootNode);
virtual void loadGame(const XmlNode *rootNode,void *genericData);
};
}}//end namespace

16
source/shared_lib/include/graphics/particle.h
View File

@ -68,6 +68,7 @@ public:
int getEnergy() const {return energy;}
void saveGame(XmlNode *rootNode);
void loadGame(const XmlNode *rootNode);
};
// =====================================================
@ -79,6 +80,7 @@ public:
virtual ~ParticleObserver(){};
virtual void update(ParticleSystem *particleSystem)= 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 ParticleSystem* getChild(int i);
void saveGame(XmlNode *rootNode);
virtual void saveGame(XmlNode *rootNode);
virtual void loadGame(const XmlNode *rootNode);
protected:
//protected
@ -225,6 +228,9 @@ public:
//set params
void setRadius(float radius);
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;}
Vec3f getDirection() const {return direction;}
void setModelCycle(float modelCycle) {this->modelCycle= modelCycle;}
virtual void saveGame(XmlNode *rootNode);
virtual void loadGame(const XmlNode *rootNode);
protected:
typedef std::vector<UnitParticleSystem*> Children;
Children children;
@ -362,6 +372,10 @@ public:
void setParentDirection(Vec3f parentDirection);
static Shape strToShape(const string& str);
virtual void saveGame(XmlNode *rootNode);
virtual void loadGame(const XmlNode *rootNode);
};
// =====================================================

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

@ -658,6 +658,48 @@ public:
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;

2
source/shared_lib/include/xml/xml_parser.h
View File

@ -29,7 +29,7 @@ namespace XERCES_CPP_NAMESPACE{
namespace Shared{ namespace Xml{
const int strSize= 4096;
const int strSize= 8094;
class XmlIo;
class XmlTree;

217
source/shared_lib/sources/graphics/particle.cpp
View File

@ -21,6 +21,7 @@
#include "math_util.h"
#include "platform_common.h"
#include "conversion.h"
#include "model.h"
#include "leak_dumper.h"
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) {
if(checkMemory) {
printf("++ Create ParticleSystem [%p]\n",this);
@ -294,6 +315,75 @@ void ParticleSystem::saveGame(XmlNode *rootNode) {
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 =========================
void ParticleSystem::fade(){
if(particleObserver != NULL){
@ -483,6 +573,28 @@ void FireParticleSystem::setWind(float windAngle, float windSpeed){
#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
// ===========================================================================
@ -607,6 +719,69 @@ void GameParticleSystem::setTween(float relative,float 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
// ===========================================================================
@ -869,6 +1044,48 @@ void UnitParticleSystem::setWind(float windAngle, float windSpeed){
#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
// ===========================================================================