Fix multiple profiles

Store profile directory in profile as m_sProfileID and use that as key
for maps in scoreman

Author: nico-abram

src/Profile.cpp

@@ -871,7 +871,7 @@ void Profile::LoadTypeFromDir(const RString &dir)
 
 void Profile::CalculateStatsFromScores(LoadingWindow* ld) {
 	LOG->Trace("Calculating stats from scores");
-	vector<HighScore*> all = SCOREMAN->GetAllScores();
+	const vector<HighScore*>& all = SCOREMAN->GetAllProfileScores(m_sProfileID);
 	float TotalGameplaySeconds = 0.f;
 	m_iTotalTapsAndHolds = 0;
 	m_iTotalHolds = 0;
@@ -893,14 +893,14 @@ void Profile::CalculateStatsFromScores(LoadingWindow* ld) {
 	m_iTotalDancePoints = m_iTotalTapsAndHolds * 2;
 	m_iTotalGameplaySeconds = static_cast<int>(TotalGameplaySeconds);
 
-	SCOREMAN->RecalculateSSRs(ld);
-	SCOREMAN->CalcPlayerRating(m_fPlayerRating, m_fPlayerSkillsets);
+	SCOREMAN->RecalculateSSRs(ld, m_sProfileID);
+	SCOREMAN->CalcPlayerRating(m_fPlayerRating, m_fPlayerSkillsets, m_sProfileID);
 	//SCOREMAN->RatingOverTime();
 }
 
 void Profile::CalculateStatsFromScores() {
 	LOG->Trace("Calculating stats from scores");
-	vector<HighScore*> all = SCOREMAN->GetAllScores();
+	const vector<HighScore*> all = SCOREMAN->GetAllProfileScores(m_sProfileID);
 	float TotalGameplaySeconds = 0.f;
 	m_iTotalTapsAndHolds = 0;
 	m_iTotalHolds = 0;
@@ -922,8 +922,8 @@ void Profile::CalculateStatsFromScores() {
 	m_iTotalDancePoints = m_iTotalTapsAndHolds * 2;
 	m_iTotalGameplaySeconds = static_cast<int>(TotalGameplaySeconds);
 
-	SCOREMAN->RecalculateSSRs(NULL);
-	SCOREMAN->CalcPlayerRating(m_fPlayerRating, m_fPlayerSkillsets);
+	SCOREMAN->RecalculateSSRs(NULL, m_sProfileID);
+	SCOREMAN->CalcPlayerRating(m_fPlayerRating, m_fPlayerSkillsets, m_sProfileID);
 }
 
 bool Profile::SaveAllToDir( const RString &sDir, bool bSignData ) const
@@ -1076,7 +1076,7 @@ void Profile::ImportScoresToEtterna() {
 					HighScore hs = hsv[i];
 					// ignore historic key and just load from here since the hashing function was changed anyway
 					hs.SetChartKey(ck);
-					SCOREMAN->ImportScore(hs);
+					SCOREMAN->ImportScore(hs, m_sProfileID);
 					++loaded;
 				}
 				continue;
@@ -1150,7 +1150,7 @@ void Profile::ImportScoresToEtterna() {
 								if (matched) {
 									ck = steps->GetChartKey();
 									loaded++;
-									SCOREMAN->ImportScore(tmp);
+									SCOREMAN->ImportScore(tmp, m_sProfileID);
 								}
 							}
 						}
@@ -1176,6 +1176,7 @@ void Profile::ImportScoresToEtterna() {
 }
 
 
+
 // more future goalman stuff
 void Profile::CreateGoal(const string& ck) {
 	ScoreGoal goal;

src/Profile.h

@@ -190,6 +190,8 @@ class Profile
 	// Editable data
 	RString m_sDisplayName;
 	RString m_sCharacterID;
+	//Dont edit this. Should be unique (Is it?)
+	RString m_sProfileID;
 	/**
 	 * @brief The last used name for high scoring purposes.
 	 *

src/ProfileManager.cpp

@@ -331,6 +331,7 @@ void ProfileManager::RefreshLocalProfilesFromDisk(LoadingWindow* ld)
 	{
 		DirAndProfile derp;
 		derp.sDir= *id + "/";
+		derp.profile.m_sProfileID = derp.sDir;
 		derp.profile.LoadTypeFromDir(derp.sDir);
 		map<ProfileType, vector<DirAndProfile> >::iterator category=
 			categorized_profiles.find(derp.profile.m_Type);
@@ -431,6 +432,7 @@ bool ProfileManager::CreateLocalProfile( const RString &sName, RString &sProfile
 	Profile *pProfile = new Profile;
 	pProfile->m_sDisplayName = sName;
 	pProfile->m_sCharacterID = CHARMAN->GetRandomCharacter()->m_sCharacterID;
+	pProfile->m_sProfileID = profile_id;
 
 	// Save it to disk.
 	RString sProfileDir = LocalProfileIDToDir(profile_id);

src/ScoreManager.cpp

@@ -41,7 +41,7 @@ ScoresAtRate::ScoresAtRate() {
 	noccPBptr = nullptr;
 }
 
-void ScoresAtRate::AddScore(HighScore& hs) {
+HighScore* ScoresAtRate::AddScore(HighScore& hs) {
 	const string& key = hs.GetScoreKey();
 	bestGrade = min(hs.GetWifeGrade(), bestGrade);
 	scores.emplace(key, hs);
@@ -56,6 +56,7 @@ void ScoresAtRate::AddScore(HighScore& hs) {
 
 	SCOREMAN->RegisterScore(&scores.find(key)->second);
 	SCOREMAN->AddToKeyedIndex(&scores.find(key)->second);
+	return &(scores.find(key)->second);
 }
 
 vector<string> ScoresAtRate::GetSortedKeys() {
@@ -92,34 +93,55 @@ void ScoreManager::PurgeScores() {
 	pscores.clear();
 }
 
-void ScoreManager::RatingOverTime() {
+void ScoreManager::PurgeProfileScores(const string& profileID) {
+	TopSSRs.clear();
+	TopSSRs.shrink_to_fit();
+	for (auto& score : AllProfileScores[profileID]) {
+		{
+			auto& it = find(AllScores.begin(), AllScores.end(), score);
+			if (it != AllScores.end())
+				AllScores.erase(it);
+		}
+		auto& it = ScoresByKey.find(score->GetChartKey());
+		if (it != ScoresByKey.end())
+			ScoresByKey.erase(it);
+	}
+	AllScores.shrink_to_fit();
+	AllProfileScores[profileID].clear();
+	AllProfileScores[profileID].shrink_to_fit();
+
+	pscores[profileID].clear();
+}
+
+void ScoreManager::RatingOverTime(const string& profileID) {
 	auto compdate = [](HighScore* a, HighScore* b) { return (a->GetDateTime() < b->GetDateTime()); };
 
+	auto& scores = AllProfileScores[profileID];
 
 	vector<bool> wasvalid;
-	sort(AllScores.begin(), AllScores.end(), compdate);
+	sort(scores.begin(), scores.end(), compdate);
 
-	for (auto& n : AllScores) {
+	for (auto& n : scores) {
 		wasvalid.push_back(n->GetEtternaValid());
 		n->SetEtternaValid(false);
 	}
 
 	float doot = 10.f;
 	float doot2[8];
 	LOG->Warn("wer");
-	if (AllScores.empty())
+	if (scores.empty())
 		return;
 
-	DateTime lastvalidday = AllScores.front()->GetDateTime();
+	DateTime lastvalidday = AllProfileScores[profileID].front()->GetDateTime();
 	lastvalidday.StripTime();
 
-	CalcPlayerRating(doot, doot2);
+	CalcPlayerRating(doot, doot2, profileID);
 	LOG->Warn(lastvalidday.GetString());
 
-	DateTime finalvalidday = AllScores.back()->GetDateTime();
+	DateTime finalvalidday = scores.back()->GetDateTime();
 	finalvalidday.StripTime();
 	while (lastvalidday != finalvalidday) {
-		for (auto& n : AllScores) {
+		for (auto& n : scores) {
 			DateTime date = n->GetDateTime();
 			date.StripTime();
 
@@ -130,7 +152,7 @@ void ScoreManager::RatingOverTime() {
 
 			n->SetEtternaValid(true);
 		}
-		CalcPlayerRating(doot, doot2);
+		CalcPlayerRating(doot, doot2, profileID);
 		LOG->Trace("%f", doot);
 	}
 }
@@ -156,15 +178,16 @@ HighScore* ScoresForChart::GetPBUpTo(float& rate) {
 	return NULL;
 }
 
-void ScoresForChart::AddScore(HighScore& hs) {
+HighScore* ScoresForChart::AddScore(HighScore& hs) {
 	bestGrade = min(hs.GetWifeGrade(), bestGrade);
 
 	float rate = hs.GetMusicRate();
 	int key = RateToKey(rate);
-	ScoresByRate[key].AddScore(hs);
+	auto hsPtr = ScoresByRate[key].AddScore(hs);
 	// ok let's try this --lurker
 	SetTopScores();
-	hs.SetTopScore(ScoresByRate[key].scores[hs.GetScoreKey()].GetTopScore());
+	hs.SetTopScore(hsPtr->GetTopScore());
+	return hsPtr;
 }
 
 vector<float> ScoresForChart::GetPlayedRates() {
@@ -235,30 +258,32 @@ vector<HighScore*> ScoresForChart::GetAllPBPtrs() {
 	return o;
 }
 
-vector<vector<HighScore*>> ScoreManager::GetAllPBPtrs() {
+vector<vector<HighScore*>> ScoreManager::GetAllPBPtrs(const string& profileID ) {
 	vector<vector<HighScore*>> vec;
-	FOREACHUM(string, ScoresForChart, pscores, i) {
+	FOREACHUM(string, ScoresForChart, pscores[profileID], i) {
 		if (!SONGMAN->IsChartLoaded(i->first))
 			continue;
 		vec.emplace_back(i->second.GetAllPBPtrs());
 	}
 	return vec;
 }
 
-HighScore* ScoreManager::GetChartPBAt(const string& ck, float& rate) {
+
+HighScore* ScoreManager::GetChartPBAt(const string& ck, float& rate, const string& profileID) {
 	if (pscores.count(ck))
-		return pscores.at(ck).GetPBAt(rate);
+		return pscores[profileID].at(ck).GetPBAt(rate);
 	return NULL;
 }
 
-HighScore* ScoreManager::GetChartPBUpTo(const string& ck, float& rate) {
+HighScore* ScoreManager::GetChartPBUpTo(const string& ck, float& rate, const string& profileID) {
 	if (pscores.count(ck))
-		return pscores.at(ck).GetPBUpTo(rate);
+		return pscores[profileID].at(ck).GetPBUpTo(rate);
 	return NULL;
 }
 
-void ScoreManager::SetAllTopScores() { 
-	FOREACHUM(string, ScoresForChart, pscores, i) {
+
+void ScoreManager::SetAllTopScores(const string& profileID) {
+	FOREACHUM(string, ScoresForChart, pscores[profileID], i) {
 		if (!SONGMAN->IsChartLoaded(i->first))
 			continue;
 		i->second.SetTopScores();
@@ -285,24 +310,25 @@ bool ScoresAtRate::HandleNoCCPB(HighScore& hs) {
 	return false;
 }
 static const float ld_update = 0.02f;
-void ScoreManager::RecalculateSSRs(LoadingWindow *ld) {
+void ScoreManager::RecalculateSSRs(LoadingWindow *ld, const string& profileID) {
 	RageTimer ld_timer;
+	auto& scores = AllProfileScores[profileID];
 	if (ld) {
 		ld_timer.Touch();
 		ld->SetIndeterminate(false);
-		ld->SetTotalWork(AllScores.size());
+		ld->SetTotalWork(scores.size());
 		ld->SetText("Updating SSR Calculations for Scores...");
 	}
 
 	int scoreindex = 0;
-	for(size_t i = 0; i < AllScores.size(); ++i) {
+	for(size_t i = 0; i < scores.size(); ++i) {
 		if (ld && ld_timer.Ago() > ld_update) {
 			ld_timer.Touch();
 			ld->SetProgress(scoreindex);
 		}
 		++scoreindex;
 
-		HighScore* hs = AllScores[i];
+		HighScore* hs = scores[i];
 		if (hs->GetSSRCalcVersion() == GetCalcVersion())
 			continue;
 
@@ -371,16 +397,16 @@ void ScoreManager::EnableAllScores() {
 	return;
 }
 
-void ScoreManager::CalcPlayerRating(float& prating, float* pskillsets) {
-	SetAllTopScores();
+void ScoreManager::CalcPlayerRating(float& prating, float* pskillsets, const string& profileID) {
+	SetAllTopScores(profileID);
 
 	vector<float> skillz;
 	FOREACH_ENUM(Skillset, ss) {
 		// actually skip overall, and jack stamina for now
 		if (ss == Skill_Overall)
 			continue;
 
-		SortTopSSRPtrs(ss);
+		SortTopSSRPtrs(ss, profileID);
 		pskillsets[ss] = AggregateSSRs(ss, 0.f, 10.24f, 1) * 1.04f;
 		CLAMP(pskillsets[ss], 0.f, 100.f);
 		skillz.push_back (pskillsets[ss]);
@@ -411,9 +437,9 @@ float ScoreManager::AggregateSSRs(Skillset ss, float rating, float res, int iter
 	return AggregateSSRs(ss, rating - res, res / 2.f, iter + 1);
 }
 
-void ScoreManager::SortTopSSRPtrs(Skillset ss) {
+void ScoreManager::SortTopSSRPtrs(Skillset ss, const string& profileID) {
 	TopSSRs.clear();
-	FOREACHUM(string, ScoresForChart, pscores, i) {
+	FOREACHUM(string, ScoresForChart, pscores[profileID], i) {
 		if (!SONGMAN->IsChartLoaded(i->first))
 			continue;
 		vector<HighScore*> pbs = i->second.GetAllPBPtrs();
@@ -436,18 +462,20 @@ HighScore* ScoreManager::GetTopSSRHighScore(unsigned int rank, int ss) {
 	return NULL;
 }
 
-void ScoreManager::ImportScore(const HighScore& hs_) {
+void ScoreManager::ImportScore(const HighScore& hs_, const string& profileID) {
 	HighScore hs = hs_;
 
 	// don't import duplicated scores
 	// this may have strange ramifications - mina
 	// actually i'll just disable this for the time being and give myself time to test it later
 	//if(!ScoresByKey.count(hs.GetScoreKey()))
 
-	pscores[hs.GetChartKey()].AddScore(hs);
+	RegisterScoreInProfile(pscores[profileID][hs.GetChartKey()].AddScore(hs), profileID);
 }
 
-
+void ScoreManager::RegisterScoreInProfile(HighScore* hs_, const string& profileID) {
+	AllProfileScores[profileID].emplace_back(hs_);
+}
 
 
 
@@ -497,9 +525,9 @@ XNode * ScoresForChart::CreateNode(const string& ck) const {
 	return o;
 }
 
-XNode * ScoreManager::CreateNode() const {
+XNode * ScoreManager::CreateNode(const string& profileID) const {
 	XNode* o = new XNode("PlayerScores");
-	FOREACHUM_CONST(string, ScoresForChart, pscores, ch) {
+	FOREACHUM_CONST(string, ScoresForChart, pscores.find(profileID)->second, ch) {
 		auto node = ch->second.CreateNode(ch->first);
 		if (!node->ChildrenEmpty())
 			o->AppendChild(node);
@@ -510,7 +538,7 @@ XNode * ScoreManager::CreateNode() const {
 
 
 // Read scores from xml
-void ScoresAtRate::LoadFromNode(const XNode* node, const string& ck, const float& rate) {
+void ScoresAtRate::LoadFromNode(const XNode* node, const string& ck, const float& rate, const string& profileID) {
 	RString sk;
 	FOREACH_CONST_Child(node, p) {
 		p->GetAttrValue("Key", sk);
@@ -537,10 +565,11 @@ void ScoresAtRate::LoadFromNode(const XNode* node, const string& ck, const float
 		// Very awkward, need to figure this out better so there isn't unnecessary redundancy between loading and adding
 		SCOREMAN->RegisterScore(&scores.find(sk)->second);
 		SCOREMAN->AddToKeyedIndex(&scores.find(sk)->second);
+		SCOREMAN->RegisterScoreInProfile(&scores.find(sk)->second, profileID);
 	}
 }
 
-void ScoresForChart::LoadFromNode(const XNode* node, const string& ck) {
+void ScoresForChart::LoadFromNode(const XNode* node, const string& ck, const string& profileID) {
 	RString rs = "";
 	int rate;
 
@@ -558,19 +587,19 @@ void ScoresForChart::LoadFromNode(const XNode* node, const string& ck) {
 		ASSERT(p->GetName() == "ScoresAt");
 		p->GetAttrValue("Rate", rs);
 		rate = 10 * StringToInt(rs.substr(0, 1) + rs.substr(2, 4));
-		ScoresByRate[rate].LoadFromNode(p, ck, KeyToRate(rate));
+		ScoresByRate[rate].LoadFromNode(p, ck, KeyToRate(rate), profileID);
 		bestGrade = min(ScoresByRate[rate].bestGrade, bestGrade);
 	}
 }
 
-void ScoreManager::LoadFromNode(const XNode * node) {
+void ScoreManager::LoadFromNode(const XNode * node, const string& profileID) {
 	FOREACH_CONST_Child(node, p) {
 		//ASSERT(p->GetName() == "Chart");
 		RString tmp;
 		p->GetAttrValue("Key", tmp);
 		string doot = SONGMAN->ReconcileBustedKeys(tmp);
 		const string ck = doot;
-		pscores[ck].LoadFromNode(p, ck);
+		pscores[profileID][ck].LoadFromNode(p, ck, profileID);
 	}
 }
 
@@ -583,9 +612,9 @@ ScoresAtRate* ScoresForChart::GetScoresAtRate(const int& rate) {
 	return NULL;
 }
 
-ScoresForChart* ScoreManager::GetScoresForChart(const string& ck) {
-	auto it = pscores.find(ck);
-	if (it != pscores.end())
+ScoresForChart* ScoreManager::GetScoresForChart(const string& ck, const string& profileID) {
+	auto it = (pscores[profileID]).find(ck);
+	if (it != (pscores[profileID]).end())
 		return &it->second;
 	return NULL;
 }