private void CalculateMastery(bool refresh)
{
Progress.Reset(Snapshot.AchievementGameCount);
Progress.IsEnabled = true;
var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var masteryStats = new List <MasteryStats>();
var mostAwardedAchievements = new List <GameStatsViewModel.AchievementStats>();
var achievementIds = new List <int>(Snapshot.GamesWithAchievements);
achievementIds.Sort();
foreach (var gameId in achievementIds)
{
Progress.Label = "Processing game " + gameId;
Progress.Current++;
if (!Progress.IsEnabled)
{
break;
}
string gameName = "";
int created = Int32.MaxValue;
int consoleId = 0;
using (var stream = File.OpenRead(Path.Combine(_settings.DumpDirectory, gameId + ".json")))
{
var json = new JsonObject(stream);
var patchData = json.GetField("PatchData").ObjectValue;
var achievements = patchData.GetField("Achievements");
if (achievements.Type != JsonFieldType.ObjectArray)
{
continue;
}
if (!achievements.ObjectArrayValue.Any(a => a.GetField("Flags").IntegerValue != 5))
{
continue;
}
foreach (var achievement in achievements.ObjectArrayValue)
{
var createdValue = achievement.GetField("Created").IntegerValue.GetValueOrDefault();
if (createdValue > 0 && createdValue < created)
{
created = createdValue;
}
}
gameName = patchData.GetField("Title").StringValue;
consoleId = patchData.GetField("ConsoleID").IntegerValue.GetValueOrDefault();
}
var gameStats = new GameStatsViewModel()
{
GameId = gameId
};
Debug.WriteLine(String.Format("{0} processing {1}", DateTime.Now, gameId));
gameStats.LoadGame(refresh);
if (!gameStats.Achievements.Any())
{
continue;
}
var twentyFifthPlayers = gameStats.NumberOfPlayers * 1 / 4;
var fiftiethPlayers = gameStats.NumberOfPlayers / 2;
var seventyFifthPlayers = gameStats.NumberOfPlayers * 3 / 4;
var ninetiethPlayers = gameStats.NumberOfPlayers * 9 / 10;
var twentyFifthPercentilePoints = 0;
var fiftiethPercentilePoints = 0;
var seventyFifthPercentilePoints = 0;
var ninetiethPercentilePoints = 0;
var ninetiethPercentileAchievements = 0;
foreach (var achievement in gameStats.Achievements)
{
if (achievement.EarnedBy > twentyFifthPlayers)
{
twentyFifthPercentilePoints += achievement.Points;
if (achievement.EarnedBy >= fiftiethPlayers)
{
fiftiethPercentilePoints += achievement.Points;
if (achievement.EarnedBy >= seventyFifthPlayers)
{
seventyFifthPercentilePoints += achievement.Points;
if (achievement.EarnedBy >= ninetiethPlayers)
{
ninetiethPercentilePoints += achievement.Points;
ninetiethPercentileAchievements++;
}
}
}
}
int i = 0;
while (i < mostAwardedAchievements.Count)
{
if (achievement.EarnedBy > mostAwardedAchievements[i].EarnedBy)
{
break;
}
++i;
}
if (i < 20)
{
if (mostAwardedAchievements.Count == 20)
{
mostAwardedAchievements.RemoveAt(19);
}
achievement.Description = gameName;
mostAwardedAchievements.Insert(i, achievement);
}
}
var standardDeviation = 0.0;
var mean = 0.0;
if (gameStats.HardcoreMasteredUserCount > 0)
{
var times = new List <double>();
foreach (var user in gameStats.TopUsers)
{
if (user.PointsEarned == gameStats.TotalPoints && user.IsEstimateReliable)
{
times.Add(user.GameTime.TotalMinutes);
}
}
if (times.Count > 0)
{
mean = times.Average();
if (gameStats.HardcoreMasteredUserCountEstimated)
{
standardDeviation = StandardDeviation.CalculateFromSample(times);
}
else
{
standardDeviation = StandardDeviation.Calculate(times);
}
}
}
var minutesPerPoint = new List <float>();
foreach (var user in gameStats.TopUsers)
{
if (user.PointsEarned > 0)
{
minutesPerPoint.Add((float)user.GameTime.TotalMinutes / user.PointsEarned);
}
}
minutesPerPoint.Sort();
var stats = new MasteryStats
{
GameId = gameStats.GameId,
GameName = gameStats.DialogTitle.Substring(12).Trim(),
ConsoleId = consoleId,
Created = unixEpoch + TimeSpan.FromSeconds(created),
Points = gameStats.TotalPoints,
NumPlayers = gameStats.NumberOfPlayers,
HardcoreMasteredUserCount = gameStats.HardcoreMasteredUserCount,
MeanTimeToMaster = mean,
StdDevTimeToMaster = standardDeviation,
MinutesPerPointToMaster = mean / gameStats.TotalPoints,
MinutesPerPoint = minutesPerPoint.Count > 0 ? minutesPerPoint[minutesPerPoint.Count / 2] : 0,
TwentyFifthPercentilePoints = twentyFifthPercentilePoints,
FiftiethPercentilePoints = fiftiethPercentilePoints,
SeventyFifthPercentilePoints = seventyFifthPercentilePoints,
NintiethPercentilePoints = ninetiethPercentilePoints,
NintiethPercentileAchievements = ninetiethPercentileAchievements,
};
if (gameStats.NumberOfPlayers == 0)
{
stats.PlayersPerDay = 0.0;
}
else
{
var age = (DateTime.Now - stats.Created).TotalDays;
stats.PlayersPerDay = gameStats.NumberOfPlayers / age;
}
masteryStats.Add(stats);
}
masteryStats.Sort((l, r) =>
{
if (l.MinutesPerPoint < r.MinutesPerPoint)
{
return(-1);
}
else if (l.MinutesPerPoint > r.MinutesPerPoint)
{
return(1);
}
return(0);
});
_backgroundWorkerService.InvokeOnUiThread(() =>
{
Results.Clear();
foreach (var stats in masteryStats)
{
Results.Add(stats);
}
});
_mostAwardedAchievements = mostAwardedAchievements;
Progress.Label = String.Empty;
}
private void SaveSummary(string filename)
{
const int CountPerSection = 20;
var results = new List <MasteryStats>(Results);
results.RemoveAll(r => r.GameName.Contains("[Bonus]") || r.GameName.Contains("[Multi]") || r.GameName.EndsWith(" (Events)"));
DateTime thirtyDaysAgo = DateTime.Today - TimeSpan.FromDays(30);
DateTime now = DateTime.Now;
var cheaters = new List <CheaterInfo>();
var cheatedGames = new List <CheatedGameInfo>();
results.Sort((l, r) =>
{
if (l == null)
{
return(-1);
}
if (r == null)
{
return(1);
}
return(l.GameId - r.GameId);
});
var detailedUserMasteryInfo = new List <string>();
Progress.Label = "Analyzing data...";
Progress.Reset(results.Count);
Progress.IsEnabled = true;
foreach (var result in results)
{
++Progress.Current;
GameStatsViewModel gameStats = null;
if (!String.IsNullOrEmpty(UserMasteryDetails))
{
gameStats = new GameStatsViewModel()
{
GameId = result.GameId
};
gameStats.LoadGame();
GameStatsViewModel.UserStats userStats = null;
int userIndex = -1;
int masteredCount = 0;
foreach (var user in gameStats.TopUsers)
{
if (user.PointsEarned < gameStats.TotalPoints)
{
break;
}
if (user.User == UserMasteryDetails)
{
userIndex = masteredCount;
userStats = user;
}
masteredCount++;
}
if (userStats != null)
{
detailedUserMasteryInfo.Add(String.Format("{2,3}/{3,3} | {0,4}m/{1,4}m | {4,3}x {5,6}:{6}",
(int)userStats.GameTime.TotalMinutes, (int)result.MeanTimeToMaster,
userIndex + 1, masteredCount,
gameStats.Achievements.Count(), result.GameId, result.GameName));
}
}
if (result.HardcoreMasteredUserCount < 8 || result.Points < 50)
{
continue;
}
var threshold = result.MeanTimeToMaster / 5;
if (threshold > result.MeanTimeToMaster - result.StdDevTimeToMaster * 2)
{
continue;
}
if (gameStats == null)
{
gameStats = new GameStatsViewModel()
{
GameId = result.GameId
};
gameStats.LoadGame();
}
var usersToRefresh = new List <GameStatsViewModel.UserStats>();
CheatedGameInfo gameEntry = null;
foreach (var user in gameStats.TopUsers)
{
if (user.PointsEarned == result.Points && user.GameTime.TotalMinutes < threshold)
{
// if the user isn't averaging at least three achievements per session, the
// estimate will be off. ignore it.
if (!user.IsEstimateReliable)
{
continue;
}
// some things that appear like cheating aren't. check the exceptions list.
if (IgnoreCheater(user, result.GameId))
{
continue;
}
// if the user data contains a bunch of entries without seconds, it's old. try refreshing it
if (user.Achievements.Count(a => a.Value.Second == 0) > gameStats.Achievements.Count() / 2)
{
usersToRefresh.Add(user);
}
// add a new cheating entry for the user
var entry = cheaters.FirstOrDefault(c => c.UserName == user.User);
if (entry == null)
{
entry = new CheaterInfo()
{
UserName = user.User,
Results = new List <KeyValuePair <MasteryStats, GameStatsViewModel.UserStats> >()
};
cheaters.Add(entry);
}
entry.Results.Add(new KeyValuePair <MasteryStats, GameStatsViewModel.UserStats>(result, user));
// add a new cheating entry for the game
if (gameEntry == null)
{
gameEntry = new CheatedGameInfo()
{
Game = result,
Users = new List <GameStatsViewModel.UserStats>()
};
cheatedGames.Add(gameEntry);
}
gameEntry.Users.Add(user);
}
}
if (usersToRefresh.Count > 0)
{
gameStats.RefreshUsers(usersToRefresh);
}
}
cheaters.Sort((l, r) =>
{
int diff = (r.Results.Count - l.Results.Count);
if (diff == 0)
{
diff = String.Compare(l.UserName, r.UserName);
}
return(diff);
});
using (var file = File.CreateText(filename))
{
file.WriteLine("Games: {0,6:D}", Snapshot.GameCount);
file.WriteLine("Achievements: {0,6:D} ({1} games with achievements)", Snapshot.AchievementCount, Snapshot.AchievementGameCount);
file.WriteLine("Leaderboards: {0,6:D} ({1} games with leaderboards)", Snapshot.LeaderboardCount, Snapshot.LeaderboardGameCount);
file.WriteLine("RichPresences: {0,6:D} ({1} static)", Snapshot.RichPresenceCount, Snapshot.StaticRichPresenceCount);
file.WriteLine("Authors: {0,6:D}", Snapshot.AuthorCount);
file.WriteLine("Systems: {0,6:D}", Snapshot.SystemCount);
file.WriteLine();
file.WriteLine("Most played: MAX(Players)");
file.WriteLine("```");
results.Sort((l, r) => l.NumPlayers - r.NumPlayers);
for (int i = results.Count - 1, count = 0; count < CountPerSection; i--, count++)
{
file.WriteLine(String.Format("{0,5:D} {1}", results[i].NumPlayers, results[i].GameName));
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Least played: MIN(Players) [Players > 0, Age > 30 days]");
file.WriteLine("```");
for (int i = 0, count = 0; count < CountPerSection || results[i].NumPlayers == results[i - 1].NumPlayers; i++)
{
if (results[i].NumPlayers > 0 && results[i].Created < thirtyDaysAgo)
{
file.WriteLine(String.Format("{0,5:D} {1}", results[i].NumPlayers, results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Most Popular: MAX(Players/Day) [Age > 30 days]");
file.WriteLine("```");
results.Sort((l, r) => (int)((l.PlayersPerDay - r.PlayersPerDay) * 100000));
for (int i = results.Count - 1, count = 0; count < CountPerSection; i--)
{
if (results[i].NumPlayers > 0 && results[i].Created < thirtyDaysAgo)
{
file.WriteLine(String.Format("{0:F3} {1}", results[i].PlayersPerDay, results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Least Popular: MIN(Players/Day) [Age > 30 days]");
file.WriteLine("```");
for (int i = 0, count = 0; count < CountPerSection; i++)
{
if (results[i].NumPlayers > 0 && results[i].Created < thirtyDaysAgo)
{
file.WriteLine(String.Format("{0:F4} {1}", results[i].PlayersPerDay, results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Slowest to Master: MAX(MeanTimeToMaster) MasteryRate|MeanTimeToMaster|StdDev [Players Mastered >= 3]");
file.WriteLine("```");
results.Sort((l, r) => (int)((l.MeanTimeToMaster - r.MeanTimeToMaster) * 100000));
for (int i = results.Count - 1, count = 0; count < CountPerSection; i--)
{
if (results[i].HardcoreMasteredUserCount >= 3)
{
file.WriteLine(String.Format("{0,4:D}/{1,4:D} {2,8:F2} {3,8:F2} {4}",
results[i].HardcoreMasteredUserCount, results[i].NumPlayers,
results[i].MeanTimeToMaster, results[i].StdDevTimeToMaster,
results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Fastest to Master: MIN(MeanTimeToMaster) MasteryRate|MeanTimeToMaster|StdDev [Players Mastered >= 3, Points >= 50]");
file.WriteLine("```");
for (int i = 0, count = 0; count < CountPerSection; i++)
{
if (results[i].HardcoreMasteredUserCount >= 3 && results[i].Points >= 50 && results[i].MeanTimeToMaster > 0.0)
{
file.WriteLine(String.Format("{0,4:D}/{1,4:D} {2,8:F2} {3,8:F2} {4}",
results[i].HardcoreMasteredUserCount, results[i].NumPlayers,
results[i].MeanTimeToMaster, results[i].StdDevTimeToMaster,
results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Fastest to Master: MIN(MeanTimeToMaster) MasteryRate|MeanTimeToMaster|StdDev [Players Mastered >= 3, Points >= 400]");
file.WriteLine("```");
for (int i = 0, count = 0; count < CountPerSection; i++)
{
if (results[i].HardcoreMasteredUserCount >= 3 && results[i].Points >= 400 && results[i].MeanTimeToMaster > 0.0)
{
file.WriteLine(String.Format("{0,4:D}/{1,4:D} {2,8:F2} {3,8:F2} {4}",
results[i].HardcoreMasteredUserCount, results[i].NumPlayers,
results[i].MeanTimeToMaster, results[i].StdDevTimeToMaster,
results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Points requiring the least effort: MIN(MinutesPerPoint)|NintiethPercentilePoints|Players [>= 2 achievements earned by 90% of players, Players >= 3]");
file.WriteLine("```");
results.Sort((l, r) =>
{
if (l == null)
{
return(-1);
}
if (r == null)
{
return(1);
}
return((int)((l.MinutesPerPoint - r.MinutesPerPoint) * 100000));
});
for (int i = 0, count = 0; count < CountPerSection; i++)
{
if (results[i].NintiethPercentileAchievements >= 3 && results[i].NumPlayers >= 3)
{
file.WriteLine(String.Format("{0,6:F3} {1,4:D} {2,4:D} {3}", results[i].MinutesPerPoint, results[i].NintiethPercentilePoints, results[i].NumPlayers, results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Points requiring the most effort: MAX(MinutesPerPoint)|NintiethPercentilePoints|Players [>= 10 points earned by 90% of players, Players >= 3]");
file.WriteLine("```");
for (int i = results.Count - 1, count = 0; count < CountPerSection; i--)
{
if (results[i].NintiethPercentilePoints >= 10 && results[i].NumPlayers >= 3)
{
file.WriteLine(String.Format("{0,6:F3} {1,4:D} {2,4:D} {3}", results[i].MinutesPerPoint, results[i].NintiethPercentilePoints, results[i].NumPlayers, results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Easiest sets: MAX(NintiethPercentilePoints/Points)|Players [Players >= 10, Points >= 50]");
file.WriteLine("```");
results.Sort((l, r) =>
{
if (l == null || l.Points == 0)
{
return(-1);
}
if (r == null || r.Points == 0)
{
return(1);
}
return(((l.NintiethPercentilePoints * 10000) / l.Points) - ((r.NintiethPercentilePoints * 10000) / r.Points));
});
for (int i = results.Count - 1, count = 0; count < CountPerSection; i--)
{
if (results[i].NumPlayers >= 10 && results[i].Points >= 50)
{
file.WriteLine(String.Format("{0,4:D}/{1,4:D} {2,4:D} {3}",
results[i].NintiethPercentilePoints, results[i].Points, results[i].NumPlayers,
results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Easiest sets: MAX(NintiethPercentilePoints/Points)|Players [Players >= 10, Points >= 400]");
file.WriteLine("```");
for (int i = results.Count - 1, count = 0; count < CountPerSection; i--)
{
if (results[i].NumPlayers >= 10 && results[i].Points >= 400)
{
file.WriteLine(String.Format("{0,4:D}/{1,4:D} {2,4:D} {3}",
results[i].NintiethPercentilePoints, results[i].Points, results[i].NumPlayers,
results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Hardest sets: MIN(TwentyFifthPercentilePoints/Points)|Players [Players >= 10, TwentyFifthPercentilePoints > 0]");
file.WriteLine("```");
results.Sort((l, r) =>
{
if (l == null || l.Points == 0)
{
return(-1);
}
if (r == null || r.Points == 0)
{
return(1);
}
return((l.TwentyFifthPercentilePoints * 10000) / l.Points - (r.TwentyFifthPercentilePoints * 10000) / r.Points);
});
for (int i = 0, count = 0; count < CountPerSection; i++)
{
if (results[i].NumPlayers >= 10 && results[i].TwentyFifthPercentilePoints > 0)
{
file.WriteLine(String.Format("{0,4:D}/{1,4:D} {2,4:D} {3}",
results[i].TwentyFifthPercentilePoints, results[i].Points, results[i].NumPlayers,
results[i].GameName));
count++;
}
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Most Earned Achievements: MAX(Players)|Achievement (Game)");
file.WriteLine("```");
foreach (var achievement in _mostAwardedAchievements)
{
file.WriteLine(String.Format("{0,5:D} {1} ({2})",
achievement.EarnedBy, achievement.Title, achievement.Description));
}
file.WriteLine("```");
file.WriteLine();
file.WriteLine("Possible cheaters: TimeToMaster < 20% of median Time/Median/StdDev|LinkToComparePage [Masters >= 8, Points >= 50, TimeToMaster more than 2 stddevs from median]");
file.WriteLine();
foreach (var cheater in cheaters)
{
foreach (var kvp in cheater.Results)
{
var result = kvp.Key;
var user = kvp.Value;
file.WriteLine("* {0} mastered {1} ({2})", user.User, result.GameName, result.GameId);
file.WriteLine(" https://retroachievements.org/gamecompare.php?ID={0}&f={1}", result.GameId, user.User);
bool dumpTimes = true;
var notified = CheaterNotified(user.User, result.GameId);
if (!String.IsNullOrEmpty(notified))
{
file.WriteLine(" - notified {0}", notified);
}
if (IsUntracked(user.User))
{
file.WriteLine(" - currently Untracked");
dumpTimes = false;
}
var performance = 1.0 - (user.GameTime.TotalMinutes / result.MeanTimeToMaster);
file.WriteLine(" Time to Master: {0:F2} ({1:F2}% faster than median {2:F2}, std dev={3:F2})", user.GameTime.TotalMinutes, performance * 100, result.MeanTimeToMaster, result.StdDevTimeToMaster);
if (dumpTimes)
{
var achievements = new List <AchievementTime>();
foreach (var achievement in user.Achievements)
{
achievements.Add(new AchievementTime {
Id = achievement.Key, When = achievement.Value
});
}
achievements.Sort((l, r) => DateTime.Compare(l.When, r.When));
var gameStats = new GameStatsViewModel()
{
GameId = result.GameId
};
gameStats.LoadGame();
foreach (var achievement in achievements)
{
file.Write(" {0:D4}-{1:D2}-{2:D2} {3:D2}:{4:D2}:{5:D2} ", achievement.When.Year, achievement.When.Month, achievement.When.Day,
achievement.When.Hour, achievement.When.Minute, achievement.When.Second);
var achDef = gameStats.Achievements.FirstOrDefault(a => a.Id == achievement.Id);
if (achDef != null)
{
file.WriteLine("{0,6:D} {1}", achDef.Id, achDef.Title);
}
else
{
file.WriteLine("{0,6:D} ??????", achievement.Id);
}
}
}
file.WriteLine();
}
}
file.WriteLine();
file.WriteLine("Most cheated games: Count|ID|Name [most frequent games from previous list]");
file.WriteLine("```");
cheatedGames.Sort((l, r) =>
{
int diff = (r.Users.Count - l.Users.Count);
if (diff == 0)
{
diff = String.Compare(l.Game.GameName, r.Game.GameName);
}
return(diff);
});
for (int i = 0, count = 0; (count < CountPerSection && cheatedGames[i].Users.Count > 1) || (i > 0 && cheatedGames[i].Users.Count == cheatedGames[i - 1].Users.Count); i++)
{
file.WriteLine(String.Format("{0,2:D} {1,5:D} {2}", cheatedGames[i].Users.Count,
cheatedGames[i].Game.GameId, cheatedGames[i].Game.GameName));
}
file.WriteLine("```");
file.WriteLine();
if (!String.IsNullOrEmpty(UserMasteryDetails))
{
file.Write("Details for ");
file.WriteLine(UserMasteryDetails);
file.WriteLine(" rank | mastery | achs gameid:name");
file.WriteLine(" ------ | ----------- | -----------------------------------------------------------------------");
detailedUserMasteryInfo.Sort();
foreach (var line in detailedUserMasteryInfo)
{
file.WriteLine(line);
}
}
}
Progress.Label = String.Empty;
}
private void GameStats()
{
var vm = new GameStatsViewModel();
vm.ShowDialog();
}
