Start caching high-score ranks, implement GetScoresByUser DB method

Author: Toastbrot236

Refresh.Database/GameDatabaseContext.Leaderboard.cs

@@ -58,6 +58,7 @@ public GameScore SubmitScore(ISerializedScore score, GameUser user, GameLevel le
             this.GameScores.Add(newScore);
         });
 
+        this.RecalculateScoreStatistics(level.LevelId, score.ScoreType);
         this.CreateLevelScoreEvent(user, newScore);
 
         // Notify the last #1 users that they've been overtaken
@@ -101,12 +102,12 @@ public DatabaseScoreList GetTopScoresForLevel(GameLevel level, int count, int sk
             scores = scores.Where(s => s.ScoreType == scoreType);
 
         if (!showDuplicates)
-            scores = scores.DistinctBy(s => s.PublisherId);
+            scores = scores.Where(s => s.Rank != 0);
 
         if (minAge != null)
             scores = scores.Where(s => s.ScoreSubmitted >= minAge);
 
-        return new(scores.ToArray().Select((s, i) => new ScoreWithRank(s, i + 1)), skip, count, user);
+        return new(scores.ToArray().Select(s => new ScoreWithRank(s, s.Rank)), skip, count, user);
     }
 
     public DatabaseScoreList GetRankedScoresAroundScore(GameScore score, int count, GameUser? user = null)
