diff --git a/source/glest_game/ai/ai.cpp b/source/glest_game/ai/ai.cpp index 9e26b976..634c1d5a 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 3528d2c6..0c36a968 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 fe52011e..f50e46da 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 0741a39a..e3bd3427 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 afccc039..8cd2908a 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 5216992c..60e62343 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 4de8aa8d..3a3e8363 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 fd6e6a22..55e0cd61 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 0270ad3d..5fb14e95 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 413f8b7c..787d5df8 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 e9d0b396..494e599c 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 dffbf10c..814c91eb 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 436678bd..4aeb9ccc 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 c4082f24..1d0bda79 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 c1aebdd3..841643aa 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 6d3ecc7e..0283d9db 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 d42fe8d8..7cb480d8 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 a3e50016..4f591504 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 1829f7fe..9376b55b 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 3bd3d1c8..ec7ca4f5 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 478d3e9a..90eb251c 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 14e354bb..004ae3c5 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 ebb14212..5723227b 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 3047fa3b..4d867e76 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 982d1e57..1417b07c 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 d3fef729..009868ad 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 1fd11a5f..82d9b19d 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 518249a6..654e3b34 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 71122a9a..f7b952d2 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 2377044c..f907825a 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 c6e52e13..7417082d 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 05540590..9fa41b90 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 067b9470..0b3f0c64 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 8d495361..b24570e0 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 64dfbf84..bdc58a31 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 514a68b0..b07f9213 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 87e8531a..26e14df5 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 c0834375..46824d48 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 f1f31d50..9ffc100e 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 5d48f42f..80245ab3 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 0eca3c5d..32037363 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 f41ccd05..0b2d1736 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 3253c806..17b6bf09 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 1ea03992..d3647eef 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 218099fc..8d0836d3 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 6205ade8..e06cf2be 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 69cdf63d..5c5b1308 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 f4f9300b..c05c59db 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 bac4caab..88868e9b 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 715eac71..a6af3323 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 d96d8f36..e01a4b46 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 16498cb6..12d329e6 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 8ad2ba04..c7a12ad4 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 a8f3a1ad..fa976844 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 f4cb7f8b..8caf7d77 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 323d8fff..2d21f287 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 8287f92e..dd312f83 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 5090d3a3..2ed3d699 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 e9675b14..cde34e1b 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 181d2a19..8e5fafee 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 f04f2a22..7533aa72 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 036006ac..33fb8285 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 201483e1..f1a9be9d 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 19521e7b..63486455 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 2c952e07..7e1d7fde 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 1ecf6b83..21988abd 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 3a2bf0c7..3b733b07 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));