XNode* TapNote::CreateNode() const
{
XNode *p = new XNode( "TapNote" );
p->AppendChild( result.CreateNode() );
p->AppendChild( HoldResult.CreateNode() );
return p;
}
XNode* HighScoreList::CreateNode() const
{
XNode* pNode = new XNode( "HighScoreList" );
pNode->AppendChild( "NumTimesPlayed", iNumTimesPlayed );
pNode->AppendChild( "LastPlayed", dtLastPlayed.GetString() );
if( HighGrade != Grade_NoData )
pNode->AppendChild( "HighGrade", GradeToString(HighGrade) );
for( unsigned i=0; i<vHighScores.size(); i++ )
{
const HighScore &hs = vHighScores[i];
pNode->AppendChild( hs.CreateNode() );
}
return pNode;
}
bool Profile::SaveAllToDir( CString sDir, bool bSignData ) const
{
m_sLastPlayedMachineGuid = PROFILEMAN->GetMachineProfile()->m_sGuid;
m_LastPlayedDate = DateTime::GetNowDate();
// Save editable.xml
SaveEditableDataToDir( sDir );
// Save stats.xml
CString fn = sDir + STATS_XML;
XNode xml;
xml.name = "Stats";
xml.AppendChild( SaveGeneralDataCreateNode() );
xml.AppendChild( SaveSongScoresCreateNode() );
xml.AppendChild( SaveCourseScoresCreateNode() );
xml.AppendChild( SaveCategoryScoresCreateNode() );
xml.AppendChild( SaveScreenshotDataCreateNode() );
xml.AppendChild( SaveCalorieDataCreateNode() );
xml.AppendChild( SaveRecentSongScoresCreateNode() );
xml.AppendChild( SaveRecentCourseScoresCreateNode() );
if( IsMachine() )
xml.AppendChild( SaveCoinDataCreateNode() );
DISP_OPT opts = optDefault;
opts.stylesheet = STATS_XSL;
opts.write_tabs = false;
bool bSaved = xml.SaveToFile(fn, &opts);
// Update file cache, or else IsAFile in CryptManager won't see this new file.
FILEMAN->FlushDirCache( sDir );
if( bSaved && bSignData )
{
CString sStatsXmlSigFile = fn+SIGNATURE_APPEND;
CryptManager::SignFileToFile(fn, sStatsXmlSigFile);
// Update file cache, or else IsAFile in CryptManager won't see sStatsXmlSigFile.
FILEMAN->FlushDirCache( sDir );
// Save the "don't share" file
CString sDontShareFile = sDir + DONT_SHARE_SIG;
CryptManager::SignFileToFile(sStatsXmlSigFile, sDontShareFile);
}
SaveStatsWebPageToDir( sDir );
// Empty directories if none exist.
FILEMAN->CreateDir( sDir + EDITS_SUBDIR );
FILEMAN->CreateDir( sDir + SCREENSHOTS_SUBDIR );
return bSaved;
}
XNode* RadarValues::CreateNode( bool bIncludeSimpleValues, bool bIncludeComplexValues ) const
{
XNode* pNode = new XNode( "RadarValues" );
// TRICKY: Don't print a remainder for the integer values.
FOREACH_ENUM( RadarCategory, rc )
{
if( rc >= RadarCategory_TapsAndHolds )
{
if( bIncludeSimpleValues )
pNode->AppendChild( RadarCategoryToString(rc), (int)m_Values.f[rc] );
}
else
{
if( bIncludeComplexValues )
pNode->AppendChild( RadarCategoryToString(rc), m_Values.f[rc] );
}
}
return pNode;
}
XNode* RadarValues::CreateNode() const
{
XNode* pNode = new XNode;
pNode->m_sName = "RadarValues";
// TRICKY: Don't print a remainder for the integer values.
FOREACH_RadarCategory( rc )
{
if( rc >= RADAR_NUM_TAPS_AND_HOLDS )
{
if( WRITE_SIMPLE_VALUES )
pNode->AppendChild( RadarCategoryToString(rc), (int)m_Values.f[rc] );
}
else
{
if( WRITE_COMPLEX_VALUES )
pNode->AppendChild( RadarCategoryToString(rc), m_Values.f[rc] );
}
}
return pNode;
}
bool
PropertySet::XMLStore(XNode *pBackupNode)
{
XNode *pPropertiesNode = pBackupNode->AppendChild(_T("Properties"));
std::map<String, std::shared_ptr<Property> >::iterator iterProperty = items_.begin();
while (iterProperty != items_.end())
{
std::shared_ptr<Property> oProperty = (*iterProperty).second;
XNode *pNode = pPropertiesNode->AppendChild(String(oProperty->GetName()));
pNode->AppendAttr(_T("LongValue"), StringParser::IntToString(oProperty->GetLongValue()));
pNode->AppendAttr(_T("StringValue"), oProperty->GetStringValue());
iterProperty++;
}
return true;
}
XNode* MakeRecentScoreNode( const StageStats &ss, Trail *pTrail, const PlayerStageStats &pss, MultiPlayer mp )
{
XNode* pNode = nullptr;
if( GAMESTATE->IsCourseMode() )
{
pNode = new XNode( "HighScoreForACourseAndTrail" );
CourseID courseID;
courseID.FromCourse(GAMESTATE->m_pCurCourse );
pNode->AppendChild( courseID.CreateNode() );
TrailID trailID;
trailID.FromTrail( pTrail );
pNode->AppendChild( trailID.CreateNode() );
}
else
{
pNode = new XNode( "HighScoreForASongAndSteps" );
SongID songID;
songID.FromSong( ss.m_vpPossibleSongs[0] );
pNode->AppendChild( songID.CreateNode() );
StepsID stepsID;
stepsID.FromSteps( pss.m_vpPossibleSteps[0] );
pNode->AppendChild( stepsID.CreateNode() );
}
XNode* pHighScore = pss.m_HighScore.CreateNode();
pHighScore->AppendChild("Pad", mp);
pHighScore->AppendChild("StageGuid", GAMESTATE->m_sStageGUID);
pHighScore->AppendChild("Guid", CryptManager::GenerateRandomUUID());
pNode->AppendChild( pHighScore );
return pNode;
}
XNode *HighScoreImpl::CreateNode() const
{
XNode *pNode = new XNode( "HighScore" );
const bool bWriteSimpleValues = RadarValues::WRITE_SIMPLE_VALIES;
const bool bWriteComplexValues = RadarValues::WRITE_COMPLEX_VALIES;
// TRICKY: Don't write "name to fill in" markers.
pNode->AppendChild( "Name", IsRankingToFillIn(sName) ? RString("") : sName );
pNode->AppendChild( "Grade", GradeToString(grade) );
pNode->AppendChild( "Score", iScore );
pNode->AppendChild( "PercentDP", fPercentDP );
pNode->AppendChild( "SurviveSeconds", fSurviveSeconds );
pNode->AppendChild( "MaxCombo", iMaxCombo );
pNode->AppendChild( "StageAward", StageAwardToString(stageAward) );
pNode->AppendChild( "PeakComboAward", PeakComboAwardToString(peakComboAward) );
pNode->AppendChild( "Modifiers", sModifiers );
pNode->AppendChild( "DateTime", dateTime.GetString() );
pNode->AppendChild( "PlayerGuid", sPlayerGuid );
pNode->AppendChild( "MachineGuid", sMachineGuid );
pNode->AppendChild( "ProductID", iProductID );
XNode* pTapNoteScores = pNode->AppendChild( "TapNoteScores" );
FOREACH_ENUM( TapNoteScore, tns )
if( tns != TNS_None ) // HACK: don't save meaningless "none" count
pTapNoteScores->AppendChild( TapNoteScoreToString(tns), iTapNoteScores[tns] );
XNode* pHoldNoteScores = pNode->AppendChild( "HoldNoteScores" );
FOREACH_ENUM( HoldNoteScore, hns )
if( hns != HNS_None ) // HACK: don't save meaningless "none" count
pHoldNoteScores->AppendChild( HoldNoteScoreToString(hns), iHoldNoteScores[hns] );
pNode->AppendChild( radarValues.CreateNode(bWriteSimpleValues, bWriteComplexValues) );
pNode->AppendChild( "LifeRemainingSeconds", fLifeRemainingSeconds );
pNode->AppendChild( "Disqualified", bDisqualified);
return pNode;
}
bool
BackupExecuter::StartBackup()
{
Logger::Instance()->LogBackup("Loading backup settings....");
_LoadSettings();
// Special temp setting to skip files during backup/restore while still storing/restoring db file/message info.
bool bMessagesDBOnly = IniFileSettings::Instance()->GetBackupMessagesDBOnly();
if (m_iBackupMode & Backup::BOMessages)
{
if (!PersistentMessage::GetAllMessageFilesAreInDataFolder())
{
Application::Instance()->GetBackupManager()->OnBackupFailed("All messages are not located in the data folder.");
return false;
}
// Skip size check if DB only
if (!bMessagesDBOnly) {
// Check size of data directory and LOG it.
if (PersistentMessage::GetTotalMessageSize() > 1500)
{
Logger::Instance()->LogBackup("The size of the data directory exceeds the maximum RECOMMENDED size for the built in backup (1.5GB) so LOGGING. Please consult the backup documentation");
// Check size of data directory and STOP it.
if (PersistentMessage::GetTotalMessageSize() > 30000)
{
Application::Instance()->GetBackupManager()->OnBackupFailed("The size of the data directory exceeds the maximum size for the built in backup (30GB) so ABORTING. Please consult the backup documentation.");
return false;
}
}
}
}
if (!FileUtilities::Exists(m_sDestination))
{
Application::Instance()->GetBackupManager()->OnBackupFailed("The specified backup directory is not accessible: " + m_sDestination);
return false;
}
String sTime = Time::GetCurrentDateTime();
sTime.Replace(_T(":"), _T(""));
// Generate name for zip file. We always create zip
// file
String sZipFile;
sZipFile.Format(_T("%s\\HMBackup %s.7z"), m_sDestination, sTime);
String sXMLFile;
sXMLFile.Format(_T("%s\\hMailServerBackup.xml"), m_sDestination);
// The name of the backup directory that
// contains all the data files.
String sDataBackupDir = m_sDestination + "\\DataBackup";
// Backup all properties.
XDoc oDoc;
XNode *pBackupNode = oDoc.AppendChild(_T("Backup"));
XNode *pBackupInfoNode = pBackupNode->AppendChild(_T("BackupInformation"));
// Store backup mode
pBackupInfoNode->AppendAttr(_T("Mode"), StringParser::IntToString(m_iBackupMode));
pBackupInfoNode->AppendAttr(_T("Version"), Application::Instance()->GetVersion());
// Backup business objects
if (m_iBackupMode & Backup::BODomains)
{
Logger::Instance()->LogBackup("Backing up domains...");
if (!_BackupDomains(pBackupNode))
{
Application::Instance()->GetBackupManager()->OnBackupFailed("Could not backup domains.");
return false;
}
// Backup message files
if (m_iBackupMode & Backup::BOMessages && !bMessagesDBOnly)
{
Logger::Instance()->LogBackup("Backing up data directory...");
if (!_BackupDataDirectory(sDataBackupDir))
{
Application::Instance()->GetBackupManager()->OnBackupFailed("Could not backup data directory.");
return false;
}
}
}
// Save information in the XML file where messages can be found.
if (m_iBackupMode & Backup::BOMessages)
{
XNode *pMessageFile = pBackupInfoNode->AppendChild(_T("DataFiles"));
if (m_iBackupMode & Backup::BOCompression)
{
pMessageFile->AppendAttr(_T("Format"), _T("7z"));
pMessageFile->AppendAttr(_T("Size"), StringParser::IntToString(FileUtilities::FileSize(sZipFile)));
}
else
{
pMessageFile->AppendAttr(_T("Format"), _T("Raw"));
pMessageFile->AppendAttr(_T("FolderName"), _T("DataBackup"));
}
}
if (m_iBackupMode & Backup::BOSettings)
{
Logger::Instance()->LogBackup("Backing up settings...");
Configuration::Instance()->XMLStore(pBackupNode);
}
Logger::Instance()->LogBackup(_T("Writing XML file..."));
String sXMLData = oDoc.GetXML();
if (!FileUtilities::WriteToFile(sXMLFile, sXMLData, true))
{
Application::Instance()->GetBackupManager()->OnBackupFailed("Could not write to the XML file.");
return false;
}
// Compress the XML file
Compression oComp;
oComp.AddFile(sZipFile, sXMLFile);
// Delete the XML file
FileUtilities::DeleteFile(sXMLFile);
// Should we compress the message files?
if (m_iBackupMode & Backup::BOMessages &&
m_iBackupMode & Backup::BOCompression && !bMessagesDBOnly)
{
Logger::Instance()->LogBackup("Compressing message files...");
if (m_iBackupMode & Backup::BOMessages)
oComp.AddDirectory(sZipFile, sDataBackupDir + "\\");
// Since the files are now compressed, we can deleted
// the data backup directory
if (!FileUtilities::DeleteDirectory(sDataBackupDir))
{
Application::Instance()->GetBackupManager()->OnBackupFailed("Could not delete files from the destination directory.");
return false;
}
}
Application::Instance()->GetBackupManager()->OnBackupCompleted();
return true;
}
XNode* Profile::SaveGeneralDataCreateNode() const
{
XNode* pGeneralDataNode = new XNode;
pGeneralDataNode->name = "GeneralData";
// TRICKY: These are write-only elements that are never read again. This
// data is required by other apps (like internet ranking), but is
// redundant to the game app.
pGeneralDataNode->AppendChild( "DisplayName", GetDisplayName() );
pGeneralDataNode->AppendChild( "IsMachine", IsMachine() );
pGeneralDataNode->AppendChild( "Guid", m_sGuid );
pGeneralDataNode->AppendChild( "UsingProfileDefaultModifiers", m_bUsingProfileDefaultModifiers );
pGeneralDataNode->AppendChild( "DefaultModifiers", m_sDefaultModifiers );
pGeneralDataNode->AppendChild( "SortOrder", SortOrderToString(m_SortOrder) );
pGeneralDataNode->AppendChild( "LastDifficulty", DifficultyToString(m_LastDifficulty) );
pGeneralDataNode->AppendChild( "LastCourseDifficulty", CourseDifficultyToString(m_LastCourseDifficulty) );
pGeneralDataNode->AppendChild( m_lastSong.CreateNode() );
pGeneralDataNode->AppendChild( m_lastCourse.CreateNode() );
pGeneralDataNode->AppendChild( "TotalPlays", m_iTotalPlays );
pGeneralDataNode->AppendChild( "TotalPlaySeconds", m_iTotalPlaySeconds );
pGeneralDataNode->AppendChild( "TotalGameplaySeconds", m_iTotalGameplaySeconds );
pGeneralDataNode->AppendChild( "CurrentCombo", m_iCurrentCombo );
pGeneralDataNode->AppendChild( "TotalCaloriesBurned", m_fTotalCaloriesBurned );
pGeneralDataNode->AppendChild( "LastPlayedMachineGuid", m_sLastPlayedMachineGuid );
pGeneralDataNode->AppendChild( "LastPlayedDate", m_LastPlayedDate );
pGeneralDataNode->AppendChild( "TotalDancePoints", m_iTotalDancePoints );
pGeneralDataNode->AppendChild( "NumExtraStagesPassed", m_iNumExtraStagesPassed );
pGeneralDataNode->AppendChild( "NumExtraStagesFailed", m_iNumExtraStagesFailed );
pGeneralDataNode->AppendChild( "NumToasties", m_iNumToasties );
pGeneralDataNode->AppendChild( "TotalTapsAndHolds", m_iTotalTapsAndHolds );
pGeneralDataNode->AppendChild( "TotalJumps", m_iTotalJumps );
pGeneralDataNode->AppendChild( "TotalHolds", m_iTotalHolds );
pGeneralDataNode->AppendChild( "TotalMines", m_iTotalMines );
pGeneralDataNode->AppendChild( "TotalHands", m_iTotalHands );
// Keep declared variables in a very local scope so they aren't
// accidentally used where they're not intended. There's a lot of
// copying and pasting in this code.
{
XNode* pUnlockedSongs = pGeneralDataNode->AppendChild("UnlockedSongs");
for( set<int>::const_iterator it = m_UnlockedSongs.begin(); it != m_UnlockedSongs.end(); ++it )
pUnlockedSongs->AppendChild( ssprintf("Unlock%i", *it) );
}
{
XNode* pNumSongsPlayedByPlayMode = pGeneralDataNode->AppendChild("NumSongsPlayedByPlayMode");
FOREACH_PlayMode( pm )
{
/* Don't save unplayed PlayModes. */
if( !m_iNumSongsPlayedByPlayMode[pm] )
continue;
pNumSongsPlayedByPlayMode->AppendChild( PlayModeToString(pm), m_iNumSongsPlayedByPlayMode[pm] );
}
}
{
XNode* pNumSongsPlayedByStyle = pGeneralDataNode->AppendChild("NumSongsPlayedByStyle");
for( map<StyleID,int>::const_iterator iter = m_iNumSongsPlayedByStyle.begin();
iter != m_iNumSongsPlayedByStyle.end();
iter++ )
{
const StyleID &s = iter->first;
int iNumPlays = iter->second;
XNode *pStyleNode = s.CreateNode();
pStyleNode->SetValue( iNumPlays );
pNumSongsPlayedByStyle->AppendChild( pStyleNode );
}
}
{
XNode* pNumSongsPlayedByDifficulty = pGeneralDataNode->AppendChild("NumSongsPlayedByDifficulty");
FOREACH_Difficulty( dc )
{
if( !m_iNumSongsPlayedByDifficulty[dc] )
continue;
pNumSongsPlayedByDifficulty->AppendChild( DifficultyToString(dc), m_iNumSongsPlayedByDifficulty[dc] );
}
}
{
XNode* pNumSongsPlayedByMeter = pGeneralDataNode->AppendChild("NumSongsPlayedByMeter");
for( int i=0; i<MAX_METER+1; i++ )
{
if( !m_iNumSongsPlayedByMeter[i] )
continue;
pNumSongsPlayedByMeter->AppendChild( ssprintf("Meter%d",i), m_iNumSongsPlayedByMeter[i] );
}
}
{
XNode* pNumStagesPassedByGrade = pGeneralDataNode->AppendChild("NumStagesPassedByGrade");
FOREACH_Grade( g )
{
if( !m_iNumStagesPassedByGrade[g] )
continue;
pNumStagesPassedByGrade->AppendChild( GradeToString(g), m_iNumStagesPassedByGrade[g] );
}
}
{
XNode* pNumStagesPassedByPlayMode = pGeneralDataNode->AppendChild("NumStagesPassedByPlayMode");
FOREACH_PlayMode( pm )
{
/* Don't save unplayed PlayModes. */
if( !m_iNumStagesPassedByPlayMode[pm] )
continue;
pNumStagesPassedByPlayMode->AppendChild( PlayModeToString(pm), m_iNumStagesPassedByPlayMode[pm] );
}
}
return pGeneralDataNode;
}