@@ -118,13 +119,12 @@ public DatabaseScoreList GetRankedScoresAroundScore(GameScore score, int count,
         List<GameScore> scores = this.GameScoresIncluded
             .Where(s => s.ScoreType == score.ScoreType && s.LevelId == score.LevelId)
             .OrderByDescending(s => s.Score)
-            .ToArray()
-            .DistinctBy(s => s.PublisherId)
+            .Where(s => s.Rank != 0)
             .ToList();
 
         return new
         (
-            scores.Select((s, i) => new ScoreWithRank(s, i + 1)),
+            scores.Select(s => new ScoreWithRank(s, s.Rank)),
             Math.Min(scores.Count, scores.IndexOf(score) - count / 2), // center user's score around other scores
             count, user
         );
@@ -140,8 +140,7 @@ public DatabaseScoreList GetLevelTopScoresByFriends(GameUser user, GameLevel lev
         IEnumerable<GameScore> scores = this.GameScoresIncluded
             .Where(s => s.LevelId == level.LevelId)
             .OrderByDescending(s => s.Score)
-            .ToArray()
-            .DistinctBy(s => s.PublisherId)
+            .Where(s => s.Rank != 0)
             //TODO: THIS CALL IS EXTREMELY INEFFECIENT!!! once we are in postgres land, figure out a way to do this effeciently
             .Where(s => s.PlayerIds.Any(p => mutuals.Contains(p)));
 
@@ -151,7 +150,22 @@ public DatabaseScoreList GetLevelTopScoresByFriends(GameUser user, GameLevel lev
         if (minAge != null)
             scores = scores.Where(s => s.ScoreSubmitted >= minAge);
 
-        return new(scores.Select((s, i) => new ScoreWithRank(s, i + 1)), skip, count, user);
+        return new(scores.ToArray().Select(s => new ScoreWithRank(s, s.Rank)), skip, count, user);
+    }
+
+    /// <param name="scoreType">0 = don't filter by type</param>
+    /// <param name="rank">0 = show all high-scores regardless of rank</param>
+    public DatabaseList<ScoreWithRank> GetScoresByUser(GameUser user, int skip, int count, byte scoreType, int rank)
+    {
+        IQueryable<GameScore> scores = this.GameScoresIncluded
+            .Where(s => s.PublisherId == user.UserId)
+            .Where(s => s.Rank != 0)
+            .OrderBy(s => s.Rank);
+        
+        if (scoreType != 0) scores = scores.Where(s => s.ScoreType == scoreType);
+        if (rank != 0) scores = scores.Where(s => s.Rank == rank);
+        
+        return new(scores.ToArray().Select(s => new ScoreWithRank(s, s.Rank)), skip, count);
     }
 
     [Pure]

Refresh.Database/GameDatabaseContext.Statistics.cs

@@ -1,8 +1,10 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using Refresh.Common;
 using Refresh.Common.Constants;
 using Refresh.Database.Models.Comments;
 using Refresh.Database.Models.Levels;
+using Refresh.Database.Models.Levels.Scores;
 using Refresh.Database.Models.Playlists;
 using Refresh.Database.Models.Statistics;
 using Refresh.Database.Models.Users;
@@ -214,6 +216,56 @@ private void MarkLevelStatisticsDirty(GameLevel level)
     }
     #endregion
 
+    #region Level Scores
+
+    public void RecalculateScoreStatistics(int levelId, byte scoreType, bool saveChanges = true)
+    {
+        List<GameScore> scores = this.GameScores
+#if DEBUG
+            .Include(s => s.Publisher)
+#endif
+            .Where(s => s.LevelId == levelId && s.ScoreType == scoreType)
+            .OrderByDescending(s => s.Score)
+            .ToList();
+        
+        // Step 1: Reset all ranks
+        foreach (GameScore score in scores)
+        {
+            this._logger.LogDebug(RefreshContext.Database, $"Reset {score.ScoreId} ({score.Score} by {score.Publisher}) rank to 0");
+            score.Rank = 0;
+        }
+        
+        // Step 2: Assign ranks to high scores
+        // Exclude all scores which are not high scores now
+        int rank = 1;
+        int? previousScore = null;
+        foreach (GameScore score in scores.DistinctBy(s => s.PublisherId).ToList())
+        {
+            // Scores with the same value should have the same rank.
+            // Increment rank if there was a previous score and it was higher.
+            if (previousScore != null && previousScore > score.Score)
+                rank++;
+
+            score.Rank = rank;
+            this._logger.LogDebug(RefreshContext.Database, $"Set {score.ScoreId} ({score.Score} by {score.Publisher}) rank to {rank}");
+
+            previousScore = score.Score;
+        }
+
+        this.SaveChanges();
+    }
+
+    public void RecalculateScoreStatistics(GameLevel level)
+    {
+        this.RecalculateScoreStatistics(level.LevelId, 1, false);
+        this.RecalculateScoreStatistics(level.LevelId, 2, false);
+        this.RecalculateScoreStatistics(level.LevelId, 3, false);
+        this.RecalculateScoreStatistics(level.LevelId, 4, false);
+        this.SaveChanges();
+    }
+    
+    #endregion
+
     #region Users
 
     internal const int UserStatisticsVersion = 2;

Refresh.Database/Models/Levels/Scores/GameScore.cs

@@ -30,4 +30,11 @@ public partial class GameScore
     /// </summary>
     [ForeignKey(nameof(PublisherId)), Required] public GameUser Publisher { get; set; }
     [Required] public ObjectId PublisherId { get; set; }
+
+    /// <summary>
+    /// The rank of this score among all scores for the level and score type. Not stored in a separate
+    /// entity as that would add unnecessary complexity for now (this is the only stat so far).
+    /// Scores which are no longer the high score of their publisher have a rank of 0.
+    /// </summary>
+    public int Rank { get; set; }
 }

Refresh.Interfaces.APIv3/Endpoints/DataTypes/Response/Levels/ApiGameScoreResponse.cs

@@ -14,6 +14,7 @@ public class ApiGameScoreResponse : IApiResponse, IDataConvertableFrom<ApiGameSc
     public required ApiMinimalUserResponse Publisher { get; set; }
     public required DateTimeOffset ScoreSubmitted { get; set; }
     public required int Score { get; set; }
+    public required int Rank { get; set; }
     public required byte ScoreType { get; set; }
 
     public required TokenGame Game { get; set; }
@@ -32,6 +33,7 @@ public class ApiGameScoreResponse : IApiResponse, IDataConvertableFrom<ApiGameSc
             ScoreSubmitted = old.ScoreSubmitted,
             Score = old.Score,
             ScoreType = old.ScoreType,
+            Rank = old.Rank,
             Game = old.Game,
             Platform = old.Platform,
         };