From c5331b7e8aa0f054c5d3dd3ea3ef083f1e85ae00 Mon Sep 17 00:00:00 2001 From: Mark Vejvoda Date: Sat, 10 Mar 2012 03:27:25 +0000 Subject: [PATCH] - initial work to save game state to XML. Current only saves when out of synch or game end occurs and saves to same folder as log files and file is called: megaglest-saved.xml (Currently we store way too much info but this is a starting point) --- source/glest_game/ai/ai.cpp | 82 ++++- source/glest_game/ai/ai.h | 10 + source/glest_game/ai/ai_interface.cpp | 32 ++ source/glest_game/ai/ai_interface.h | 2 + source/glest_game/ai/path_finder.cpp | 132 ++++++++ source/glest_game/ai/path_finder.h | 5 + source/glest_game/game/game.cpp | 161 +++++++++- source/glest_game/game/game.h | 2 + source/glest_game/game/game_camera.cpp | 54 ++++ source/glest_game/game/game_camera.h | 2 + source/glest_game/game/game_constants.h | 2 + source/glest_game/game/stats.cpp | 59 ++++ source/glest_game/game/stats.h | 2 + source/glest_game/global/config.cpp | 2 + source/glest_game/graphics/particle_type.cpp | 92 ++++++ source/glest_game/graphics/particle_type.h | 5 + .../graphics/unit_particle_type.cpp | 46 ++- .../glest_game/graphics/unit_particle_type.h | 1 + source/glest_game/gui/display.cpp | 27 ++ source/glest_game/gui/display.h | 2 + source/glest_game/gui/gui.cpp | 67 +++- source/glest_game/gui/gui.h | 2 + source/glest_game/gui/selection.cpp | 29 ++ source/glest_game/gui/selection.h | 2 + source/glest_game/network/network_types.cpp | 33 ++ source/glest_game/network/network_types.h | 3 + source/glest_game/type_instances/command.cpp | 27 ++ source/glest_game/type_instances/command.h | 2 + source/glest_game/type_instances/faction.cpp | 73 +++++ source/glest_game/type_instances/faction.h | 2 + source/glest_game/type_instances/resource.cpp | 14 + source/glest_game/type_instances/resource.h | 4 + source/glest_game/type_instances/unit.cpp | 298 ++++++++++++++++++ source/glest_game/type_instances/unit.h | 15 + source/glest_game/type_instances/upgrade.cpp | 22 ++ source/glest_game/type_instances/upgrade.h | 5 + source/glest_game/types/damage_multiplier.cpp | 41 ++- source/glest_game/types/damage_multiplier.h | 12 +- source/glest_game/types/element_type.cpp | 45 +++ source/glest_game/types/element_type.h | 10 +- source/glest_game/types/faction_type.cpp | 52 +++ source/glest_game/types/faction_type.h | 2 + source/glest_game/types/resource_type.cpp | 30 ++ source/glest_game/types/resource_type.h | 2 + source/glest_game/types/skill_type.cpp | 155 +++++++++ source/glest_game/types/skill_type.h | 16 + source/glest_game/types/tech_tree.cpp | 44 +++ source/glest_game/types/tech_tree.h | 3 + source/glest_game/types/unit_type.cpp | 7 + source/glest_game/types/unit_type.h | 2 + source/glest_game/types/upgrade_type.cpp | 113 +++++++ source/glest_game/types/upgrade_type.h | 4 + source/glest_game/world/map.cpp | 2 + source/glest_game/world/map.h | 3 + source/glest_game/world/tileset.cpp | 1 + source/glest_game/world/tileset.h | 4 + source/glest_game/world/time_flow.cpp | 15 + source/glest_game/world/time_flow.h | 3 + source/glest_game/world/unit_updater.cpp | 41 +++ source/glest_game/world/unit_updater.h | 3 + source/glest_game/world/world.cpp | 87 +++++ source/glest_game/world/world.h | 2 + source/shared_lib/include/graphics/particle.h | 7 + source/shared_lib/include/util/randomgen.h | 3 + .../sources/graphics/md5/Md5Model.cpp | 16 +- .../shared_lib/sources/graphics/particle.cpp | 81 +++++ source/shared_lib/sources/xml/xml_parser.cpp | 10 + 67 files changed, 2120 insertions(+), 14 deletions(-) diff --git a/source/glest_game/ai/ai.cpp b/source/glest_game/ai/ai.cpp index 9e26b9760..634c1d5ae 100644 --- a/source/glest_game/ai/ai.cpp +++ b/source/glest_game/ai/ai.cpp @@ -22,10 +22,16 @@ using namespace Shared::Util; namespace Glest { namespace Game { +void Task::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *taskNode = rootNode->addChild("Task"); + + taskNode->addAttribute("taskClass",intToStr(taskClass), mapTagReplacements); +} + // ===================================================== // class ProduceTask // ===================================================== - ProduceTask::ProduceTask(UnitClass unitClass){ taskClass= tcProduce; this->unitClass= unitClass; @@ -53,6 +59,24 @@ string ProduceTask::toString() const{ return str; } +void ProduceTask::saveGame(XmlNode *rootNode) const { + Task::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *produceTaskNode = rootNode->addChild("ProduceTask"); + +// UnitClass unitClass; + produceTaskNode->addAttribute("unitClass",intToStr(unitClass), mapTagReplacements); +// const UnitType *unitType; + if(unitType != NULL) { + produceTaskNode->addAttribute("unitType",unitType->getName(), mapTagReplacements); + } +// const ResourceType *resourceType; + if(resourceType != NULL) { + produceTaskNode->addAttribute("resourceType",resourceType->getName(), mapTagReplacements); + } +} + // ===================================================== // class BuildTask // ===================================================== @@ -87,6 +111,26 @@ string BuildTask::toString() const{ return str; } +void BuildTask::saveGame(XmlNode *rootNode) const { + Task::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *buildTaskNode = rootNode->addChild("BuildTask"); + +// const UnitType *unitType; + if(unitType != NULL) { + buildTaskNode->addAttribute("unitType",unitType->getName(), mapTagReplacements); + } +// const ResourceType *resourceType; + if(resourceType != NULL) { + buildTaskNode->addAttribute("resourceType",resourceType->getName(), mapTagReplacements); + } +// bool forcePos; + buildTaskNode->addAttribute("forcePos",intToStr(forcePos), mapTagReplacements); +// Vec2i pos; + buildTaskNode->addAttribute("pos",pos.getString(), mapTagReplacements); +} + // ===================================================== // class UpgradeTask // ===================================================== @@ -104,6 +148,17 @@ string UpgradeTask::toString() const{ return str; } +void UpgradeTask::saveGame(XmlNode *rootNode) const { + Task::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *upgradeTaskNode = rootNode->addChild("UpgradeTask"); + + if(upgradeType != NULL) { + upgradeType->saveGame(upgradeTaskNode); + } +} + // ===================================================== // class Ai // ===================================================== @@ -884,4 +939,29 @@ bool Ai::outputAIBehaviourToConsole() const { return false; } +void Ai::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *aiNode = rootNode->addChild("Ai"); + +// AiInterface *aiInterface; +// AiRules aiRules; +// int startLoc; + aiNode->addAttribute("startLoc",intToStr(startLoc), mapTagReplacements); +// bool randomMinWarriorsReached; + aiNode->addAttribute("randomMinWarriorsReached",intToStr(randomMinWarriorsReached), mapTagReplacements); +// Tasks tasks; + for(Tasks::const_iterator it = tasks.begin(); it != tasks.end(); ++it) { + (*it)->saveGame(aiNode); + } +// Positions expansionPositions; + for(Positions::const_iterator it = expansionPositions.begin(); it != expansionPositions.end(); ++it) { + XmlNode *expansionPositionsNode = aiNode->addChild("expansionPositions"); + expansionPositionsNode->addAttribute("pos",(*it).getString(), mapTagReplacements); + } + +// RandomGen random; + aiNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); +// std::map factionSwitchTeamRequestCount; + +} }}//end namespace diff --git a/source/glest_game/ai/ai.h b/source/glest_game/ai/ai.h index 3528d2c67..0c36a968d 100644 --- a/source/glest_game/ai/ai.h +++ b/source/glest_game/ai/ai.h @@ -51,6 +51,8 @@ public: virtual ~Task(){} TaskClass getClass() const {return taskClass;} virtual string toString() const= 0; + + virtual void saveGame(XmlNode *rootNode) const; }; // ==================== ProduceTask ==================== @@ -70,6 +72,8 @@ public: const UnitType *getUnitType() const {return unitType;} const ResourceType *getResourceType() const {return resourceType;} virtual string toString() const; + + virtual void saveGame(XmlNode *rootNode) const; }; // ==================== BuildTask ==================== @@ -91,6 +95,8 @@ public: bool getForcePos() const {return forcePos;} Vec2i getPos() const {return pos;} virtual string toString() const; + + virtual void saveGame(XmlNode *rootNode) const; }; // ==================== UpgradeTask ==================== @@ -103,6 +109,8 @@ public: UpgradeTask(const UpgradeType *upgradeType= NULL); const UpgradeType *getUpgradeType() const {return upgradeType;} virtual string toString() const; + + virtual void saveGame(XmlNode *rootNode) const; }; // =============================== @@ -197,6 +205,8 @@ public: void unblockUnits(); bool outputAIBehaviourToConsole() const; + + void saveGame(XmlNode *rootNode) const; }; }}//end namespace diff --git a/source/glest_game/ai/ai_interface.cpp b/source/glest_game/ai/ai_interface.cpp index fe52011e8..f50e46daf 100644 --- a/source/glest_game/ai/ai_interface.cpp +++ b/source/glest_game/ai/ai_interface.cpp @@ -667,4 +667,36 @@ bool AiInterface::factionUsesResourceType(const FactionType *factionType, const return factionUsesResourceType; } +void AiInterface::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *aiInterfaceNode = rootNode->addChild("AiInterface"); + +// World *world; +// Commander *commander; +// Console *console; +// GameSettings *gameSettings; +// +// Ai ai; + ai.saveGame(aiInterfaceNode); +// int timer; + aiInterfaceNode->addAttribute("timer",intToStr(timer), mapTagReplacements); +// int factionIndex; + aiInterfaceNode->addAttribute("factionIndex",intToStr(factionIndex), mapTagReplacements); +// int teamIndex; + aiInterfaceNode->addAttribute("teamIndex",intToStr(teamIndex), mapTagReplacements); +// //config +// bool redir; + aiInterfaceNode->addAttribute("redir",intToStr(redir), mapTagReplacements); +// int logLevel; + aiInterfaceNode->addAttribute("logLevel",intToStr(logLevel), mapTagReplacements); +// std::map cacheUnitHarvestResourceLookup; + for(std::map::const_iterator iterMap = cacheUnitHarvestResourceLookup.begin(); + iterMap != cacheUnitHarvestResourceLookup.end(); ++iterMap) { + XmlNode *cacheUnitHarvestResourceLookupNode = aiInterfaceNode->addChild("cacheUnitHarvestResourceLookup"); + + cacheUnitHarvestResourceLookupNode->addAttribute("key",iterMap->first->getName(), mapTagReplacements); + cacheUnitHarvestResourceLookupNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } +} + }}//end namespace diff --git a/source/glest_game/ai/ai_interface.h b/source/glest_game/ai/ai_interface.h index 0741a39a0..e3bd34275 100644 --- a/source/glest_game/ai/ai_interface.h +++ b/source/glest_game/ai/ai_interface.h @@ -103,6 +103,8 @@ public: bool factionUsesResourceType(const FactionType *factionType, const ResourceType *rt); + void saveGame(XmlNode *rootNode) const; + private: string getLogFilename() const {return "ai"+intToStr(factionIndex)+".log";} bool executeCommandOverNetwork(); diff --git a/source/glest_game/ai/path_finder.cpp b/source/glest_game/ai/path_finder.cpp index afccc0392..8cd2908aa 100644 --- a/source/glest_game/ai/path_finder.cpp +++ b/source/glest_game/ai/path_finder.cpp @@ -1483,4 +1483,136 @@ bool PathFinder::openPos(const Vec2i &sucPos, FactionState &faction) { return true; } +int PathFinder::findNodeIndex(Node *node, Nodes &nodeList) { + int index = -1; + if(node != NULL) { + for(unsigned int i = 0; i < nodeList.size(); ++i) { + Node *curnode = nodeList[i]; + if(node == curnode) { + index = i; + break; + } + } + } + return index; +} + +int PathFinder::findNodeIndex(Node *node, std::vector &nodeList) { + int index = -1; + if(node != NULL) { + for(unsigned int i = 0; i < nodeList.size(); ++i) { + Node &curnode = nodeList[i]; + if(node == &curnode) { + index = i; + break; + } + } + } + return index; +} + +void PathFinder::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *pathfinderNode = rootNode->addChild("PathFinder"); + +// static int pathFindNodesMax; + pathfinderNode->addAttribute("pathFindNodesMax",intToStr(pathFindNodesMax), mapTagReplacements); +// static int pathFindNodesAbsoluteMax; + pathfinderNode->addAttribute("pathFindNodesAbsoluteMax",intToStr(pathFindNodesAbsoluteMax), mapTagReplacements); +// FactionStateList factions; + for(unsigned int i = 0; i < factions.size(); ++i) { + FactionState &factionState = factions[i]; + XmlNode *factionsNode = pathfinderNode->addChild("factions"); + +// std::map openPosList; + XmlNode *openPosListNode = factionsNode->addChild("openPosList"); + for(std::map::iterator iterMap = factionState.openPosList.begin(); + iterMap != factionState.openPosList.end(); ++iterMap) { + openPosListNode->addAttribute("key",iterMap->first.getString(), mapTagReplacements); + openPosListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } +// std::map openNodesList; + XmlNode *openNodesListNode = factionsNode->addChild("openNodesList"); + for(std::map::iterator iterMap = factionState.openNodesList.begin(); + iterMap != factionState.openNodesList.end(); ++iterMap) { + + Nodes &nodeList = iterMap->second; + for(unsigned int j = 0; j < nodeList.size(); ++j) { + Node *curNode = nodeList[j]; + XmlNode *openNodesListNodeNode = factionsNode->addChild("openNodesListNode"); + openNodesListNodeNode->addAttribute("key",floatToStr(iterMap->first), mapTagReplacements); + +// Vec2i pos; + openNodesListNodeNode->addAttribute("pos",curNode->pos.getString(), mapTagReplacements); +// Node *next; + int nextIdx = findNodeIndex(curNode->next, nodeList); + openNodesListNodeNode->addAttribute("next",intToStr(nextIdx), mapTagReplacements); +// Node *prev; + int prevIdx = findNodeIndex(curNode->prev, nodeList); + openNodesListNodeNode->addAttribute("prev",intToStr(nextIdx), mapTagReplacements); +// float heuristic; + openNodesListNodeNode->addAttribute("heuristic",floatToStr(curNode->heuristic), mapTagReplacements); +// bool exploredCell; + openNodesListNodeNode->addAttribute("exploredCell",intToStr(curNode->exploredCell), mapTagReplacements); + } + } + +// std::map closedNodesList; + XmlNode *closedNodesListNode = factionsNode->addChild("closedNodesList"); + for(std::map::iterator iterMap = factionState.closedNodesList.begin(); + iterMap != factionState.closedNodesList.end(); ++iterMap) { + + Nodes &nodeList = iterMap->second; + for(unsigned int j = 0; j < nodeList.size(); ++j) { + Node *curNode = nodeList[j]; + XmlNode *closedNodesListNodeNode = factionsNode->addChild("closedNodesListNode"); + closedNodesListNodeNode->addAttribute("key",floatToStr(iterMap->first), mapTagReplacements); + +// Vec2i pos; + closedNodesListNodeNode->addAttribute("pos",curNode->pos.getString(), mapTagReplacements); +// Node *next; + int nextIdx = findNodeIndex(curNode->next, nodeList); + closedNodesListNodeNode->addAttribute("next",intToStr(nextIdx), mapTagReplacements); +// Node *prev; + int prevIdx = findNodeIndex(curNode->prev, nodeList); + closedNodesListNodeNode->addAttribute("prev",intToStr(nextIdx), mapTagReplacements); +// float heuristic; + closedNodesListNodeNode->addAttribute("heuristic",floatToStr(curNode->heuristic), mapTagReplacements); +// bool exploredCell; + closedNodesListNodeNode->addAttribute("exploredCell",intToStr(curNode->exploredCell), mapTagReplacements); + } + } + +// std::vector nodePool; + for(unsigned int j = 0; j < factionState.nodePool.size(); ++j) { + Node *curNode = &factionState.nodePool[j]; + XmlNode *nodePoolNode = factionsNode->addChild("nodePool"); + //closedNodesListNodeNode->addAttribute("key",iterMap->first.getString(), mapTagReplacements); + +// Vec2i pos; + nodePoolNode->addAttribute("pos",curNode->pos.getString(), mapTagReplacements); +// Node *next; + int nextIdx = findNodeIndex(curNode->next, factionState.nodePool); + nodePoolNode->addAttribute("next",intToStr(nextIdx), mapTagReplacements); +// Node *prev; + int prevIdx = findNodeIndex(curNode->prev, factionState.nodePool); + nodePoolNode->addAttribute("prev",intToStr(nextIdx), mapTagReplacements); +// float heuristic; + nodePoolNode->addAttribute("heuristic",floatToStr(curNode->heuristic), mapTagReplacements); +// bool exploredCell; + nodePoolNode->addAttribute("exploredCell",intToStr(curNode->exploredCell), mapTagReplacements); + } + +// int nodePoolCount; +// RandomGen random; +// int useMaxNodeCount; +// +// std::map precachedTravelState; +// std::map > precachedPath; + + } +// const Map *map; + +} + }} //end namespace diff --git a/source/glest_game/ai/path_finder.h b/source/glest_game/ai/path_finder.h index 5216992c1..60e62343a 100644 --- a/source/glest_game/ai/path_finder.h +++ b/source/glest_game/ai/path_finder.h @@ -118,6 +118,11 @@ public: void clearUnitPrecache(Unit *unit); void removeUnitPrecache(Unit *unit); + int findNodeIndex(Node *node, Nodes &nodeList); + int findNodeIndex(Node *node, std::vector &nodeList); + + void saveGame(XmlNode *rootNode); + private: TravelState aStar(Unit *unit, const Vec2i &finalPos, bool inBailout, int frameIndex, int maxNodeCount=-1); Node *newNode(FactionState &faction,int maxNodeCount); diff --git a/source/glest_game/game/game.cpp b/source/glest_game/game/game.cpp index 4de8aa8de..3a3e83637 100644 --- a/source/glest_game/game/game.cpp +++ b/source/glest_game/game/game.cpp @@ -2614,9 +2614,9 @@ void Game::keyPress(SDL_KeyboardEvent c) { Stats Game::quitGame() { if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__); - if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled == true) { + //if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled == true) { world.DumpWorldToLog(); - } + //} //Stats stats = *(world.getStats()); Stats endStats; @@ -3417,4 +3417,161 @@ void Game::toggleTeamColorMarker() { renderExtraTeamColor=renderExtraTeamColor%4; } +void Game::saveGame(string name) { + XmlTree xmlTree; + xmlTree.init("megaglest-saved-game"); + XmlNode *rootNode = xmlTree.getRootNode(); + + std::map mapTagReplacements; + time_t now = time(NULL); + struct tm *loctime = localtime (&now); + char szBuf[4096]=""; + strftime(szBuf,4095,"%Y-%m-%d %H:%M:%S",loctime); + + rootNode->addAttribute("version",glestVersionString, mapTagReplacements); + rootNode->addAttribute("timestamp",szBuf, mapTagReplacements); + + XmlNode *gameNode = rootNode->addChild("Game"); + //World world; + world.saveGame(gameNode); + //AiInterfaces aiInterfaces; + for(unsigned int i = 0; i < aiInterfaces.size(); ++i) { + AiInterface *aiIntf = aiInterfaces[i]; + if(aiIntf != NULL) { + aiIntf->saveGame(gameNode); + } + } + //Gui gui; + gui.saveGame(gameNode); + //GameCamera gameCamera; + gameCamera.saveGame(gameNode); + //Commander commander; + //Console console; + //ChatManager chatManager; + //ScriptManager scriptManager; + + //misc + //Checksum checksum; + gameNode->addAttribute("checksum",intToStr(checksum.getSum()), mapTagReplacements); + //string loadingText; +// int mouse2d; + gameNode->addAttribute("mouse2d",intToStr(mouse2d), mapTagReplacements); +// int mouseX; + gameNode->addAttribute("mouseX",intToStr(mouseX), mapTagReplacements); +// int mouseY; //coords win32Api + gameNode->addAttribute("mouseY",intToStr(mouseY), mapTagReplacements); +// Vec2i mouseCellPos; + gameNode->addAttribute("mouseCellPos",mouseCellPos.getString(), mapTagReplacements); +// int updateFps, lastUpdateFps, avgUpdateFps; +// int totalRenderFps, renderFps, lastRenderFps, avgRenderFps,currentAvgRenderFpsTotal; + //Uint64 tickCount; + gameNode->addAttribute("tickCount",intToStr(tickCount), mapTagReplacements); + + //bool paused; + gameNode->addAttribute("paused",intToStr(paused), mapTagReplacements); + //bool gameOver; + gameNode->addAttribute("gameOver",intToStr(gameOver), mapTagReplacements); + //bool renderNetworkStatus; + //bool showFullConsole; + //bool mouseMoved; + //float scrollSpeed; + gameNode->addAttribute("scrollSpeed",floatToStr(scrollSpeed), mapTagReplacements); + //bool camLeftButtonDown; + //bool camRightButtonDown; + //bool camUpButtonDown; + //bool camDownButtonDown; + + //Speed speed; + gameNode->addAttribute("speed",intToStr(speed), mapTagReplacements); + + //GraphicMessageBox mainMessageBox; + //GraphicMessageBox errorMessageBox; + + //misc ptr + //ParticleSystem *weatherParticleSystem; + if(weatherParticleSystem != NULL) { + weatherParticleSystem->saveGame(gameNode); + } + //GameSettings gameSettings; + //Vec2i lastMousePos; + gameNode->addAttribute("lastMousePos",lastMousePos.getString(), mapTagReplacements); + //time_t lastRenderLog2d; + gameNode->addAttribute("lastRenderLog2d",intToStr(lastRenderLog2d), mapTagReplacements); + //DisplayMessageFunction originalDisplayMsgCallback; + //bool isFirstRender; + gameNode->addAttribute("isFirstRender",intToStr(isFirstRender), mapTagReplacements); + + //bool quitTriggeredIndicator; + //int original_updateFps; + gameNode->addAttribute("original_updateFps",intToStr(original_updateFps), mapTagReplacements); + //int original_cameraFps; + gameNode->addAttribute("original_cameraFps",intToStr(original_cameraFps), mapTagReplacements); + + //bool captureAvgTestStatus; + gameNode->addAttribute("captureAvgTestStatus",intToStr(captureAvgTestStatus), mapTagReplacements); + //int updateFpsAvgTest; + gameNode->addAttribute("updateFpsAvgTest",intToStr(updateFpsAvgTest), mapTagReplacements); + //int renderFpsAvgTest; + gameNode->addAttribute("renderFpsAvgTest",intToStr(renderFpsAvgTest), mapTagReplacements); + + //int renderExtraTeamColor; + gameNode->addAttribute("renderExtraTeamColor",intToStr(renderExtraTeamColor), mapTagReplacements); + + //static const int renderTeamColorCircleBit=1; + //static const int renderTeamColorPlaneBit=2; + + //bool photoModeEnabled; + gameNode->addAttribute("photoModeEnabled",intToStr(photoModeEnabled), mapTagReplacements); + //bool visibleHUD; + gameNode->addAttribute("visibleHUD",intToStr(visibleHUD), mapTagReplacements); + //bool withRainEffect; + gameNode->addAttribute("withRainEffect",intToStr(withRainEffect), mapTagReplacements); + //Program *program; + + //bool gameStarted; + gameNode->addAttribute("gameStarted",intToStr(gameStarted), mapTagReplacements); + + //time_t lastMaxUnitCalcTime; + gameNode->addAttribute("lastMaxUnitCalcTime",intToStr(lastMaxUnitCalcTime), mapTagReplacements); + + //PopupMenu popupMenu; + //PopupMenu popupMenuSwitchTeams; + + //std::map switchTeamIndexMap; + //GraphicMessageBox switchTeamConfirmMessageBox; + + //int exitGamePopupMenuIndex; + //int joinTeamPopupMenuIndex; + //int pauseGamePopupMenuIndex; + //int keyboardSetupPopupMenuIndex; + //GLuint statelist3dMenu; + //ProgramState *currentUIState; + + //bool masterserverMode; + + //StrSound *currentAmbientSound; + + //time_t lastNetworkPlayerConnectionCheck; + gameNode->addAttribute("lastNetworkPlayerConnectionCheck",intToStr(lastNetworkPlayerConnectionCheck), mapTagReplacements); + + //time_t lastMasterServerGameStatsDump; + gameNode->addAttribute("lastMasterServerGameStatsDump",intToStr(lastMasterServerGameStatsDump), mapTagReplacements); + + // Save the file now + string saveGameFile = name; + if(getGameReadWritePath(GameConstants::path_logs_CacheLookupKey) != "") { + saveGameFile = getGameReadWritePath(GameConstants::path_logs_CacheLookupKey) + saveGameFile; + } + else { + string userData = Config::getInstance().getString("UserData_Root",""); + if(userData != "") { + endPathWithSlash(userData); + } + saveGameFile = userData + saveGameFile; + } + + if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Saving game to [%s]\n",saveGameFile.c_str()); + xmlTree.save(saveGameFile); +} + }}//end namespace diff --git a/source/glest_game/game/game.h b/source/glest_game/game/game.h index fd6e6a22d..55e0cd612 100644 --- a/source/glest_game/game/game.h +++ b/source/glest_game/game/game.h @@ -225,6 +225,8 @@ public: void endGame(); + void saveGame(string name); + private: //render void render3d(); diff --git a/source/glest_game/game/game_camera.cpp b/source/glest_game/game/game_camera.cpp index 0270ad3d8..5fb14e957 100644 --- a/source/glest_game/game/game_camera.cpp +++ b/source/glest_game/game/game_camera.cpp @@ -412,4 +412,58 @@ void GameCamera::moveUp(float d){ destPos.y += d; } +void GameCamera::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *gamecameraNode = rootNode->addChild("GameCamera"); + +// Vec3f pos; + gamecameraNode->addAttribute("pos",pos.getString(), mapTagReplacements); +// Vec3f destPos; + gamecameraNode->addAttribute("destPos",destPos.getString(), mapTagReplacements); +// +// float hAng; //YZ plane positive -Z axis + gamecameraNode->addAttribute("hAng",floatToStr(hAng), mapTagReplacements); +// float vAng; //XZ plane positive +Z axis + gamecameraNode->addAttribute("vAng",floatToStr(vAng), mapTagReplacements); +// float lastHAng; + gamecameraNode->addAttribute("lastHAng",floatToStr(lastHAng), mapTagReplacements); + +// float lastVAng; + gamecameraNode->addAttribute("lastVAng",floatToStr(lastVAng), mapTagReplacements); +// Vec2f destAng; + gamecameraNode->addAttribute("destAng",destAng.getString(), mapTagReplacements); +// float rotate; + gamecameraNode->addAttribute("rotate",floatToStr(rotate), mapTagReplacements); +// Vec3f move; + gamecameraNode->addAttribute("move",move.getString(), mapTagReplacements); +// State state; + gamecameraNode->addAttribute("state",intToStr(state), mapTagReplacements); +// int limitX; + gamecameraNode->addAttribute("limitX",intToStr(limitX), mapTagReplacements); +// int limitY; + gamecameraNode->addAttribute("limitY",intToStr(limitY), mapTagReplacements); +// //config +// float speed; + gamecameraNode->addAttribute("speed",floatToStr(speed), mapTagReplacements); +// bool clampBounds; + gamecameraNode->addAttribute("clampBounds",intToStr(clampBounds), mapTagReplacements); +// //float maxRenderDistance; +// float maxHeight; + gamecameraNode->addAttribute("maxHeight",floatToStr(maxHeight), mapTagReplacements); +// float minHeight; + gamecameraNode->addAttribute("minHeight",floatToStr(minHeight), mapTagReplacements); +// //float maxCameraDist; +// //float minCameraDist; +// float minVAng; + gamecameraNode->addAttribute("minVAng",floatToStr(minVAng), mapTagReplacements); +// float maxVAng; + gamecameraNode->addAttribute("maxVAng",floatToStr(maxVAng), mapTagReplacements); +// float fov; + gamecameraNode->addAttribute("fov",floatToStr(fov), mapTagReplacements); +// float calculatedDefault; + gamecameraNode->addAttribute("calculatedDefault",floatToStr(calculatedDefault), mapTagReplacements); +// std::map > > cacheVisibleQuad; +// int MaxVisibleQuadItemCache; + gamecameraNode->addAttribute("MaxVisibleQuadItemCache",intToStr(MaxVisibleQuadItemCache), mapTagReplacements); +} }}//end namespace diff --git a/source/glest_game/game/game_camera.h b/source/glest_game/game/game_camera.h index 413f8b7ca..787d5df80 100644 --- a/source/glest_game/game/game_camera.h +++ b/source/glest_game/game/game_camera.h @@ -143,6 +143,8 @@ public: void setMinVAng(float value) { minVAng = value; } void setMaxVAng(float value) { maxVAng = value; } + void saveGame(XmlNode *rootNode); + private: void clampPosXYZ(float x1, float x2, float y1, float y2, float z1, float z2); void clampPosXZ(float x1, float x2, float z1, float z2); diff --git a/source/glest_game/game/game_constants.h b/source/glest_game/game/game_constants.h index e9d0b396a..494e599c6 100644 --- a/source/glest_game/game/game_constants.h +++ b/source/glest_game/game/game_constants.h @@ -125,6 +125,8 @@ public: static const char *application_name; + static const char *saveGameFileDefault; + // VC++ Chokes on init of non integral static types static const float normalMultiplier; static const float easyMultiplier; diff --git a/source/glest_game/game/stats.cpp b/source/glest_game/game/stats.cpp index dffbf10c2..814c91ebc 100644 --- a/source/glest_game/game/stats.cpp +++ b/source/glest_game/game/stats.cpp @@ -150,4 +150,63 @@ string Stats::getStats() const { return result; } +void Stats::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *statsNode = rootNode->addChild("Stats"); + +// PlayerStats playerStats[GameConstants::maxPlayers]; + for(unsigned int i = 0; i < GameConstants::maxPlayers; ++i) { + PlayerStats &stat = playerStats[i]; + + XmlNode *statsNodePlayer = statsNode->addChild("Player"); + +// ControlType control; + statsNodePlayer->addAttribute("control",intToStr(stat.control), mapTagReplacements); +// float resourceMultiplier; + statsNodePlayer->addAttribute("resourceMultiplier",floatToStr(stat.resourceMultiplier), mapTagReplacements); +// string factionTypeName; + statsNodePlayer->addAttribute("factionTypeName",stat.factionTypeName, mapTagReplacements); +// FactionPersonalityType personalityType; + statsNodePlayer->addAttribute("personalityType",intToStr(stat.personalityType), mapTagReplacements); +// int teamIndex; + statsNodePlayer->addAttribute("teamIndex",intToStr(stat.teamIndex), mapTagReplacements); +// bool victory; + statsNodePlayer->addAttribute("victory",intToStr(stat.victory), mapTagReplacements); +// int kills; + statsNodePlayer->addAttribute("kills",intToStr(stat.kills), mapTagReplacements); +// int enemykills; + statsNodePlayer->addAttribute("enemykills",intToStr(stat.enemykills), mapTagReplacements); +// int deaths; + statsNodePlayer->addAttribute("deaths",intToStr(stat.deaths), mapTagReplacements); +// int unitsProduced; + statsNodePlayer->addAttribute("unitsProduced",intToStr(stat.unitsProduced), mapTagReplacements); +// int resourcesHarvested; + statsNodePlayer->addAttribute("resourcesHarvested",intToStr(stat.resourcesHarvested), mapTagReplacements); +// string playerName; + statsNodePlayer->addAttribute("playerName",stat.playerName, mapTagReplacements); +// Vec3f playerColor; + statsNodePlayer->addAttribute("playerColor",stat.playerColor.getString(), mapTagReplacements); + } +// string description; + statsNode->addAttribute("description",description, mapTagReplacements); +// int factionCount; + statsNode->addAttribute("factionCount",intToStr(factionCount), mapTagReplacements); +// int thisFactionIndex; + statsNode->addAttribute("thisFactionIndex",intToStr(thisFactionIndex), mapTagReplacements); +// +// float worldTimeElapsed; + statsNode->addAttribute("worldTimeElapsed",floatToStr(worldTimeElapsed), mapTagReplacements); +// int framesPlayed; + statsNode->addAttribute("framesPlayed",intToStr(framesPlayed), mapTagReplacements); +// int framesToCalculatePlaytime; + statsNode->addAttribute("framesToCalculatePlaytime",intToStr(framesToCalculatePlaytime), mapTagReplacements); +// time_t timePlayed; + statsNode->addAttribute("timePlayed",intToStr(timePlayed), mapTagReplacements); +// int maxConcurrentUnitCount; + statsNode->addAttribute("maxConcurrentUnitCount",intToStr(maxConcurrentUnitCount), mapTagReplacements); +// int totalEndGameConcurrentUnitCount; + statsNode->addAttribute("totalEndGameConcurrentUnitCount",intToStr(totalEndGameConcurrentUnitCount), mapTagReplacements); +// bool isMasterserverMode; +} + }}//end namespace diff --git a/source/glest_game/game/stats.h b/source/glest_game/game/stats.h index 436678bdf..4aeb9ccc5 100644 --- a/source/glest_game/game/stats.h +++ b/source/glest_game/game/stats.h @@ -134,6 +134,8 @@ public: void addFramesToCalculatePlaytime() {this->framesToCalculatePlaytime++; } string getStats() const; + + void saveGame(XmlNode *rootNode); }; }}//end namespace diff --git a/source/glest_game/global/config.cpp b/source/glest_game/global/config.cpp index c4082f245..1d0bda791 100644 --- a/source/glest_game/global/config.cpp +++ b/source/glest_game/global/config.cpp @@ -61,6 +61,8 @@ const char *GameConstants::path_data_CacheLookupKey = "data"; const char *GameConstants::path_ini_CacheLookupKey = "ini"; const char *GameConstants::path_logs_CacheLookupKey = "logs"; +const char *GameConstants::saveGameFileDefault = "megaglest-saved.xml"; + const char *Config::glest_ini_filename = "glest.ini"; const char *Config::glestuser_ini_filename = "glestuser.ini"; diff --git a/source/glest_game/graphics/particle_type.cpp b/source/glest_game/graphics/particle_type.cpp index c1aebdd3a..841643aa0 100644 --- a/source/glest_game/graphics/particle_type.cpp +++ b/source/glest_game/graphics/particle_type.cpp @@ -20,6 +20,7 @@ #include "game_constants.h" #include "util.h" #include "platform_common.h" +#include "conversion.h" #include "leak_dumper.h" using namespace Shared::Xml; @@ -304,6 +305,63 @@ void ParticleSystemType::setValues(AttackParticleSystem *ats){ ats->setBlendMode(ParticleSystem::strToBlendMode(mode)); } +void ParticleSystemType::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *particleSystemTypeNode = rootNode->addChild("ParticleSystemType"); + +// string type; + particleSystemTypeNode->addAttribute("type",type, mapTagReplacements); +// Texture2D *texture; +// Model *model; +// float modelCycle; + particleSystemTypeNode->addAttribute("modelCycle",floatToStr(modelCycle), mapTagReplacements); +// string primitive; + particleSystemTypeNode->addAttribute("primitive",primitive, mapTagReplacements); +// Vec3f offset; + particleSystemTypeNode->addAttribute("offset",offset.getString(), mapTagReplacements); +// Vec4f color; + particleSystemTypeNode->addAttribute("color",color.getString(), mapTagReplacements); +// Vec4f colorNoEnergy; + particleSystemTypeNode->addAttribute("colorNoEnergy",colorNoEnergy.getString(), mapTagReplacements); +// float size; + particleSystemTypeNode->addAttribute("size",floatToStr(size), mapTagReplacements); +// float sizeNoEnergy; + particleSystemTypeNode->addAttribute("sizeNoEnergy",floatToStr(sizeNoEnergy), mapTagReplacements); +// float speed; + particleSystemTypeNode->addAttribute("speed",floatToStr(speed), mapTagReplacements); +// float gravity; + particleSystemTypeNode->addAttribute("gravity",floatToStr(gravity), mapTagReplacements); +// float emissionRate; + particleSystemTypeNode->addAttribute("emissionRate",floatToStr(emissionRate), mapTagReplacements); +// int energyMax; + particleSystemTypeNode->addAttribute("energyMax",intToStr(energyMax), mapTagReplacements); +// int energyVar; + particleSystemTypeNode->addAttribute("energyVar",intToStr(energyVar), mapTagReplacements); +// string mode; + particleSystemTypeNode->addAttribute("mode",mode, mapTagReplacements); +// bool teamcolorNoEnergy; + particleSystemTypeNode->addAttribute("teamcolorNoEnergy",intToStr(teamcolorNoEnergy), mapTagReplacements); +// bool teamcolorEnergy; + particleSystemTypeNode->addAttribute("teamcolorEnergy",intToStr(teamcolorEnergy), mapTagReplacements); +// int alternations; + particleSystemTypeNode->addAttribute("alternations",intToStr(alternations), mapTagReplacements); +// int particleSystemStartDelay; + particleSystemTypeNode->addAttribute("particleSystemStartDelay",intToStr(particleSystemStartDelay), mapTagReplacements); +// typedef std::list Children; +// Children children; + for(Children::iterator it = children.begin(); it != children.end(); ++it) { + (*it)->saveGame(particleSystemTypeNode); + } +// bool minmaxEnabled; + particleSystemTypeNode->addAttribute("minmaxEnabled",intToStr(minmaxEnabled), mapTagReplacements); +// int minHp; + particleSystemTypeNode->addAttribute("minHp",intToStr(minHp), mapTagReplacements); +// int maxHp; + particleSystemTypeNode->addAttribute("maxHp",intToStr(maxHp), mapTagReplacements); +// bool minmaxIsPercent; + particleSystemTypeNode->addAttribute("minmaxIsPercent",intToStr(minmaxIsPercent), mapTagReplacements); +} + // =========================================================== // class ParticleSystemTypeProjectile // =========================================================== @@ -383,6 +441,22 @@ ProjectileParticleSystem *ParticleSystemTypeProjectile::create() { return ps; } +void ParticleSystemTypeProjectile::saveGame(XmlNode *rootNode) { + ParticleSystemType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *particleSystemTypeProjectileNode = rootNode->addChild("ParticleSystemTypeProjectile"); + +// string trajectory; + particleSystemTypeProjectileNode->addAttribute("trajectory",trajectory, mapTagReplacements); +// float trajectorySpeed; + particleSystemTypeProjectileNode->addAttribute("trajectorySpeed",floatToStr(trajectorySpeed), mapTagReplacements); +// float trajectoryScale; + particleSystemTypeProjectileNode->addAttribute("trajectoryScale",floatToStr(trajectoryScale), mapTagReplacements); +// float trajectoryFrequency; + particleSystemTypeProjectileNode->addAttribute("trajectoryFrequency",floatToStr(trajectoryFrequency), mapTagReplacements); +} + // =========================================================== // class ParticleSystemTypeSplash // =========================================================== @@ -452,4 +526,22 @@ SplashParticleSystem *ParticleSystemTypeSplash::create(){ return ps; } +void ParticleSystemTypeSplash::saveGame(XmlNode *rootNode) { + ParticleSystemType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *particleSystemTypeSplashNode = rootNode->addChild("ParticleSystemTypeSplash"); + +// float emissionRateFade; + particleSystemTypeSplashNode->addAttribute("emissionRateFade",floatToStr(emissionRateFade), mapTagReplacements); +// float verticalSpreadA; + particleSystemTypeSplashNode->addAttribute("verticalSpreadA",floatToStr(verticalSpreadA), mapTagReplacements); +// float verticalSpreadB; + particleSystemTypeSplashNode->addAttribute("verticalSpreadB",floatToStr(verticalSpreadB), mapTagReplacements); +// float horizontalSpreadA; + particleSystemTypeSplashNode->addAttribute("horizontalSpreadA",floatToStr(horizontalSpreadA), mapTagReplacements); +// float horizontalSpreadB; + particleSystemTypeSplashNode->addAttribute("horizontalSpreadB",floatToStr(horizontalSpreadB), mapTagReplacements); +} + }}//end mamespace diff --git a/source/glest_game/graphics/particle_type.h b/source/glest_game/graphics/particle_type.h index 6d3ecc7e6..0283d9db9 100644 --- a/source/glest_game/graphics/particle_type.h +++ b/source/glest_game/graphics/particle_type.h @@ -106,6 +106,8 @@ public: string getType() const { return type; }; + virtual void saveGame(XmlNode *rootNode); + protected: }; @@ -128,6 +130,7 @@ public: string parentLoader, string techtreePath); ProjectileParticleSystem *create(); + virtual void saveGame(XmlNode *rootNode); }; // =========================================================== @@ -143,6 +146,8 @@ public: string parentLoader, string techtreePath); SplashParticleSystem *create(); + virtual void saveGame(XmlNode *rootNode); + private: float emissionRateFade; float verticalSpreadA; diff --git a/source/glest_game/graphics/unit_particle_type.cpp b/source/glest_game/graphics/unit_particle_type.cpp index d42fe8d83..7cb480d87 100644 --- a/source/glest_game/graphics/unit_particle_type.cpp +++ b/source/glest_game/graphics/unit_particle_type.cpp @@ -17,7 +17,7 @@ #include "config.h" #include "game_constants.h" #include "platform_common.h" - +#include "conversion.h" #include "leak_dumper.h" using namespace Shared::Xml; @@ -280,4 +280,48 @@ void UnitParticleSystemType::load(const XmlNode *particleFileNode, const string } } +void UnitParticleSystemType::saveGame(XmlNode *rootNode) { + ParticleSystemType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *unitParticleSystemTypeNode = rootNode->addChild("UnitParticleSystemType"); + +// UnitParticleSystem::Shape shape; + unitParticleSystemTypeNode->addAttribute("shape",intToStr(shape), mapTagReplacements); +// float angle; + unitParticleSystemTypeNode->addAttribute("angle",floatToStr(angle), mapTagReplacements); +// float radius; + unitParticleSystemTypeNode->addAttribute("radius",floatToStr(radius), mapTagReplacements); +// float minRadius; + unitParticleSystemTypeNode->addAttribute("minRadius",floatToStr(minRadius), mapTagReplacements); +// float emissionRateFade; + unitParticleSystemTypeNode->addAttribute("emissionRateFade",floatToStr(emissionRateFade), mapTagReplacements); +// Vec3f direction; + unitParticleSystemTypeNode->addAttribute("direction",direction.getString(), mapTagReplacements); +// bool relative; + unitParticleSystemTypeNode->addAttribute("relative",intToStr(relative), mapTagReplacements); +// bool relativeDirection; + unitParticleSystemTypeNode->addAttribute("relativeDirection",intToStr(relativeDirection), mapTagReplacements); +// bool fixed; + unitParticleSystemTypeNode->addAttribute("fixed",intToStr(fixed), mapTagReplacements); +// int staticParticleCount; + unitParticleSystemTypeNode->addAttribute("staticParticleCount",intToStr(staticParticleCount), mapTagReplacements); +// bool isVisibleAtNight; + unitParticleSystemTypeNode->addAttribute("isVisibleAtNight",intToStr(isVisibleAtNight), mapTagReplacements); +// bool isVisibleAtDay; + unitParticleSystemTypeNode->addAttribute("isVisibleAtDay",intToStr(isVisibleAtDay), mapTagReplacements); +// bool isDaylightAffected; + unitParticleSystemTypeNode->addAttribute("isDaylightAffected",intToStr(isDaylightAffected), mapTagReplacements); +// bool radiusBasedStartenergy; + unitParticleSystemTypeNode->addAttribute("radiusBasedStartenergy",intToStr(radiusBasedStartenergy), mapTagReplacements); +// int delay; + unitParticleSystemTypeNode->addAttribute("delay",intToStr(delay), mapTagReplacements); +// int lifetime; + unitParticleSystemTypeNode->addAttribute("lifetime",intToStr(lifetime), mapTagReplacements); +// float startTime; + unitParticleSystemTypeNode->addAttribute("startTime",floatToStr(startTime), mapTagReplacements); +// float endTime; + unitParticleSystemTypeNode->addAttribute("endTime",floatToStr(endTime), mapTagReplacements); +} + }}//end mamespace diff --git a/source/glest_game/graphics/unit_particle_type.h b/source/glest_game/graphics/unit_particle_type.h index a3e500161..4f591504d 100644 --- a/source/glest_game/graphics/unit_particle_type.h +++ b/source/glest_game/graphics/unit_particle_type.h @@ -82,6 +82,7 @@ public: const void setValues (UnitParticleSystem *uts); bool hasTexture() const { return(texture != NULL); } + virtual void saveGame(XmlNode *rootNode); }; class ObjectParticleSystemType: public UnitParticleSystemType{ diff --git a/source/glest_game/gui/display.cpp b/source/glest_game/gui/display.cpp index 1829f7fe1..9376b55b9 100644 --- a/source/glest_game/gui/display.cpp +++ b/source/glest_game/gui/display.cpp @@ -128,4 +128,31 @@ int Display::computeUpY(int index) const{ return Metrics::getInstance().getDisplayH() - (index/upCellSideCount)*upImageSize - upImageSize; } +void Display::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *displayNode = rootNode->addChild("Display"); + +// string title; + displayNode->addAttribute("title",title, mapTagReplacements); +// string text; + displayNode->addAttribute("text",text, mapTagReplacements); +// string infoText; + displayNode->addAttribute("infoText",infoText, mapTagReplacements); +// const Texture2D *upImages[upCellCount]; +// const Texture2D *downImages[downCellCount]; +// bool downLighted[downCellCount]; +// const CommandType *commandTypes[downCellCount]; +// CommandClass commandClasses[downCellCount]; +// int progressBar; + displayNode->addAttribute("progressBar",intToStr(progressBar), mapTagReplacements); +// int downSelectedPos; + displayNode->addAttribute("downSelectedPos",intToStr(downSelectedPos), mapTagReplacements); +// Vec4f colors[colorCount]; +// int currentColor; + displayNode->addAttribute("currentColor",intToStr(currentColor), mapTagReplacements); +// int upCellSideCount; +// int upImageSize; +// int maxUpIndex; + +} }}//end namespace diff --git a/source/glest_game/gui/display.h b/source/glest_game/gui/display.h index 3bd3d1c8f..ec7ca4f5f 100644 --- a/source/glest_game/gui/display.h +++ b/source/glest_game/gui/display.h @@ -103,6 +103,8 @@ public: int computeUpX(int index) const; int computeUpY(int index) const; + void saveGame(XmlNode *rootNode) const; + private: void calculateUpDimensions(int index); }; diff --git a/source/glest_game/gui/gui.cpp b/source/glest_game/gui/gui.cpp index 478d3e9a3..90eb251c3 100644 --- a/source/glest_game/gui/gui.cpp +++ b/source/glest_game/gui/gui.cpp @@ -1162,10 +1162,75 @@ Unit* Gui::getRelevantObjectFromSelection(Selection::UnitContainer *uc){ return resultUnit; } -void Gui::removingObjectEvent(Object* o){ +void Gui::removingObjectEvent(Object* o){ if(getSelectedResourceObject()==o){ selectedResourceObject=NULL; } } +void Gui::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *guiNode = rootNode->addChild("Gui"); + + //External objects +// RandomGen random; + guiNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); +// const Commander *commander; +// const World *world; +// const Game *game; +// GameCamera *gameCamera; +// Console *console; +// +// //Positions +// Vec2i posObjWorld; //world coords + guiNode->addAttribute("posObjWorld",posObjWorld.getString(), mapTagReplacements); +// bool validPosObjWorld; + guiNode->addAttribute("validPosObjWorld",intToStr(validPosObjWorld), mapTagReplacements); +// //display +// const UnitType *choosenBuildingType; + if(choosenBuildingType != NULL) { + guiNode->addAttribute("choosenBuildingType",choosenBuildingType->getName(), mapTagReplacements); + } +// const CommandType *activeCommandType; + if(activeCommandType != NULL) { + guiNode->addAttribute("activeCommandType",activeCommandType->getName(), mapTagReplacements); + } + +// CommandClass activeCommandClass; + guiNode->addAttribute("activeCommandClass",intToStr(activeCommandClass), mapTagReplacements); +// int activePos; + guiNode->addAttribute("activePos",intToStr(activePos), mapTagReplacements); +// int lastPosDisplay; + guiNode->addAttribute("lastPosDisplay",intToStr(lastPosDisplay), mapTagReplacements); +// //composite +// Display display; + display.saveGame(guiNode); +// Mouse3d mouse3d; +// Selection selection; + selection.saveGame(guiNode); +// SelectionQuad selectionQuad; +// int lastQuadCalcFrame; + guiNode->addAttribute("lastQuadCalcFrame",intToStr(lastQuadCalcFrame), mapTagReplacements); +// int selectionCalculationFrameSkip; + guiNode->addAttribute("selectionCalculationFrameSkip",intToStr(selectionCalculationFrameSkip), mapTagReplacements); +// int minQuadSize; + guiNode->addAttribute("minQuadSize",intToStr(minQuadSize), mapTagReplacements); +// Chrono lastGroupRecallTime; + //guiNode->addAttribute("lastGroupRecallTime",intToStr(lastGroupRecallTime.getMillis()), mapTagReplacements); +// int lastGroupRecall; + guiNode->addAttribute("lastGroupRecall",intToStr(lastGroupRecall), mapTagReplacements); +// //states +// bool selectingBuilding; + guiNode->addAttribute("selectingBuilding",intToStr(selectingBuilding), mapTagReplacements); +// bool selectingPos; + guiNode->addAttribute("selectingPos",intToStr(selectingPos), mapTagReplacements); +// bool selectingMeetingPoint; + guiNode->addAttribute("selectingMeetingPoint",intToStr(selectingMeetingPoint), mapTagReplacements); +// CardinalDir selectedBuildingFacing; + guiNode->addAttribute("selectedBuildingFacing",intToStr(selectedBuildingFacing), mapTagReplacements); +// const Object *selectedResourceObject; +// +// Texture2D* hudTexture; + +} }}//end namespace diff --git a/source/glest_game/gui/gui.h b/source/glest_game/gui/gui.h index 14e354bb0..004ae3c5d 100644 --- a/source/glest_game/gui/gui.h +++ b/source/glest_game/gui/gui.h @@ -199,6 +199,8 @@ public: void switchToNextDisplayColor(); void onSelectionChanged(); + void saveGame(XmlNode *rootNode) const; + private: //orders diff --git a/source/glest_game/gui/selection.cpp b/source/glest_game/gui/selection.cpp index ebb14212a..5723227bb 100644 --- a/source/glest_game/gui/selection.cpp +++ b/source/glest_game/gui/selection.cpp @@ -216,4 +216,33 @@ void Selection::unitEvent(UnitObserver::Event event, const Unit *unit){ } } +void Selection::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *selectionNode = rootNode->addChild("Selection"); + +// int factionIndex; + selectionNode->addAttribute("factionIndex",intToStr(factionIndex), mapTagReplacements); +// int teamIndex; + selectionNode->addAttribute("teamIndex",intToStr(teamIndex), mapTagReplacements); +// UnitContainer selectedUnits; + for(unsigned int i = 0; i < selectedUnits.size(); i++) { + Unit *unit = selectedUnits[i]; + + XmlNode *selectedUnitsNode = selectionNode->addChild("selectedUnits"); + selectedUnitsNode->addAttribute("id",intToStr(unit->getId()), mapTagReplacements); + } +// UnitContainer groups[maxGroups]; + for(unsigned int x = 0; x < maxGroups; ++x) { + XmlNode *groupsNode = selectionNode->addChild("groups"); + for(unsigned int i = 0; i < selectedUnits.size(); i++) { + Unit *unit = selectedUnits[i]; + + XmlNode *selectedUnitsNode = groupsNode->addChild("selectedUnits"); + selectedUnitsNode->addAttribute("id",intToStr(unit->getId()), mapTagReplacements); + } + } + +// Gui *gui; +} + }}//end namespace diff --git a/source/glest_game/gui/selection.h b/source/glest_game/gui/selection.h index 3047fa3b3..4d867e76f 100644 --- a/source/glest_game/gui/selection.h +++ b/source/glest_game/gui/selection.h @@ -79,6 +79,8 @@ public: virtual void unitEvent(UnitObserver::Event event, const Unit *unit); + + virtual void saveGame(XmlNode *rootNode) const; }; }}//end namespace diff --git a/source/glest_game/network/network_types.cpp b/source/glest_game/network/network_types.cpp index 982d1e575..1417b07c6 100644 --- a/source/glest_game/network/network_types.cpp +++ b/source/glest_game/network/network_types.cpp @@ -98,4 +98,37 @@ string NetworkCommand::toString() const { return result; } +void NetworkCommand::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *networkCommandNode = rootNode->addChild("NetworkCommand"); + +// int16 networkCommandType; + networkCommandNode->addAttribute("networkCommandType",intToStr(networkCommandType), mapTagReplacements); +// int32 unitId; + networkCommandNode->addAttribute("unitId",intToStr(unitId), mapTagReplacements); +// int16 unitTypeId; + networkCommandNode->addAttribute("unitTypeId",intToStr(unitTypeId), mapTagReplacements); +// int16 commandTypeId; + networkCommandNode->addAttribute("commandTypeId",intToStr(commandTypeId), mapTagReplacements); +// int16 positionX; + networkCommandNode->addAttribute("positionX",intToStr(positionX), mapTagReplacements); +// int16 positionY; + networkCommandNode->addAttribute("positionY",intToStr(positionY), mapTagReplacements); +// int32 targetId; + networkCommandNode->addAttribute("targetId",intToStr(targetId), mapTagReplacements); +// int8 wantQueue; + networkCommandNode->addAttribute("wantQueue",intToStr(wantQueue), mapTagReplacements); +// int8 fromFactionIndex; + networkCommandNode->addAttribute("fromFactionIndex",intToStr(fromFactionIndex), mapTagReplacements); +// uint16 unitFactionUnitCount; + networkCommandNode->addAttribute("unitFactionUnitCount",intToStr(unitFactionUnitCount), mapTagReplacements); +// int8 unitFactionIndex; + networkCommandNode->addAttribute("unitFactionIndex",intToStr(unitFactionIndex), mapTagReplacements); +// int8 commandStateType; + networkCommandNode->addAttribute("commandStateType",intToStr(commandStateType), mapTagReplacements); +// int32 commandStateValue; + networkCommandNode->addAttribute("commandStateValue",intToStr(commandStateValue), mapTagReplacements); +// int32 unitCommandGroupId; + networkCommandNode->addAttribute("unitCommandGroupId",intToStr(unitCommandGroupId), mapTagReplacements); +} }}//end namespace diff --git a/source/glest_game/network/network_types.h b/source/glest_game/network/network_types.h index d3fef7290..009868ad0 100644 --- a/source/glest_game/network/network_types.h +++ b/source/glest_game/network/network_types.h @@ -130,6 +130,9 @@ public: void preprocessNetworkCommand(World *world); string toString() const; + + void saveGame(XmlNode *rootNode); + }; #pragma pack(pop) diff --git a/source/glest_game/type_instances/command.cpp b/source/glest_game/type_instances/command.cpp index 1fd11a5f3..82d9b19d8 100644 --- a/source/glest_game/type_instances/command.cpp +++ b/source/glest_game/type_instances/command.cpp @@ -140,4 +140,31 @@ std::string Command::toString() const { return result; } +void Command::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *commandNode = rootNode->addChild("Command"); + +// const CommandType *commandType; + if(commandType != NULL) { + commandNode->addAttribute("commandType",commandType->getName(), mapTagReplacements); + } +// Vec2i originalPos; + commandNode->addAttribute("originalPos",originalPos.getString(), mapTagReplacements); +// Vec2i pos; + commandNode->addAttribute("pos",pos.getString(), mapTagReplacements); +// UnitReference unitRef; //target unit, used to move and attack optionally + unitRef.saveGame(commandNode); +// CardinalDir facing; // facing, for build command + commandNode->addAttribute("facing",intToStr(facing), mapTagReplacements); +// const UnitType *unitType; //used for build + if(unitType != NULL) { + commandNode->addAttribute("unitType",unitType->getName(), mapTagReplacements); + } +// CommandStateType stateType; + commandNode->addAttribute("stateType",intToStr(stateType), mapTagReplacements); +// int stateValue; + commandNode->addAttribute("stateValue",intToStr(stateValue), mapTagReplacements); +// int unitCommandGroupId; + commandNode->addAttribute("unitCommandGroupId",intToStr(unitCommandGroupId), mapTagReplacements); +} }}//end namespace diff --git a/source/glest_game/type_instances/command.h b/source/glest_game/type_instances/command.h index 518249a6b..654e3b347 100644 --- a/source/glest_game/type_instances/command.h +++ b/source/glest_game/type_instances/command.h @@ -86,6 +86,8 @@ public: int getUnitCommandGroupId() const { return unitCommandGroupId; } std::string toString() const; + + void saveGame(XmlNode *rootNode); }; }}//end namespace diff --git a/source/glest_game/type_instances/faction.cpp b/source/glest_game/type_instances/faction.cpp index 71122a9af..f7b952d21 100644 --- a/source/glest_game/type_instances/faction.cpp +++ b/source/glest_game/type_instances/faction.cpp @@ -1761,4 +1761,77 @@ std::string Faction::toString() const { return result; } +void Faction::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *factionNode = rootNode->addChild("Faction"); + +// UpgradeManager upgradeManager; + upgradeManager.saveGame(factionNode); +// Resources resources; + for(unsigned int i = 0; i < resources.size(); ++i) { + Resource &resource = resources[i]; + resource.saveGame(factionNode); + } +// Store store; +// Allies allies; + for(unsigned int i = 0; i < allies.size(); ++i) { + Faction *ally = allies[i]; + XmlNode *allyNode = factionNode->addChild("Ally"); + allyNode->addAttribute("startlocationindex",intToStr(ally->getStartLocationIndex()), mapTagReplacements); + } +// Mutex *unitsMutex; +// Units units; + for(unsigned int i = 0; i < units.size(); ++i) { + Unit *unit = units[i]; + unit->saveGame(factionNode); + } +// UnitMap unitMap; +// World *world; +// ScriptManager *scriptManager; +// +// ControlType control; + factionNode->addAttribute("control",intToStr(control), mapTagReplacements); +// Texture2D *texture; +// FactionType *factionType; + factionNode->addAttribute("factiontype",factionType->getName(), mapTagReplacements); +// int index; + factionNode->addAttribute("index",intToStr(index), mapTagReplacements); +// int teamIndex; + factionNode->addAttribute("teamIndex",intToStr(teamIndex), mapTagReplacements); +// int startLocationIndex; + factionNode->addAttribute("startLocationIndex",intToStr(startLocationIndex), mapTagReplacements); +// bool thisFaction; + factionNode->addAttribute("thisFaction",intToStr(thisFaction), mapTagReplacements); +// bool factionDisconnectHandled; +// +// bool cachingDisabled; +// std::map cacheResourceTargetList; + for(std::map::iterator iterMap = cacheResourceTargetList.begin(); + iterMap != cacheResourceTargetList.end(); ++iterMap) { + XmlNode *cacheResourceTargetListNode = factionNode->addChild("cacheResourceTargetList"); + + cacheResourceTargetListNode->addAttribute("key",iterMap->first.getString(), mapTagReplacements); + cacheResourceTargetListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } +// std::map cachedCloseResourceTargetLookupList; + for(std::map::iterator iterMap = cachedCloseResourceTargetLookupList.begin(); + iterMap != cachedCloseResourceTargetLookupList.end(); ++iterMap) { + XmlNode *cachedCloseResourceTargetLookupListNode = factionNode->addChild("cachedCloseResourceTargetLookupList"); + + cachedCloseResourceTargetLookupListNode->addAttribute("key",iterMap->first.getString(), mapTagReplacements); + cachedCloseResourceTargetLookupListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } + +// RandomGen random; + factionNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); +// FactionThread *workerThread; +// +// std::map switchTeamVotes; +// int currentSwitchTeamVoteFactionIndex; + factionNode->addAttribute("currentSwitchTeamVoteFactionIndex",intToStr(currentSwitchTeamVoteFactionIndex), mapTagReplacements); +// set livingUnits; +// set livingUnitsp; + +} + }}//end namespace diff --git a/source/glest_game/type_instances/faction.h b/source/glest_game/type_instances/faction.h index 2377044c9..f907825a1 100644 --- a/source/glest_game/type_instances/faction.h +++ b/source/glest_game/type_instances/faction.h @@ -256,6 +256,8 @@ public: std::string toString() const; + void saveGame(XmlNode *rootNode); + private: void resetResourceAmount(const ResourceType *rt); }; diff --git a/source/glest_game/type_instances/resource.cpp b/source/glest_game/type_instances/resource.cpp index c6e52e13d..7417082df 100644 --- a/source/glest_game/type_instances/resource.cpp +++ b/source/glest_game/type_instances/resource.cpp @@ -101,4 +101,18 @@ bool Resource::decAmount(int i) { return true; } +void Resource::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *resourceNode = rootNode->addChild("Resource"); + +// int amount; + resourceNode->addAttribute("amount",intToStr(amount), mapTagReplacements); +// const ResourceType *type; + resourceNode->addAttribute("type",type->getName(), mapTagReplacements); +// Vec2i pos; + resourceNode->addAttribute("pos",pos.getString(), mapTagReplacements); +// int balance; + resourceNode->addAttribute("balance",intToStr(balance), mapTagReplacements); +} + }}//end namespace diff --git a/source/glest_game/type_instances/resource.h b/source/glest_game/type_instances/resource.h index 05540590f..9fa41b906 100644 --- a/source/glest_game/type_instances/resource.h +++ b/source/glest_game/type_instances/resource.h @@ -14,10 +14,12 @@ #include #include "vec.h" #include "platform_common.h" +#include "xml_parser.h" #include "leak_dumper.h" using std::string; using std::map; +using Shared::Xml::XmlNode; namespace Glest{ namespace Game{ @@ -55,6 +57,8 @@ public: void setBalance(int balance); bool decAmount(int i); + + void saveGame(XmlNode *rootNode) const; }; }}// end namespace diff --git a/source/glest_game/type_instances/unit.cpp b/source/glest_game/type_instances/unit.cpp index 067b9470c..0b3f0c64a 100644 --- a/source/glest_game/type_instances/unit.cpp +++ b/source/glest_game/type_instances/unit.cpp @@ -157,6 +157,29 @@ std::string UnitPathBasic::toString() const { return result; } + +void UnitPathBasic::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *unitPathBasicNode = rootNode->addChild("UnitPathBasic"); + +// int blockCount; + unitPathBasicNode->addAttribute("blockCount",intToStr(blockCount), mapTagReplacements); +// vector pathQueue; + for(unsigned int i = 0; i < pathQueue.size(); ++i) { + Vec2i &vec = pathQueue[i]; + + XmlNode *pathQueueNode = unitPathBasicNode->addChild("pathQueue"); + pathQueueNode->addAttribute("vec",vec.getString(), mapTagReplacements); + } +// vector lastPathCacheQueue; + for(unsigned int i = 0; i < lastPathCacheQueue.size(); ++i) { + Vec2i &vec = lastPathCacheQueue[i]; + + XmlNode *lastPathCacheQueueNode = unitPathBasicNode->addChild("lastPathCacheQueue"); + lastPathCacheQueueNode->addAttribute("vec",vec.getString(), mapTagReplacements); + } +} + // ===================================================== // class UnitPath // ===================================================== @@ -217,6 +240,16 @@ Unit *UnitReference::getUnit() const{ return NULL; } +void UnitReference::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *unitRefNode = rootNode->addChild("UnitReference"); + + unitRefNode->addAttribute("id",intToStr(id), mapTagReplacements); + if(faction != NULL) { + unitRefNode->addAttribute("faction",intToStr(faction->getIndex()), mapTagReplacements); + } +} + const bool checkMemory = false; static map memoryObjectList; @@ -257,6 +290,29 @@ UnitAttackBoostEffect::~UnitAttackBoostEffect() { upst = NULL; } +void UnitAttackBoostEffect::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *unitAttackBoostEffectNode = rootNode->addChild("UnitAttackBoostEffect"); + +// const AttackBoost *boost; + if(boost != NULL) { + boost->saveGame(unitAttackBoostEffectNode); + } +// const Unit *source; + if(source != NULL) { + unitAttackBoostEffectNode->addAttribute("source",intToStr(source->getId()), mapTagReplacements); + } +// UnitParticleSystem *ups; + if(ups != NULL) { + ups->saveGame(unitAttackBoostEffectNode); + } + +// UnitParticleSystemType *upst; + if(upst != NULL) { + upst->saveGame(unitAttackBoostEffectNode); + } +} + UnitAttackBoostEffectOriginator::UnitAttackBoostEffectOriginator() { skillType = NULL; currentAppliedEffect = NULL; @@ -267,6 +323,24 @@ UnitAttackBoostEffectOriginator::~UnitAttackBoostEffectOriginator() { currentAppliedEffect = NULL; } +void UnitAttackBoostEffectOriginator::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *unitAttackBoostEffectOriginatorNode = rootNode->addChild("UnitAttackBoostEffectOriginator"); + +// const SkillType *skillType; + if(skillType != NULL) { + unitAttackBoostEffectOriginatorNode->addAttribute("skillType",skillType->getName(), mapTagReplacements); + } +// std::vector currentAttackBoostUnits; + for(unsigned int i = 0; i < currentAttackBoostUnits.size(); ++i) { + XmlNode *currentAttackBoostUnitsNode = unitAttackBoostEffectOriginatorNode->addChild("currentAttackBoostUnits"); + currentAttackBoostUnitsNode->addAttribute("value",intToStr(currentAttackBoostUnits[i]), mapTagReplacements); + } +// UnitAttackBoostEffect *currentAppliedEffect; + if(currentAppliedEffect != NULL) { + currentAppliedEffect->saveGame(unitAttackBoostEffectOriginatorNode); + } +} // ===================================================== // class Unit @@ -3353,4 +3427,228 @@ std::string Unit::toString() const { return result; } +void Unit::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *unitNode = rootNode->addChild("Unit"); + +// const int id; + unitNode->addAttribute("id",intToStr(id), mapTagReplacements); +// int hp; + unitNode->addAttribute("hp",intToStr(hp), mapTagReplacements); +// int ep; + unitNode->addAttribute("ep",intToStr(ep), mapTagReplacements); +// int loadCount; + unitNode->addAttribute("loadCount",intToStr(loadCount), mapTagReplacements); +// int deadCount; + unitNode->addAttribute("deadCount",intToStr(deadCount), mapTagReplacements); +// float progress; //between 0 and 1 + unitNode->addAttribute("progress",floatToStr(progress), mapTagReplacements); +// float lastAnimProgress; //between 0 and 1 + unitNode->addAttribute("lastAnimProgress",floatToStr(lastAnimProgress), mapTagReplacements); +// float animProgress; //between 0 and 1 + unitNode->addAttribute("animProgress",floatToStr(animProgress), mapTagReplacements); +// float highlight; + unitNode->addAttribute("highlight",floatToStr(highlight), mapTagReplacements); +// int progress2; + unitNode->addAttribute("progress2",intToStr(progress2), mapTagReplacements); +// int kills; + unitNode->addAttribute("kills",intToStr(kills), mapTagReplacements); +// int enemyKills; + unitNode->addAttribute("enemyKills",intToStr(enemyKills), mapTagReplacements); +// UnitReference targetRef; + targetRef.saveGame(unitNode); +// +// Field currField; + unitNode->addAttribute("currField",intToStr(currField), mapTagReplacements); +// Field targetField; + unitNode->addAttribute("targetField",intToStr(targetField), mapTagReplacements); +// const Level *level; + if(level != NULL) { + level->saveGame(unitNode); + } +// Vec2i pos; + unitNode->addAttribute("pos",pos.getString(), mapTagReplacements); +// Vec2i lastPos; + unitNode->addAttribute("lastPos",lastPos.getString(), mapTagReplacements); +// Vec2i targetPos; //absolute target pos + unitNode->addAttribute("targetPos",targetPos.getString(), mapTagReplacements); +// Vec3f targetVec; + unitNode->addAttribute("targetVec",targetVec.getString(), mapTagReplacements); +// Vec2i meetingPos; + unitNode->addAttribute("meetingPos",meetingPos.getString(), mapTagReplacements); +// +// float lastRotation; //in degrees + unitNode->addAttribute("lastRotation",floatToStr(lastRotation), mapTagReplacements); +// float targetRotation; + unitNode->addAttribute("targetRotation",floatToStr(targetRotation), mapTagReplacements); +// float rotation; + unitNode->addAttribute("rotation",floatToStr(rotation), mapTagReplacements); +// float targetRotationZ; + unitNode->addAttribute("targetRotationZ",floatToStr(targetRotationZ), mapTagReplacements); +// float targetRotationX; + unitNode->addAttribute("targetRotationX",floatToStr(targetRotationX), mapTagReplacements); +// float rotationZ; + unitNode->addAttribute("rotationZ",floatToStr(rotationZ), mapTagReplacements); +// float rotationX; + unitNode->addAttribute("rotationX",floatToStr(rotationX), mapTagReplacements); +// const UnitType *type; + unitNode->addAttribute("type",type->getName(), mapTagReplacements); +// const ResourceType *loadType; + if(loadType != NULL) { + unitNode->addAttribute("loadType",loadType->getName(), mapTagReplacements); + } +// const SkillType *currSkill; + if(currSkill != NULL) { + unitNode->addAttribute("currSkill",currSkill->getName(), mapTagReplacements); + } +// int lastModelIndexForCurrSkillType; + unitNode->addAttribute("lastModelIndexForCurrSkillType",intToStr(lastModelIndexForCurrSkillType), mapTagReplacements); +// int animationRandomCycleCount; + unitNode->addAttribute("animationRandomCycleCount",intToStr(animationRandomCycleCount), mapTagReplacements); +// +// bool toBeUndertaken; + unitNode->addAttribute("toBeUndertaken",intToStr(toBeUndertaken), mapTagReplacements); +// bool alive; + unitNode->addAttribute("alive",intToStr(alive), mapTagReplacements); +// bool showUnitParticles; + unitNode->addAttribute("showUnitParticles",intToStr(showUnitParticles), mapTagReplacements); +// Faction *faction; +// ParticleSystem *fire; + if(fire != NULL) { + fire->saveGame(unitNode); + } +// TotalUpgrade totalUpgrade; + totalUpgrade.saveGame(unitNode); +// Map *map; +// +// UnitPathInterface *unitPath; + unitPath->saveGame(unitNode); +// WaypointPath waypointPath; +// +// Commands commands; + for(Commands::iterator it = commands.begin(); it != commands.end(); ++it) { + (*it)->saveGame(unitNode); + } +// Observers observers; + for(Observers::iterator it = observers.begin(); it != observers.end(); ++it) { + (*it)->saveGame(unitNode); + } + +// vector unitParticleSystems; + for(unsigned int i = 0; i < unitParticleSystems.size(); ++i) { + UnitParticleSystem *ups= unitParticleSystems[i]; + ups->saveGame(unitNode); + } +// vector queuedUnitParticleSystemTypes; + for(unsigned int i = 0; i < queuedUnitParticleSystemTypes.size(); ++i) { + UnitParticleSystemType *upst= queuedUnitParticleSystemTypes[i]; + upst->saveGame(unitNode); + } + +// UnitParticleSystems damageParticleSystems; + for(unsigned int i = 0; i < damageParticleSystems.size(); ++i) { + UnitParticleSystem *ups= damageParticleSystems[i]; + ups->saveGame(unitNode); + } + +// std::map damageParticleSystemsInUse; + for(std::map::const_iterator iterMap = damageParticleSystemsInUse.begin(); + iterMap != damageParticleSystemsInUse.end(); ++iterMap) { + XmlNode *damageParticleSystemsInUseNode = unitNode->addChild("damageParticleSystemsInUse"); + + damageParticleSystemsInUseNode->addAttribute("key",intToStr(iterMap->first), mapTagReplacements); + iterMap->second->saveGame(damageParticleSystemsInUseNode); + } +// vector fireParticleSystems; + for(unsigned int i = 0; i < fireParticleSystems.size(); ++i) { + ParticleSystem *ps= fireParticleSystems[i]; + ps->saveGame(unitNode); + } + +// vector smokeParticleSystems; + for(unsigned int i = 0; i < smokeParticleSystems.size(); ++i) { + UnitParticleSystem *ups= smokeParticleSystems[i]; + ups->saveGame(unitNode); + } + +// CardinalDir modelFacing; + unitNode->addAttribute("modelFacing",intToStr(modelFacing), mapTagReplacements); + +// std::string lastSynchDataString; + unitNode->addAttribute("lastSynchDataString",lastSynchDataString, mapTagReplacements); +// std::string lastFile; + unitNode->addAttribute("lastFile",lastFile, mapTagReplacements); +// int lastLine; + unitNode->addAttribute("lastLine",intToStr(lastLine), mapTagReplacements); +// std::string lastSource; + unitNode->addAttribute("lastSource",lastSource, mapTagReplacements); +// int lastRenderFrame; + unitNode->addAttribute("lastRenderFrame",intToStr(lastRenderFrame), mapTagReplacements); +// bool visible; + unitNode->addAttribute("visible",intToStr(visible), mapTagReplacements); +// int retryCurrCommandCount; + unitNode->addAttribute("retryCurrCommandCount",intToStr(retryCurrCommandCount), mapTagReplacements); +// Vec3f screenPos; + unitNode->addAttribute("screenPos",screenPos.getString(), mapTagReplacements); +// string currentUnitTitle; + unitNode->addAttribute("currentUnitTitle",currentUnitTitle, mapTagReplacements); +// +// bool inBailOutAttempt; + unitNode->addAttribute("inBailOutAttempt",intToStr(inBailOutAttempt), mapTagReplacements); +// //std::vector > badHarvestPosList; +// std::map badHarvestPosList; + for(std::map::const_iterator iterMap = badHarvestPosList.begin(); + iterMap != badHarvestPosList.end(); ++iterMap) { + XmlNode *badHarvestPosListNode = unitNode->addChild("badHarvestPosList"); + + badHarvestPosListNode->addAttribute("key",iterMap->first.getString(), mapTagReplacements); + badHarvestPosListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } + +// //time_t lastBadHarvestListPurge; +// std::pair lastHarvestResourceTarget; + XmlNode *lastHarvestResourceTargetNode = unitNode->addChild("lastHarvestResourceTarget"); + lastHarvestResourceTargetNode->addAttribute("key",lastHarvestResourceTarget.first.getString(), mapTagReplacements); + lastHarvestResourceTargetNode->addAttribute("value",intToStr(lastHarvestResourceTarget.second), mapTagReplacements); + +// //std::pair > currentTargetPathTaken; +// static Game *game; +// +// bool ignoreCheckCommand; + unitNode->addAttribute("ignoreCheckCommand",intToStr(ignoreCheckCommand), mapTagReplacements); +// uint32 lastStuckFrame; + unitNode->addAttribute("lastStuckFrame",intToStr(lastStuckFrame), mapTagReplacements); +// Vec2i lastStuckPos; + unitNode->addAttribute("lastStuckPos",lastStuckPos.getString(), mapTagReplacements); +// uint32 lastPathfindFailedFrame; + unitNode->addAttribute("lastPathfindFailedFrame",intToStr(lastPathfindFailedFrame), mapTagReplacements); +// Vec2i lastPathfindFailedPos; + unitNode->addAttribute("lastPathfindFailedPos",lastPathfindFailedPos.getString(), mapTagReplacements); +// bool usePathfinderExtendedMaxNodes; + unitNode->addAttribute("usePathfinderExtendedMaxNodes",intToStr(usePathfinderExtendedMaxNodes), mapTagReplacements); +// int maxQueuedCommandDisplayCount; + unitNode->addAttribute("maxQueuedCommandDisplayCount",intToStr(maxQueuedCommandDisplayCount), mapTagReplacements); +// UnitAttackBoostEffectOriginator currentAttackBoostOriginatorEffect; + currentAttackBoostOriginatorEffect.saveGame(unitNode); +// std::vector currentAttackBoostEffects; + for(unsigned int i = 0; i < currentAttackBoostEffects.size(); ++i) { + UnitAttackBoostEffect *uabe= currentAttackBoostEffects[i]; + uabe->saveGame(unitNode); + } + +// Mutex *mutexCommands; +// +// //static Mutex mutexDeletedUnits; +// //static std::map deletedUnits; +// +// bool changedActiveCommand; + unitNode->addAttribute("changedActiveCommand",intToStr(changedActiveCommand), mapTagReplacements); +// int lastAttackerUnitId; + unitNode->addAttribute("lastAttackerUnitId",intToStr(lastAttackerUnitId), mapTagReplacements); +// int lastAttackedUnitId; + unitNode->addAttribute("lastAttackedUnitId",intToStr(lastAttackedUnitId), mapTagReplacements); +// CauseOfDeathType causeOfDeath; + unitNode->addAttribute("causeOfDeath",intToStr(causeOfDeath), mapTagReplacements); +} + }}//end namespace diff --git a/source/glest_game/type_instances/unit.h b/source/glest_game/type_instances/unit.h index 8d495361e..b24570e0f 100644 --- a/source/glest_game/type_instances/unit.h +++ b/source/glest_game/type_instances/unit.h @@ -88,6 +88,8 @@ public: public: virtual ~UnitObserver() {} virtual void unitEvent(Event event, const Unit *unit)=0; + + virtual void saveGame(XmlNode *rootNode) const = 0; }; // ===================================================== @@ -107,6 +109,8 @@ public: int getUnitId() const { return id; } Faction *getUnitFaction() const { return faction; } + + void saveGame(XmlNode *rootNode); }; class UnitPathInterface { @@ -133,6 +137,8 @@ public: virtual void setMap(Map *value) = 0; virtual Map * getMap() = 0; + + virtual void saveGame(XmlNode *rootNode) = 0; }; class UnitPathBasic : public UnitPathInterface { @@ -179,6 +185,8 @@ public: virtual Map * getMap() { return map; } virtual std::string toString() const; + + virtual void saveGame(XmlNode *rootNode); }; // ===================================================== @@ -235,6 +243,8 @@ public: virtual Map * getMap() { return map; } virtual std::string toString() const; + + virtual void saveGame(XmlNode *rootNode) {}; }; class WaypointPath : public list { @@ -264,6 +274,7 @@ public: UnitParticleSystem *ups; UnitParticleSystemType *upst; + virtual void saveGame(XmlNode *rootNode); }; class UnitAttackBoostEffectOriginator { @@ -275,6 +286,8 @@ public: const SkillType *skillType; std::vector currentAttackBoostUnits; UnitAttackBoostEffect *currentAppliedEffect; + + virtual void saveGame(XmlNode *rootNode); }; class Unit : public BaseColorPickEntity, ValueCheckerVault { @@ -627,6 +640,8 @@ public: void updateTimedParticles(); virtual string getUniquePickName() const; + void saveGame(XmlNode *rootNode); + private: float computeHeight(const Vec2i &pos) const; void calculateXZRotation(); diff --git a/source/glest_game/type_instances/upgrade.cpp b/source/glest_game/type_instances/upgrade.cpp index 64dfbf848..bdc58a318 100644 --- a/source/glest_game/type_instances/upgrade.cpp +++ b/source/glest_game/type_instances/upgrade.cpp @@ -65,6 +65,14 @@ std::string Upgrade::toString() const { return result; } +void Upgrade::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *upgradeNode = rootNode->addChild("Upgrade"); + + upgradeNode->addAttribute("state",intToStr(state), mapTagReplacements); + upgradeNode->addAttribute("factionIndex",intToStr(factionIndex), mapTagReplacements); + upgradeNode->addAttribute("type",type->getName(), mapTagReplacements); +} // ===================================================== // class UpgradeManager @@ -226,4 +234,18 @@ std::string UpgradeManager::toString() const { return result; } +void UpgradeManager::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *upgrademanagerNode = rootNode->addChild("UpgradeManager"); + + for(unsigned int i = 0; i < upgrades.size(); ++i) { + upgrades[i]->saveGame(upgrademanagerNode); + } + +// Upgrades upgrades; +// UgradesLookup upgradesLookup; + +} + + }}// end namespace diff --git a/source/glest_game/type_instances/upgrade.h b/source/glest_game/type_instances/upgrade.h index 514a68b05..b07f92138 100644 --- a/source/glest_game/type_instances/upgrade.h +++ b/source/glest_game/type_instances/upgrade.h @@ -15,10 +15,12 @@ #include #include #include +#include "xml_parser.h" #include "leak_dumper.h" using std::vector; using std::map; +using Shared::Xml::XmlNode; namespace Glest { namespace Game { @@ -62,6 +64,8 @@ private: void setState(UpgradeState state); std::string toString() const; + + void saveGame(XmlNode *rootNode); }; @@ -90,6 +94,7 @@ public: void computeTotalUpgrade(const Unit *unit, TotalUpgrade *totalUpgrade) const; std::string toString() const; + void saveGame(XmlNode *rootNode); }; }}//end namespace diff --git a/source/glest_game/types/damage_multiplier.cpp b/source/glest_game/types/damage_multiplier.cpp index 87e8531ad..26e14df50 100644 --- a/source/glest_game/types/damage_multiplier.cpp +++ b/source/glest_game/types/damage_multiplier.cpp @@ -10,11 +10,33 @@ // ============================================================== #include "damage_multiplier.h" - +#include "conversion.h" #include "leak_dumper.h" +using namespace Shared::Util; + namespace Glest{ namespace Game{ +void AttackType::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *attackTypeNode = rootNode->addChild("AttackType"); + +// string name; + attackTypeNode->addAttribute("name",name, mapTagReplacements); +// int id; + attackTypeNode->addAttribute("id",intToStr(id), mapTagReplacements); +} + +void ArmorType::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *armorTypeNode = rootNode->addChild("ArmorType"); + +// string name; + armorTypeNode->addAttribute("name",name, mapTagReplacements); +// int id; + armorTypeNode->addAttribute("id",intToStr(id), mapTagReplacements); +} + // ===================================================== // class DamageMultiplierTable // ===================================================== @@ -48,4 +70,21 @@ void DamageMultiplierTable::setDamageMultiplier(const AttackType *att, const Arm values[attackTypeCount*art->getId()+att->getId()]= value; } +void DamageMultiplierTable::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *damageMultiplierTableNode = rootNode->addChild("DamageMultiplierTable"); + +// float *values; +// int attackTypeCount; +// int armorTypeCount; + damageMultiplierTableNode->addAttribute("attackTypeCount",intToStr(attackTypeCount), mapTagReplacements); + damageMultiplierTableNode->addAttribute("armorTypeCount",intToStr(armorTypeCount), mapTagReplacements); + + int valueCount= attackTypeCount * armorTypeCount; + for(unsigned int i=0; i < valueCount; ++i) { + XmlNode *valuesNode = damageMultiplierTableNode->addChild("values"); + valuesNode->addAttribute("value",intToStr(values[i]), mapTagReplacements); + } +} + }}//end namespaces diff --git a/source/glest_game/types/damage_multiplier.h b/source/glest_game/types/damage_multiplier.h index c08343756..46824d48c 100644 --- a/source/glest_game/types/damage_multiplier.h +++ b/source/glest_game/types/damage_multiplier.h @@ -13,9 +13,11 @@ #define _GLEST_GAME_DAMAGEMULTIPLIER_H_ #include +#include "xml_parser.h" #include "leak_dumper.h" using std::string; +using Shared::Xml::XmlNode; namespace Glest{ namespace Game{ @@ -23,7 +25,7 @@ namespace Glest{ namespace Game{ // class AttackType // =============================== -class AttackType{ +class AttackType { private: string name; int id; @@ -37,6 +39,8 @@ public: void setName(const string &name) {this->name= name;} void setId(int id) {this->id= id;} + + void saveGame(XmlNode *rootNode); }; // =============================== @@ -57,6 +61,8 @@ public: void setName(const string &name) {this->name= name;} void setId(int id) {this->id= id;} + + void saveGame(XmlNode *rootNode); }; // ===================================================== @@ -66,7 +72,7 @@ public: /// armor types and vice-versa // ===================================================== -class DamageMultiplierTable{ +class DamageMultiplierTable { private: float *values; int attackTypeCount; @@ -79,6 +85,8 @@ public: void init(int attackTypeCount, int armorTypeCount); float getDamageMultiplier(const AttackType *att, const ArmorType *art) const; void setDamageMultiplier(const AttackType *att, const ArmorType *art, float value); + + void saveGame(XmlNode *rootNode); }; }}//end namespace diff --git a/source/glest_game/types/element_type.cpp b/source/glest_game/types/element_type.cpp index f1f31d501..9ffc100e9 100644 --- a/source/glest_game/types/element_type.cpp +++ b/source/glest_game/types/element_type.cpp @@ -35,6 +35,13 @@ DisplayableType::DisplayableType(){ image= NULL; } +void DisplayableType::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *displayableTypeNode = rootNode->addChild("DisplayableType"); + + displayableTypeNode->addAttribute("name",name, mapTagReplacements); +} + // ===================================================== // class RequirableType // ===================================================== @@ -71,6 +78,28 @@ string RequirableType::getReqDesc() const{ } } +void RequirableType::saveGame(XmlNode *rootNode) const { + DisplayableType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *requirableTypeNode = rootNode->addChild("RequirableType"); + +// UnitReqs unitReqs; //needed units + for(unsigned int i = 0; i < unitReqs.size(); ++i) { + const UnitType *ut = unitReqs[i]; + + XmlNode *unitReqsNode = requirableTypeNode->addChild("unitReqs"); + unitReqsNode->addAttribute("name",ut->getName(), mapTagReplacements); + } +// UpgradeReqs upgradeReqs; //needed upgrades + for(unsigned int i = 0; i < upgradeReqs.size(); ++i) { + const UpgradeType* ut = upgradeReqs[i]; + + ut->saveGame(requirableTypeNode); + } + +} + // ===================================================== // class ProducibleType // ===================================================== @@ -115,4 +144,20 @@ string ProducibleType::getReqDesc() const{ return str; } +void ProducibleType::saveGame(XmlNode *rootNode) const { + RequirableType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *producibleTypeNode = rootNode->addChild("ProducibleType"); + +// Costs costs; + for(unsigned int i = 0; i < costs.size(); ++i) { + const Resource &res = costs[i]; + res.saveGame(producibleTypeNode); + } +// Texture2D *cancelImage; +// int productionTime; + producibleTypeNode->addAttribute("productionTime",intToStr(productionTime), mapTagReplacements); +} + }}//end namespace diff --git a/source/glest_game/types/element_type.h b/source/glest_game/types/element_type.h index 5d48f42f5..80245ab3d 100644 --- a/source/glest_game/types/element_type.h +++ b/source/glest_game/types/element_type.h @@ -39,7 +39,7 @@ class ResourceType; /// Base class for anything that has a name and a portrait // ===================================================== -class DisplayableType{ +class DisplayableType { protected: string name; //name Texture2D *image; //portrait @@ -51,6 +51,8 @@ public: //get string getName() const {return name;} const Texture2D *getImage() const {return image;} + + virtual void saveGame(XmlNode *rootNode) const; }; @@ -78,6 +80,8 @@ public: //other virtual string getReqDesc() const; + + virtual void saveGame(XmlNode *rootNode) const; }; @@ -87,7 +91,7 @@ public: /// Base class for anything that can be produced // ===================================================== -class ProducibleType: public RequirableType{ +class ProducibleType: public RequirableType { private: typedef vector Costs; @@ -111,6 +115,8 @@ public: void checkCostStrings(TechTree *techTree); virtual string getReqDesc() const; + + virtual void saveGame(XmlNode *rootNode) const; }; }}//end namespace diff --git a/source/glest_game/types/faction_type.cpp b/source/glest_game/types/faction_type.cpp index 0eca3c5db..320373632 100644 --- a/source/glest_game/types/faction_type.cpp +++ b/source/glest_game/types/faction_type.cpp @@ -799,4 +799,56 @@ std::string FactionType::toString() const { return result; } +void FactionType::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *factionTypeNode = rootNode->addChild("FactionType"); + +// string name; + factionTypeNode->addAttribute("name",name, mapTagReplacements); +// UnitTypes unitTypes; + for(unsigned int i = 0; i < unitTypes.size(); ++i) { + XmlNode *unitTypesNode = factionTypeNode->addChild("unitTypes"); + unitTypesNode->addAttribute("name",unitTypes[i].getName(), mapTagReplacements); + } +// UpgradeTypes upgradeTypes; + for(unsigned int i = 0; i < upgradeTypes.size(); ++i) { + XmlNode *upgradeTypesNode = factionTypeNode->addChild("upgradeTypes"); + upgradeTypesNode->addAttribute("name",upgradeTypes[i].getName(), mapTagReplacements); + } + +// StartingUnits startingUnits; + for(unsigned int i = 0; i < startingUnits.size(); ++i) { + XmlNode *startingUnitsNode = factionTypeNode->addChild("startingUnits"); + startingUnitsNode->addAttribute("name",startingUnits[i].first->getName(), mapTagReplacements); + startingUnitsNode->addAttribute("count",intToStr(startingUnits[i].second), mapTagReplacements); + } + +// Resources startingResources; + for(unsigned int i = 0; i < startingResources.size(); ++i) { + startingResources[i].saveGame(factionTypeNode); + } + +// StrSound *music; +// FactionPersonalityType personalityType; + factionTypeNode->addAttribute("personalityType",intToStr(personalityType), mapTagReplacements); +// std::map > mapAIBehaviorUnitCategories; + for(std::map >::iterator iterMap = mapAIBehaviorUnitCategories.begin(); + iterMap != mapAIBehaviorUnitCategories.end(); ++iterMap) { + + std::vector &vct = iterMap->second; + for(unsigned int i = 0; i < vct.size(); ++i) { + PairPUnitTypeInt &item = vct[i]; + + XmlNode *mapAIBehaviorUnitCategoriesNode = factionTypeNode->addChild("mapAIBehaviorUnitCategories"); + mapAIBehaviorUnitCategoriesNode->addAttribute("key",intToStr(iterMap->first), mapTagReplacements); + mapAIBehaviorUnitCategoriesNode->addAttribute("unitType",item.first->getName(), mapTagReplacements); + mapAIBehaviorUnitCategoriesNode->addAttribute("count",intToStr(item.second), mapTagReplacements); + } + } +// std::vector vctAIBehaviorUpgrades; + for(unsigned int i = 0; i < vctAIBehaviorUpgrades.size(); ++i) { + vctAIBehaviorUpgrades[i]->saveGame(factionTypeNode); + } +} + }}//end namespace diff --git a/source/glest_game/types/faction_type.h b/source/glest_game/types/faction_type.h index f41ccd052..0b2d1736a 100644 --- a/source/glest_game/types/faction_type.h +++ b/source/glest_game/types/faction_type.h @@ -90,6 +90,8 @@ public: void deletePixels(); bool factionUsesResourceType(const ResourceType *rt) const; + + void saveGame(XmlNode *rootNode); }; }}//end namespace diff --git a/source/glest_game/types/resource_type.cpp b/source/glest_game/types/resource_type.cpp index 3253c806a..17b6bf091 100644 --- a/source/glest_game/types/resource_type.cpp +++ b/source/glest_game/types/resource_type.cpp @@ -199,4 +199,34 @@ void ResourceType::deletePixels() { } } +void ResourceType::saveGame(XmlNode *rootNode) { + DisplayableType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *resourceTypeNode = rootNode->addChild("ResourceType"); + +// ResourceClass resourceClass; + resourceTypeNode->addAttribute("resourceClass",intToStr(resourceClass), mapTagReplacements); +// int tilesetObject; //used only if class==rcTileset + resourceTypeNode->addAttribute("tilesetObject",intToStr(tilesetObject), mapTagReplacements); +// int resourceNumber; //used only if class==rcTech, resource number in the map + resourceTypeNode->addAttribute("resourceNumber",intToStr(resourceNumber), mapTagReplacements); +// int interval; //used only if class==rcConsumable + resourceTypeNode->addAttribute("interval",intToStr(interval), mapTagReplacements); +// int defResPerPatch; //used only if class==rcTileset || class==rcTech + resourceTypeNode->addAttribute("defResPerPatch",intToStr(defResPerPatch), mapTagReplacements); +// bool recoup_cost; + resourceTypeNode->addAttribute("recoup_cost",intToStr(recoup_cost), mapTagReplacements); +// +// Model *model; + if(model != NULL) { + resourceTypeNode->addAttribute("model",model->getFileName(), mapTagReplacements); + } +// ObjectParticleSystemTypes particleTypes; + for(unsigned int i = 0; i < particleTypes.size(); ++i) { + ObjectParticleSystemType *opst = particleTypes[i]; + opst->saveGame(resourceTypeNode); + } +} + }}//end namespace diff --git a/source/glest_game/types/resource_type.h b/source/glest_game/types/resource_type.h index 1ea03992f..d3647eeff 100644 --- a/source/glest_game/types/resource_type.h +++ b/source/glest_game/types/resource_type.h @@ -72,6 +72,8 @@ public: static ResourceClass strToRc(const string &s); void deletePixels(); + + void saveGame(XmlNode *rootNode); }; }} //end namespace diff --git a/source/glest_game/types/skill_type.cpp b/source/glest_game/types/skill_type.cpp index 218099fc1..8d0836d3c 100644 --- a/source/glest_game/types/skill_type.cpp +++ b/source/glest_game/types/skill_type.cpp @@ -205,6 +205,41 @@ string AttackBoost::getDesc() const{ return ""; } +void AttackBoost::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *attackBoostNode = rootNode->addChild("AttackBoost"); + +// bool enabled; + attackBoostNode->addAttribute("enabled",intToStr(enabled), mapTagReplacements); +// bool allowMultipleBoosts; + attackBoostNode->addAttribute("allowMultipleBoosts",intToStr(allowMultipleBoosts), mapTagReplacements); +// int radius; + attackBoostNode->addAttribute("radius",intToStr(radius), mapTagReplacements); +// AttackBoostTargetType targetType; + attackBoostNode->addAttribute("targetType",intToStr(targetType), mapTagReplacements); +// vector boostUnitList; + for(unsigned int i = 0; i < boostUnitList.size(); ++i) { + const UnitType *ut = boostUnitList[i]; + XmlNode *unitTypeNode = attackBoostNode->addChild("UnitType"); + unitTypeNode->addAttribute("name",ut->getName(), mapTagReplacements); + } +// UpgradeTypeBase boostUpgrade; + boostUpgrade.saveGame(attackBoostNode); +// UnitParticleSystemType *unitParticleSystemTypeForSourceUnit; + if(unitParticleSystemTypeForSourceUnit != NULL) { + unitParticleSystemTypeForSourceUnit->saveGame(attackBoostNode); + } +// UnitParticleSystemType *unitParticleSystemTypeForAffectedUnit; + if(unitParticleSystemTypeForAffectedUnit != NULL) { + unitParticleSystemTypeForAffectedUnit->saveGame(attackBoostNode); + } + +// bool includeSelf; + attackBoostNode->addAttribute("includeSelf",intToStr(includeSelf), mapTagReplacements); +// string name; + attackBoostNode->addAttribute("name",name, mapTagReplacements); +} + // ===================================================== // class SkillType // ===================================================== @@ -546,6 +581,41 @@ string SkillType::fieldToStr(Field field){ }; } +void SkillType::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *skillTypeNode = rootNode->addChild("SkillType"); + +// SkillClass skillClass; + skillTypeNode->addAttribute("skillClass",intToStr(skillClass), mapTagReplacements); +// string name; + skillTypeNode->addAttribute("name",name, mapTagReplacements); +// int mpCost; + skillTypeNode->addAttribute("mpCost",intToStr(mpCost), mapTagReplacements); +// int hpCost; + skillTypeNode->addAttribute("hpCost",intToStr(hpCost), mapTagReplacements); +// int speed; + skillTypeNode->addAttribute("speed",intToStr(speed), mapTagReplacements); +// int animSpeed; + skillTypeNode->addAttribute("animSpeed",intToStr(animSpeed), mapTagReplacements); +// int animationRandomCycleMaxcount; + skillTypeNode->addAttribute("animationRandomCycleMaxcount",intToStr(animationRandomCycleMaxcount), mapTagReplacements); +// vector animations; +// vector animationAttributes; +// +// SoundContainer sounds; +// float soundStartTime; + skillTypeNode->addAttribute("soundStartTime",floatToStr(soundStartTime), mapTagReplacements); +// RandomGen random; + skillTypeNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); +// AttackBoost attackBoost; + attackBoost.saveGame(skillTypeNode); +// static int nextAttackBoostId; + skillTypeNode->addAttribute("nextAttackBoostId",intToStr(nextAttackBoostId), mapTagReplacements); +// UnitParticleSystemTypes unitParticleSystemTypes; + for(UnitParticleSystemTypes::iterator it = unitParticleSystemTypes.begin(); it != unitParticleSystemTypes.end(); ++it) { + (*it)->saveGame(skillTypeNode); + } +} // ===================================================== // class StopSkillType @@ -732,6 +802,52 @@ int AttackSkillType::getTotalAttackRange(const TotalUpgrade *totalUpgrade) const return result; } +void AttackSkillType::saveGame(XmlNode *rootNode) { + SkillType::saveGame(rootNode); + std::map mapTagReplacements; + XmlNode *attackSkillTypeNode = rootNode->addChild("AttackSkillType"); + +// int attackStrength; + attackSkillTypeNode->addAttribute("attackStrength",intToStr(attackStrength), mapTagReplacements); +// int attackVar; + attackSkillTypeNode->addAttribute("attackVar",intToStr(attackVar), mapTagReplacements); +// int attackRange; + attackSkillTypeNode->addAttribute("attackRange",intToStr(attackRange), mapTagReplacements); +// const AttackType *attackType; + if(attackType != NULL) { + attackSkillTypeNode->addAttribute("attackType",attackType->getName(), mapTagReplacements); + } +// bool attackFields[fieldCount]; + for(unsigned int i = 0; i < fieldCount; ++i) { + XmlNode *attackFieldsNode = attackSkillTypeNode->addChild("attackFields"); + attackFieldsNode->addAttribute("key",intToStr(i), mapTagReplacements); + attackFieldsNode->addAttribute("value",intToStr(attackFields[i]), mapTagReplacements); + } +// float attackStartTime; + attackSkillTypeNode->addAttribute("attackStartTime",floatToStr(attackStartTime), mapTagReplacements); +// string spawnUnit; + attackSkillTypeNode->addAttribute("spawnUnit",spawnUnit, mapTagReplacements); +// int spawnUnitcount; + attackSkillTypeNode->addAttribute("spawnUnitcount",intToStr(spawnUnitcount), mapTagReplacements); +// bool projectile; + attackSkillTypeNode->addAttribute("projectile",intToStr(projectile), mapTagReplacements); +// ParticleSystemTypeProjectile* projectileParticleSystemType; + if(projectileParticleSystemType != NULL) { + projectileParticleSystemType->saveGame(attackSkillTypeNode); + } +// SoundContainer projSounds; +// +// bool splash; + attackSkillTypeNode->addAttribute("splash",intToStr(splash), mapTagReplacements); +// int splashRadius; + attackSkillTypeNode->addAttribute("splashRadius",intToStr(splashRadius), mapTagReplacements); +// bool splashDamageAll; + attackSkillTypeNode->addAttribute("splashDamageAll",intToStr(splashDamageAll), mapTagReplacements); +// ParticleSystemTypeSplash* splashParticleSystemType; + if(splashParticleSystemType != NULL) { + splashParticleSystemType->saveGame(attackSkillTypeNode); + } +} // ===================================================== // class BuildSkillType // ===================================================== @@ -802,6 +918,13 @@ int ProduceSkillType::getTotalSpeed(const TotalUpgrade *totalUpgrade) const{ return result; } +void ProduceSkillType::saveGame(XmlNode *rootNode) { + SkillType::saveGame(rootNode); + std::map mapTagReplacements; + XmlNode *produceSkillTypeNode = rootNode->addChild("ProduceSkillType"); + + produceSkillTypeNode->addAttribute("animProgressBound",intToStr(animProgressBound), mapTagReplacements); +} // ===================================================== // class UpgradeSkillType // ===================================================== @@ -835,6 +958,14 @@ int UpgradeSkillType::getTotalSpeed(const TotalUpgrade *totalUpgrade) const{ return result; } +void UpgradeSkillType::saveGame(XmlNode *rootNode) { + SkillType::saveGame(rootNode); + std::map mapTagReplacements; + XmlNode *upgradeSkillTypeNode = rootNode->addChild("UpgradeSkillType"); + + upgradeSkillTypeNode->addAttribute("animProgressBound",intToStr(animProgressBound), mapTagReplacements); +} + // ===================================================== // class BeBuiltSkillType // ===================================================== @@ -866,6 +997,14 @@ string BeBuiltSkillType::toString() const{ return "Be built"; } +void BeBuiltSkillType::saveGame(XmlNode *rootNode) { + SkillType::saveGame(rootNode); + std::map mapTagReplacements; + XmlNode *beBuiltSkillTypeNode = rootNode->addChild("BeBuiltSkillType"); + + beBuiltSkillTypeNode->addAttribute("animProgressBound",intToStr(animProgressBound), mapTagReplacements); +} + // ===================================================== // class MorphSkillType // ===================================================== @@ -899,6 +1038,14 @@ int MorphSkillType::getTotalSpeed(const TotalUpgrade *totalUpgrade) const{ return result; } +void MorphSkillType::saveGame(XmlNode *rootNode) { + SkillType::saveGame(rootNode); + std::map mapTagReplacements; + XmlNode *morphSkillTypeNode = rootNode->addChild("MorphSkillType"); + + morphSkillTypeNode->addAttribute("animProgressBound",intToStr(animProgressBound), mapTagReplacements); +} + // ===================================================== // class DieSkillType // ===================================================== @@ -921,6 +1068,14 @@ string DieSkillType::toString() const{ return "Die"; } +void DieSkillType::saveGame(XmlNode *rootNode) { + SkillType::saveGame(rootNode); + std::map mapTagReplacements; + XmlNode *dieSkillTypeNode = rootNode->addChild("DieSkillType"); + + dieSkillTypeNode->addAttribute("fade",intToStr(fade), mapTagReplacements); +} + // ===================================================== // class SkillTypeFactory // ===================================================== diff --git a/source/glest_game/types/skill_type.h b/source/glest_game/types/skill_type.h index 6205ade82..e06cf2be8 100644 --- a/source/glest_game/types/skill_type.h +++ b/source/glest_game/types/skill_type.h @@ -101,6 +101,8 @@ public: bool isAffected(const Unit *source, const Unit *dest) const; virtual string getDesc() const; + + virtual void saveGame(XmlNode *rootNode) const; }; class AnimationAttributes { @@ -178,6 +180,8 @@ public: static string skillClassToStr(SkillClass skillClass); static string fieldToStr(Field field); virtual string getBoostDesc() const {return attackBoost.getDesc();} + + virtual void saveGame(XmlNode *rootNode); }; // =============================== @@ -258,6 +262,8 @@ public: //misc int getTotalAttackStrength(const TotalUpgrade *totalUpgrade) const; int getTotalAttackRange(const TotalUpgrade *totalUpgrade) const; + + virtual void saveGame(XmlNode *rootNode); }; @@ -308,6 +314,8 @@ public: virtual string toString() const; virtual int getTotalSpeed(const TotalUpgrade *totalUpgrade) const; + + virtual void saveGame(XmlNode *rootNode); }; // =============================== @@ -327,6 +335,8 @@ public: virtual string toString() const; virtual int getTotalSpeed(const TotalUpgrade *totalUpgrade) const; + + virtual void saveGame(XmlNode *rootNode); }; @@ -346,6 +356,8 @@ public: const FactionType *ft, std::map > > &loadedFileList, string parentLoader); virtual string toString() const; + + virtual void saveGame(XmlNode *rootNode); }; // =============================== @@ -366,6 +378,8 @@ public: virtual string toString() const; virtual int getTotalSpeed(const TotalUpgrade *totalUpgrade) const; + + virtual void saveGame(XmlNode *rootNode); }; // =============================== @@ -384,6 +398,8 @@ public: const FactionType *ft, std::map > > &loadedFileList, string parentLoader); virtual string toString() const; + + virtual void saveGame(XmlNode *rootNode); }; // =============================== diff --git a/source/glest_game/types/tech_tree.cpp b/source/glest_game/types/tech_tree.cpp index 69cdf63d2..5c5b13083 100644 --- a/source/glest_game/types/tech_tree.cpp +++ b/source/glest_game/types/tech_tree.cpp @@ -370,4 +370,48 @@ float TechTree::getDamageMultiplier(const AttackType *att, const ArmorType *art) return damageMultiplierTable.getDamageMultiplier(att, art); } +void TechTree::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *techTreeNode = rootNode->addChild("TechTree"); + +// string name; + techTreeNode->addAttribute("name",name, mapTagReplacements); +// //string desc; +// string treePath; + techTreeNode->addAttribute("treePath",treePath, mapTagReplacements); +// vector pathList; + for(unsigned int i = 0; i < pathList.size(); ++i) { + XmlNode *pathListNode = techTreeNode->addChild("pathList"); + pathListNode->addAttribute("value",pathList[i], mapTagReplacements); + } +// ResourceTypes resourceTypes; + for(unsigned int i = 0; i < resourceTypes.size(); ++i) { + ResourceType &rt = resourceTypes[i]; + rt.saveGame(techTreeNode); + } +// FactionTypes factionTypes; + for(unsigned int i = 0; i < factionTypes.size(); ++i) { + FactionType &ft = factionTypes[i]; + ft.saveGame(techTreeNode); + } + +// ArmorTypes armorTypes; + for(unsigned int i = 0; i < armorTypes.size(); ++i) { + ArmorType &at = armorTypes[i]; + at.saveGame(techTreeNode); + } + +// AttackTypes attackTypes; + for(unsigned int i = 0; i < attackTypes.size(); ++i) { + AttackType &at = attackTypes[i]; + at.saveGame(techTreeNode); + } + +// DamageMultiplierTable damageMultiplierTable; + damageMultiplierTable.saveGame(techTreeNode); + +// Checksum checksumValue; + techTreeNode->addAttribute("checksumValue",intToStr(checksumValue.getSum()), mapTagReplacements); +} + }}//end namespace diff --git a/source/glest_game/types/tech_tree.h b/source/glest_game/types/tech_tree.h index f4f9300b2..c05c59db2 100644 --- a/source/glest_game/types/tech_tree.h +++ b/source/glest_game/types/tech_tree.h @@ -81,6 +81,9 @@ public: float getDamageMultiplier(const AttackType *att, const ArmorType *art) const; std::vector validateFactionTypes(); std::vector validateResourceTypes(); + + void saveGame(XmlNode *rootNode); + }; }} //end namespace diff --git a/source/glest_game/types/unit_type.cpp b/source/glest_game/types/unit_type.cpp index bac4caab1..88868e9bc 100644 --- a/source/glest_game/types/unit_type.cpp +++ b/source/glest_game/types/unit_type.cpp @@ -42,6 +42,13 @@ void Level::init(string name, int kills){ this->kills= kills; } +void Level::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *levelNode = rootNode->addChild("Level"); + + levelNode->addAttribute("name",name, mapTagReplacements); + levelNode->addAttribute("kills",intToStr(kills), mapTagReplacements); +} // ===================================================== // class UnitType // ===================================================== diff --git a/source/glest_game/types/unit_type.h b/source/glest_game/types/unit_type.h index 715eac71f..a6af33237 100644 --- a/source/glest_game/types/unit_type.h +++ b/source/glest_game/types/unit_type.h @@ -53,6 +53,8 @@ public: const string &getName() const {return name;} int getKills() const {return kills;} + + void saveGame(XmlNode *rootNode) const ; }; // =============================== diff --git a/source/glest_game/types/upgrade_type.cpp b/source/glest_game/types/upgrade_type.cpp index d96d8f36d..e01a4b46e 100644 --- a/source/glest_game/types/upgrade_type.cpp +++ b/source/glest_game/types/upgrade_type.cpp @@ -274,6 +274,102 @@ string UpgradeTypeBase::getDesc() const{ return str; } +void UpgradeTypeBase::saveGame(XmlNode *rootNode) const { + std::map mapTagReplacements; + XmlNode *upgradeTypeBaseNode = rootNode->addChild("UpgradeTypeBase"); + +// int maxHp; + upgradeTypeBaseNode->addAttribute("maxHp",intToStr(maxHp), mapTagReplacements); +// bool maxHpIsMultiplier; + upgradeTypeBaseNode->addAttribute("maxHpIsMultiplier",intToStr(maxHpIsMultiplier), mapTagReplacements); +// int maxHpRegeneration; + upgradeTypeBaseNode->addAttribute("maxHpRegeneration",intToStr(maxHpRegeneration), mapTagReplacements); +// //bool maxHpRegenerationIsMultiplier; +// +// int sight; + upgradeTypeBaseNode->addAttribute("sight",intToStr(sight), mapTagReplacements); +// bool sightIsMultiplier; + upgradeTypeBaseNode->addAttribute("sightIsMultiplier",intToStr(sightIsMultiplier), mapTagReplacements); +// int maxEp; + upgradeTypeBaseNode->addAttribute("maxEp",intToStr(maxEp), mapTagReplacements); +// bool maxEpIsMultiplier; + upgradeTypeBaseNode->addAttribute("maxEpIsMultiplier",intToStr(maxEpIsMultiplier), mapTagReplacements); +// int maxEpRegeneration; + upgradeTypeBaseNode->addAttribute("maxEpRegeneration",intToStr(maxEpRegeneration), mapTagReplacements); +// //bool maxEpRegenerationIsMultiplier; +// int armor; + upgradeTypeBaseNode->addAttribute("armor",intToStr(armor), mapTagReplacements); +// bool armorIsMultiplier; + upgradeTypeBaseNode->addAttribute("armorIsMultiplier",intToStr(armorIsMultiplier), mapTagReplacements); +// int attackStrength; + upgradeTypeBaseNode->addAttribute("attackStrength",intToStr(attackStrength), mapTagReplacements); +// bool attackStrengthIsMultiplier; + upgradeTypeBaseNode->addAttribute("attackStrengthIsMultiplier",intToStr(attackStrengthIsMultiplier), mapTagReplacements); +// std::map attackStrengthMultiplierValueList; + for(std::map::const_iterator iterMap = attackStrengthMultiplierValueList.begin(); + iterMap != attackStrengthMultiplierValueList.end(); ++iterMap) { + XmlNode *attackStrengthMultiplierValueListNode = upgradeTypeBaseNode->addChild("attackStrengthMultiplierValueList"); + + attackStrengthMultiplierValueListNode->addAttribute("key",iterMap->first, mapTagReplacements); + attackStrengthMultiplierValueListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } +// int attackRange; + upgradeTypeBaseNode->addAttribute("attackRange",intToStr(attackRange), mapTagReplacements); +// bool attackRangeIsMultiplier; + upgradeTypeBaseNode->addAttribute("attackRangeIsMultiplier",intToStr(attackRangeIsMultiplier), mapTagReplacements); +// std::map attackRangeMultiplierValueList; + for(std::map::const_iterator iterMap = attackRangeMultiplierValueList.begin(); + iterMap != attackRangeMultiplierValueList.end(); ++iterMap) { + XmlNode *attackRangeMultiplierValueListNode = upgradeTypeBaseNode->addChild("attackRangeMultiplierValueList"); + + attackRangeMultiplierValueListNode->addAttribute("key",iterMap->first, mapTagReplacements); + attackRangeMultiplierValueListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } + +// int moveSpeed; + upgradeTypeBaseNode->addAttribute("moveSpeed",intToStr(moveSpeed), mapTagReplacements); +// bool moveSpeedIsMultiplier; + upgradeTypeBaseNode->addAttribute("moveSpeedIsMultiplier",intToStr(moveSpeedIsMultiplier), mapTagReplacements); +// std::map moveSpeedIsMultiplierValueList; + for(std::map::const_iterator iterMap = moveSpeedIsMultiplierValueList.begin(); + iterMap != moveSpeedIsMultiplierValueList.end(); ++iterMap) { + XmlNode *moveSpeedIsMultiplierValueListNode = upgradeTypeBaseNode->addChild("moveSpeedIsMultiplierValueList"); + + moveSpeedIsMultiplierValueListNode->addAttribute("key",iterMap->first, mapTagReplacements); + moveSpeedIsMultiplierValueListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } + +// int prodSpeed; + upgradeTypeBaseNode->addAttribute("prodSpeed",intToStr(prodSpeed), mapTagReplacements); +// bool prodSpeedIsMultiplier; + upgradeTypeBaseNode->addAttribute("prodSpeedIsMultiplier",intToStr(prodSpeedIsMultiplier), mapTagReplacements); +// std::map prodSpeedProduceIsMultiplierValueList; + for(std::map::const_iterator iterMap = prodSpeedProduceIsMultiplierValueList.begin(); + iterMap != prodSpeedProduceIsMultiplierValueList.end(); ++iterMap) { + XmlNode *prodSpeedProduceIsMultiplierValueListNode = upgradeTypeBaseNode->addChild("prodSpeedProduceIsMultiplierValueList"); + + prodSpeedProduceIsMultiplierValueListNode->addAttribute("key",iterMap->first, mapTagReplacements); + prodSpeedProduceIsMultiplierValueListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } + +// std::map prodSpeedUpgradeIsMultiplierValueList; + for(std::map::const_iterator iterMap = prodSpeedUpgradeIsMultiplierValueList.begin(); + iterMap != prodSpeedUpgradeIsMultiplierValueList.end(); ++iterMap) { + XmlNode *prodSpeedUpgradeIsMultiplierValueListNode = upgradeTypeBaseNode->addChild("prodSpeedUpgradeIsMultiplierValueList"); + + prodSpeedUpgradeIsMultiplierValueListNode->addAttribute("key",iterMap->first, mapTagReplacements); + prodSpeedUpgradeIsMultiplierValueListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } + +// std::map prodSpeedMorphIsMultiplierValueList; + for(std::map::const_iterator iterMap = prodSpeedMorphIsMultiplierValueList.begin(); + iterMap != prodSpeedMorphIsMultiplierValueList.end(); ++iterMap) { + XmlNode *prodSpeedMorphIsMultiplierValueListNode = upgradeTypeBaseNode->addChild("prodSpeedMorphIsMultiplierValueList"); + + prodSpeedMorphIsMultiplierValueListNode->addAttribute("key",iterMap->first, mapTagReplacements); + prodSpeedMorphIsMultiplierValueListNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } +} // ==================== misc ==================== @@ -476,6 +572,22 @@ bool UpgradeType::isAffected(const UnitType *unitType) const{ return find(effects.begin(), effects.end(), unitType)!=effects.end(); } +void UpgradeType::saveGame(XmlNode *rootNode) const { + UpgradeTypeBase::saveGame(rootNode); + ProducibleType::saveGame(rootNode); + + std::map mapTagReplacements; + XmlNode *upgradeTypeNode = rootNode->addChild("UpgradeType"); + + //upgradeTypeNode->addAttribute("maxHp",intToStr(maxHp), mapTagReplacements); + //vector effects; + for(unsigned int i = 0; i < effects.size(); ++i) { + XmlNode *unitTypeNode = rootNode->addChild("UnitType"); + + const UnitType *ut = effects[i]; + unitTypeNode->addAttribute("name",ut->getName(), mapTagReplacements); + } +} // =============================== // class TotalUpgrade @@ -759,4 +871,5 @@ void TotalUpgrade::incLevel(const UnitType *ut) { armor += ut->getArmor()*50/100; } + }}//end namespace diff --git a/source/glest_game/types/upgrade_type.h b/source/glest_game/types/upgrade_type.h index 16498cb63..12d329e6f 100644 --- a/source/glest_game/types/upgrade_type.h +++ b/source/glest_game/types/upgrade_type.h @@ -131,6 +131,8 @@ public: return result; } + + virtual void saveGame(XmlNode *rootNode) const; }; // =============================== @@ -154,6 +156,8 @@ public: //other methods virtual string getReqDesc() const; + + virtual void saveGame(XmlNode *rootNode) const; }; // =============================== diff --git a/source/glest_game/world/map.cpp b/source/glest_game/world/map.cpp index 8ad2ba049..c7a12ad4f 100644 --- a/source/glest_game/world/map.cpp +++ b/source/glest_game/world/map.cpp @@ -243,6 +243,8 @@ Checksum Map::load(const string &path, TechTree *techTree, Tileset *tileset) { FILE *f = fopen(path.c_str(), "rb"); #endif if(f != NULL) { + mapFile = path; + mapChecksum.addFile(path); checksumValue.addFile(path); //read header diff --git a/source/glest_game/world/map.h b/source/glest_game/world/map.h index a8f3a1adb..fa9768440 100644 --- a/source/glest_game/world/map.h +++ b/source/glest_game/world/map.h @@ -171,6 +171,7 @@ private: Vec2i *startLocations; Checksum checksumValue; float maxMapHeight; + string mapFile; private: Map(Map&); @@ -263,6 +264,8 @@ public: bool isAproxFreeCellOrMightBeFreeSoon(Vec2i originPos,const Vec2i &pos, Field field, int teamIndex) const; bool aproxCanMoveSoon(const Unit *unit, const Vec2i &pos1, const Vec2i &pos2) const; + string getMapFile() const { return mapFile; } + private: //compute void smoothSurface(Tileset *tileset); diff --git a/source/glest_game/world/tileset.cpp b/source/glest_game/world/tileset.cpp index f4cb7f8ba..8caf7d776 100644 --- a/source/glest_game/world/tileset.cpp +++ b/source/glest_game/world/tileset.cpp @@ -143,6 +143,7 @@ void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetCheck if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); string name= lastDir(dir); + tileset_name = name; string currentPath = dir; endPathWithSlash(currentPath); string path= currentPath + name + ".xml"; diff --git a/source/glest_game/world/tileset.h b/source/glest_game/world/tileset.h index 323d8fffe..2d21f2878 100644 --- a/source/glest_game/world/tileset.h +++ b/source/glest_game/world/tileset.h @@ -141,6 +141,8 @@ private: AmbientSounds ambientSounds; Checksum checksumValue; + string tileset_name; + public: Tileset() { waterTex = NULL; @@ -178,6 +180,8 @@ public: //sounds AmbientSounds *getAmbientSounds() {return &ambientSounds;} + + string getName() const { return tileset_name; } }; }} //end namespace diff --git a/source/glest_game/world/time_flow.cpp b/source/glest_game/world/time_flow.cpp index 8287f92e9..dd312f83b 100644 --- a/source/glest_game/world/time_flow.cpp +++ b/source/glest_game/world/time_flow.cpp @@ -15,6 +15,7 @@ #include "config.h" #include "game_constants.h" #include "util.h" +#include "conversion.h" #include "leak_dumper.h" using namespace Shared::Util; @@ -125,5 +126,19 @@ Vec3f TimeFlow::computeLightColor() const { return color; } +void TimeFlow::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *timeflowNode = rootNode->addChild("TimeFlow"); + + timeflowNode->addAttribute("firstTime",intToStr(firstTime), mapTagReplacements); +// bool firstTime; +// Tileset *tileset; +// float time; + timeflowNode->addAttribute("time",intToStr(time), mapTagReplacements); +// float lastTime; + timeflowNode->addAttribute("lastTime",intToStr(lastTime), mapTagReplacements); +// float timeInc; + timeflowNode->addAttribute("timeInc",intToStr(timeInc), mapTagReplacements); +} }}//end namespace diff --git a/source/glest_game/world/time_flow.h b/source/glest_game/world/time_flow.h index 5090d3a3d..2ed3d699b 100644 --- a/source/glest_game/world/time_flow.h +++ b/source/glest_game/world/time_flow.h @@ -59,6 +59,9 @@ public: Vec3f computeLightColor() const; void update(); + + void saveGame(XmlNode *rootNode); + private: //bool isAproxTime(float time) const; }; diff --git a/source/glest_game/world/unit_updater.cpp b/source/glest_game/world/unit_updater.cpp index e9675b14c..cde34e1b1 100644 --- a/source/glest_game/world/unit_updater.cpp +++ b/source/glest_game/world/unit_updater.cpp @@ -2575,6 +2575,31 @@ string UnitUpdater::getUnitRangeCellsLookupItemCacheStats() { result = szBuf; return result; } + +void UnitUpdater::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *unitupdaterNode = rootNode->addChild("UnitUpdater"); + +// const GameCamera *gameCamera; +// Gui *gui; +// Map *map; +// World *world; +// Console *console; +// ScriptManager *scriptManager; +// PathFinder *pathFinder; + pathFinder->saveGame(unitupdaterNode); +// RoutePlanner *routePlanner; +// Game *game; +// RandomGen random; + unitupdaterNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); +// float attackWarnRange; + unitupdaterNode->addAttribute("attackWarnRange",floatToStr(attackWarnRange), mapTagReplacements); +// AttackWarnings attackWarnings; +// +// Mutex mutexUnitRangeCellsLookupItemCache; +// std::map > > UnitRangeCellsLookupItemCache; +} + // ===================================================== // class ParticleDamager // ===================================================== @@ -2604,4 +2629,20 @@ void ParticleDamager::update(ParticleSystem *particleSystem) { delete this; } +void ParticleDamager::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *particleDamagerNode = rootNode->addChild("ParticleDamager"); + +// UnitReference attackerRef; + attackerRef.saveGame(particleDamagerNode); + +// const AttackSkillType* ast; +// UnitUpdater *unitUpdater; +// const GameCamera *gameCamera; +// Vec2i targetPos; + particleDamagerNode->addAttribute("targetPos",targetPos.getString(), mapTagReplacements); +// Field targetField; + particleDamagerNode->addAttribute("targetField",intToStr(targetField), mapTagReplacements); +} + }}//end namespace diff --git a/source/glest_game/world/unit_updater.h b/source/glest_game/world/unit_updater.h index 181d2a199..8e5fafeea 100644 --- a/source/glest_game/world/unit_updater.h +++ b/source/glest_game/world/unit_updater.h @@ -128,6 +128,8 @@ public: string getUnitRangeCellsLookupItemCacheStats(); + void saveGame(XmlNode *rootNode); + private: //attack void hit(Unit *attacker); @@ -166,6 +168,7 @@ public: public: ParticleDamager(Unit *attacker, UnitUpdater *unitUpdater, const GameCamera *gameCamera); virtual void update(ParticleSystem *particleSystem); + virtual void saveGame(XmlNode *rootNode); }; }}//end namespace diff --git a/source/glest_game/world/world.cpp b/source/glest_game/world/world.cpp index f04f2a22c..7533aa72c 100644 --- a/source/glest_game/world/world.cpp +++ b/source/glest_game/world/world.cpp @@ -1984,7 +1984,94 @@ std::string World::DumpWorldToLog(bool consoleBasicInfoOnly) const { } #endif } + + //printf("Check savegame\n"); + if(this->game != NULL) { + //printf("Saving...\n"); + this->game->saveGame(GameConstants::saveGameFileDefault); + } + return debugWorldLogFile; } +void World::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *worldNode = rootNode->addChild("World"); + +// Map map; + worldNode->addAttribute("map",extractFileFromDirectoryPath(map.getMapFile()), mapTagReplacements); +// Tileset tileset; + worldNode->addAttribute("tileset",tileset.getName(), mapTagReplacements); +// //TechTree techTree; +// TechTree *techTree; + if(techTree != NULL) { + techTree->saveGame(worldNode); + } + worldNode->addAttribute("techTree",techTree->getName(), mapTagReplacements); +// TimeFlow timeFlow; + timeFlow.saveGame(worldNode); +// Scenario scenario; +// +// UnitUpdater unitUpdater; + unitUpdater.saveGame(worldNode); +// WaterEffects waterEffects; +// WaterEffects attackEffects; // onMiniMap +// Minimap minimap; +// Stats stats; //BattleEnd will delete this object + stats.saveGame(worldNode); +// +// Factions factions; + for(unsigned int i = 0; i < factions.size(); ++i) { + factions[i]->saveGame(worldNode); + } +// RandomGen random; + worldNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); +// ScriptManager* scriptManager; +// Cartographer *cartographer; +// RoutePlanner *routePlanner; +// +// int thisFactionIndex; + worldNode->addAttribute("thisFactionIndex",intToStr(thisFactionIndex), mapTagReplacements); +// int thisTeamIndex; + worldNode->addAttribute("thisTeamIndex",intToStr(thisTeamIndex), mapTagReplacements); +// int frameCount; + worldNode->addAttribute("frameCount",intToStr(frameCount), mapTagReplacements); +// //int nextUnitId; +// Mutex mutexFactionNextUnitId; +// std::map mapFactionNextUnitId; + for(std::map::iterator iterMap = mapFactionNextUnitId.begin(); + iterMap != mapFactionNextUnitId.end(); ++iterMap) { + XmlNode *factionNextUnitIdNode = worldNode->addChild("FactionNextUnitId"); + + factionNextUnitIdNode->addAttribute("key",intToStr(iterMap->first), mapTagReplacements); + factionNextUnitIdNode->addAttribute("value",intToStr(iterMap->second), mapTagReplacements); + } +// //config +// bool fogOfWarOverride; + worldNode->addAttribute("fogOfWarOverride",intToStr(fogOfWarOverride), mapTagReplacements); +// bool fogOfWar; + worldNode->addAttribute("fogOfWar",intToStr(fogOfWar), mapTagReplacements); +// int fogOfWarSmoothingFrameSkip; + worldNode->addAttribute("fogOfWarSmoothingFrameSkip",intToStr(fogOfWarSmoothingFrameSkip), mapTagReplacements); +// bool fogOfWarSmoothing; + worldNode->addAttribute("fogOfWarSmoothing",intToStr(fogOfWarSmoothing), mapTagReplacements); +// Game *game; +// Chrono chronoPerfTimer; +// bool perfTimerEnabled; +// +// bool unitParticlesEnabled; + worldNode->addAttribute("unitParticlesEnabled",intToStr(unitParticlesEnabled), mapTagReplacements); +// bool staggeredFactionUpdates; + worldNode->addAttribute("staggeredFactionUpdates",intToStr(staggeredFactionUpdates), mapTagReplacements); +// std::map staticSoundList; +// std::map streamSoundList; +// +// uint32 nextCommandGroupId; + worldNode->addAttribute("nextCommandGroupId",intToStr(nextCommandGroupId), mapTagReplacements); +// string queuedScenarioName; + worldNode->addAttribute("queuedScenarioName",queuedScenarioName, mapTagReplacements); +// bool queuedScenarioKeepFactions; + worldNode->addAttribute("queuedScenarioKeepFactions",intToStr(queuedScenarioKeepFactions), mapTagReplacements); +} + }}//end namespace diff --git a/source/glest_game/world/world.h b/source/glest_game/world/world.h index 036006aca..33fb82855 100644 --- a/source/glest_game/world/world.h +++ b/source/glest_game/world/world.h @@ -267,6 +267,8 @@ public: string getFowAlphaCellsLookupItemCacheStats(); string getAllFactionsCacheStats(); + void saveGame(XmlNode *rootNode); + private: void initCells(bool fogOfWar); diff --git a/source/shared_lib/include/graphics/particle.h b/source/shared_lib/include/graphics/particle.h index 201483e19..f1a9be9d4 100644 --- a/source/shared_lib/include/graphics/particle.h +++ b/source/shared_lib/include/graphics/particle.h @@ -18,10 +18,12 @@ #include "pixmap.h" #include "texture_manager.h" #include "randomgen.h" +#include "xml_parser.h" #include "leak_dumper.h" using std::list; using Shared::Util::RandomGen; +using Shared::Xml::XmlNode; namespace Shared{ namespace Graphics{ @@ -64,6 +66,8 @@ public: Vec4f getColor() const {return color;} float getSize() const {return size;} int getEnergy() const {return energy;} + + void saveGame(XmlNode *rootNode); }; // ===================================================== @@ -74,6 +78,7 @@ class ParticleObserver{ public: virtual ~ParticleObserver(){}; virtual void update(ParticleSystem *particleSystem)= 0; + virtual void saveGame(XmlNode *rootNode) = 0; }; // ===================================================== @@ -186,6 +191,8 @@ public: virtual int getChildCount() { return 0; } virtual ParticleSystem* getChild(int i); + void saveGame(XmlNode *rootNode); + protected: //protected Particle *createParticle(); diff --git a/source/shared_lib/include/util/randomgen.h b/source/shared_lib/include/util/randomgen.h index 19521e7b0..634864557 100644 --- a/source/shared_lib/include/util/randomgen.h +++ b/source/shared_lib/include/util/randomgen.h @@ -39,6 +39,9 @@ public: int rand(); int randRange(int min, int max); float randRange(float min, float max); + + int getLastNumber() const { return lastNumber; } + void setLastNumber(int value) { lastNumber = value; } }; }}//end namespace diff --git a/source/shared_lib/sources/graphics/md5/Md5Model.cpp b/source/shared_lib/sources/graphics/md5/Md5Model.cpp index 2c952e070..7e1d7fdeb 100644 --- a/source/shared_lib/sources/graphics/md5/Md5Model.cpp +++ b/source/shared_lib/sources/graphics/md5/Md5Model.cpp @@ -1915,12 +1915,20 @@ void Md5Object::render () const { //glRotatef( -90.0, 1.0, 0.0, 0.0 ); //glRotatef( -90.0, 0.0, 0.0, 1.0 ); //glTranslatef( 0.0f, -60.0f, 0.0f ); - glRotatef( -20.0, 1.0, 0.0, 0.0 ); - glRotatef( -20.0, 0.0, 1.0, 0.0 ); + + //!glRotatef( -20.0, 1.0, 0.0, 0.0 ); + //!glRotatef( -20.0, 0.0, 1.0, 0.0 ); + //glRotatef( 50.0, 1.0, 0.0, 0.0 ); //glTranslatef( 5.0f, -2.0f, -3.0f ); - glTranslatef(-1.4f, -1.4f, -7.5f); - glScalef(1/4.0f, 1/4.0f, 1); + + //!glTranslatef(-1.4f, -1.4f, -7.5f); + + //glRotatef( 90.0, 0.0, 0.0, 1.0 ); + //glRotatef( -25.0, 0.0, 1.0, 0.0 ); + + //glRotatef( -20.0, 1.0, 0.0, 0.0 ); + //glScalef(1.0/20.0f, 1.0/20.0f, 1.0f); if (!_softwareTransformation) { glMultMatrixf (_modelView._m); diff --git a/source/shared_lib/sources/graphics/particle.cpp b/source/shared_lib/sources/graphics/particle.cpp index 1ecf6b838..21988abdf 100644 --- a/source/shared_lib/sources/graphics/particle.cpp +++ b/source/shared_lib/sources/graphics/particle.cpp @@ -20,6 +20,7 @@ #include "particle_renderer.h" #include "math_util.h" #include "platform_common.h" +#include "conversion.h" #include "leak_dumper.h" using namespace std; @@ -36,6 +37,27 @@ namespace Graphics { const bool checkMemory = false; static map memoryObjectList; +void Particle::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *particleNode = rootNode->addChild("Particle"); + +// Vec3f pos; + particleNode->addAttribute("pos",pos.getString(), mapTagReplacements); +// Vec3f lastPos; + particleNode->addAttribute("lastPos",lastPos.getString(), mapTagReplacements); +// Vec3f speed; + particleNode->addAttribute("speed",speed.getString(), mapTagReplacements); +// Vec3f accel; + particleNode->addAttribute("accel",accel.getString(), mapTagReplacements); +// Vec4f color; + particleNode->addAttribute("color",color.getString(), mapTagReplacements); +// float size; + particleNode->addAttribute("size",floatToStr(size), mapTagReplacements); +// int energy; + particleNode->addAttribute("energy",intToStr(energy), mapTagReplacements); + +} + ParticleSystem::ParticleSystem(int particleCount) { if(checkMemory) { printf("++ Create ParticleSystem [%p]\n",this); @@ -213,6 +235,65 @@ void ParticleSystem::setVisible(bool visible){ getChild(i)->setVisible(visible); } +void ParticleSystem::saveGame(XmlNode *rootNode) { + std::map mapTagReplacements; + XmlNode *particleSystemNode = rootNode->addChild("ParticleSystem"); + +// std::vector particles; + for(unsigned int i = 0; i < particles.size(); ++i) { + Particle &particle = particles[i]; + particle.saveGame(particleSystemNode); + } +// RandomGen random; + particleSystemNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements); + +// BlendMode blendMode; + particleSystemNode->addAttribute("blendMode",intToStr(blendMode), mapTagReplacements); +// State state; + particleSystemNode->addAttribute("state",intToStr(state), mapTagReplacements); +// bool active; + particleSystemNode->addAttribute("active",intToStr(active), mapTagReplacements); +// bool visible; + particleSystemNode->addAttribute("visible",intToStr(visible), mapTagReplacements); +// int aliveParticleCount; + particleSystemNode->addAttribute("aliveParticleCount",intToStr(aliveParticleCount), mapTagReplacements); +// int particleCount; + particleSystemNode->addAttribute("particleCount",intToStr(particleCount), mapTagReplacements); +// +// Texture *texture; +// Vec3f pos; + particleSystemNode->addAttribute("pos",pos.getString(), mapTagReplacements); +// Vec4f color; + particleSystemNode->addAttribute("color",color.getString(), mapTagReplacements); +// Vec4f colorNoEnergy; + particleSystemNode->addAttribute("colorNoEnergy",colorNoEnergy.getString(), mapTagReplacements); +// float emissionRate; + particleSystemNode->addAttribute("emissionRate",floatToStr(emissionRate), mapTagReplacements); +// float emissionState; + particleSystemNode->addAttribute("emissionState",floatToStr(emissionState), mapTagReplacements); +// int maxParticleEnergy; + particleSystemNode->addAttribute("maxParticleEnergy",intToStr(maxParticleEnergy), mapTagReplacements); +// int varParticleEnergy; + particleSystemNode->addAttribute("varParticleEnergy",intToStr(varParticleEnergy), mapTagReplacements); +// float particleSize; + particleSystemNode->addAttribute("particleSize",floatToStr(particleSize), mapTagReplacements); +// float speed; + particleSystemNode->addAttribute("speed",floatToStr(speed), mapTagReplacements); +// Vec3f factionColor; + particleSystemNode->addAttribute("factionColor",factionColor.getString(), mapTagReplacements); +// bool teamcolorNoEnergy; + particleSystemNode->addAttribute("teamcolorNoEnergy",intToStr(teamcolorNoEnergy), mapTagReplacements); +// bool teamcolorEnergy; + particleSystemNode->addAttribute("teamcolorEnergy",intToStr(teamcolorEnergy), mapTagReplacements); +// int alternations; + particleSystemNode->addAttribute("alternations",intToStr(alternations), mapTagReplacements); +// int particleSystemStartDelay; + particleSystemNode->addAttribute("particleSystemStartDelay",intToStr(particleSystemStartDelay), mapTagReplacements); +// ParticleObserver *particleObserver; + if(particleObserver != NULL) { + particleObserver->saveGame(particleSystemNode); + } +} // =============== MISC ========================= void ParticleSystem::fade(){ if(particleObserver != NULL){ diff --git a/source/shared_lib/sources/xml/xml_parser.cpp b/source/shared_lib/sources/xml/xml_parser.cpp index 3a2bf0c74..3b733b074 100644 --- a/source/shared_lib/sources/xml/xml_parser.cpp +++ b/source/shared_lib/sources/xml/xml_parser.cpp @@ -147,6 +147,16 @@ void XmlIo::save(const string &path, const XmlNode *node){ XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *document= implementation->createDocument(0, str, 0); DOMElement *documentElement= document->getDocumentElement(); + for(unsigned int i = 0; i < node->getAttributeCount() ; ++i){ + XmlAttribute *attr = node->getAttribute(i); + + XMLCh strName[strSize]; + XMLString::transcode(attr->getName().c_str(), strName, strSize-1); + XMLCh strValue[strSize]; + XMLString::transcode(attr->getValue("",false).c_str(), strValue, strSize-1); + + documentElement->setAttribute(strName,strValue); + } for(unsigned int i=0; igetChildCount(); ++i){ documentElement->appendChild(node->getChild(i)->buildElement(document));