Merge pull request #20200 from smoogipoo/lazer-maximum-statistics

Populate `MaximumStatistics` for scores imported into lazer

osu.Game/BackgroundBeatmapProcessor.cs

@@ -7,6 +7,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -14,6 +15,7 @@ using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 
 namespace osu.Game
@@ -23,6 +25,9 @@ namespace osu.Game
         [Resolved]
         private RulesetStore rulesetStore { get; set; } = null!;
 
+        [Resolved]
+        private ScoreManager scoreManager { get; set; } = null!;
+
         [Resolved]
         private RealmAccess realmAccess { get; set; } = null!;
 
@@ -46,6 +51,7 @@ namespace osu.Game
                 Logger.Log("Beginning background beatmap processing..");
                 checkForOutdatedStarRatings();
                 processBeatmapSetsWithMissingMetrics();
+                processScoresWithMissingStatistics();
             }).ContinueWith(t =>
             {
                 if (t.Exception?.InnerException is ObjectDisposedException)
@@ -140,5 +146,52 @@ namespace osu.Game
                 });
             }
         }
+
+        private void processScoresWithMissingStatistics()
+        {
+            HashSet<Guid> scoreIds = new HashSet<Guid>();
+
+            Logger.Log("Querying for scores to reprocess...");
+
+            realmAccess.Run(r =>
+            {
+                foreach (var score in r.All<ScoreInfo>())
+                {
+                    if (score.Statistics.Sum(kvp => kvp.Value) > 0 && score.MaximumStatistics.Sum(kvp => kvp.Value) == 0)
+                        scoreIds.Add(score.ID);
+                }
+            });
+
+            Logger.Log($"Found {scoreIds.Count} scores which require reprocessing.");
+
+            foreach (var id in scoreIds)
+            {
+                while (localUserPlayInfo?.IsPlaying.Value == true)
+                {
+                    Logger.Log("Background processing sleeping due to active gameplay...");
+                    Thread.Sleep(TimeToSleepDuringGameplay);
+                }
+
+                try
+                {
+                    var score = scoreManager.Query(s => s.ID == id);
+
+                    scoreManager.PopulateMaximumStatistics(score);
+
+                    // Can't use async overload because we're not on the update thread.
+                    // ReSharper disable once MethodHasAsyncOverload
+                    realmAccess.Write(r =>
+                    {
+                        r.Find<ScoreInfo>(id).MaximumStatisticsJson = JsonConvert.SerializeObject(score.MaximumStatistics);
+                    });
+
+                    Logger.Log($"Populated maximum statistics for score {id}");
+                }
+                catch (Exception e)
+                {
+                    Logger.Log(@$"Failed to populate maximum statistics for {id}: {e}");
+                }
+            }
+        }
     }
 }

osu.Game/Scoring/ScoreImporter.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using Newtonsoft.Json;
@@ -16,6 +17,8 @@ using osu.Game.Scoring.Legacy;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
 using Realms;
 
 namespace osu.Game.Scoring
@@ -71,6 +74,8 @@ namespace osu.Game.Scoring
             if (model.BeatmapInfo == null) throw new ArgumentNullException(nameof(model.BeatmapInfo));
             if (model.Ruleset == null) throw new ArgumentNullException(nameof(model.Ruleset));
 
+            PopulateMaximumStatistics(model);
+
             if (string.IsNullOrEmpty(model.StatisticsJson))
                 model.StatisticsJson = JsonConvert.SerializeObject(model.Statistics);
 
@@ -78,6 +83,68 @@ namespace osu.Game.Scoring
                 model.MaximumStatisticsJson = JsonConvert.SerializeObject(model.MaximumStatistics);
         }
 
+        /// <summary>
+        /// Populates the <see cref="ScoreInfo.MaximumStatistics"/> for a given <see cref="ScoreInfo"/>.
+        /// </summary>
+        /// <param name="score">The score to populate the statistics of.</param>
+        public void PopulateMaximumStatistics(ScoreInfo score)
+        {
+            if (score.MaximumStatistics.Select(kvp => kvp.Value).Sum() > 0)
+                return;
+
+            var beatmap = score.BeatmapInfo.Detach();
+            var ruleset = score.Ruleset.Detach();
+            var rulesetInstance = ruleset.CreateInstance();
+
+            Debug.Assert(rulesetInstance != null);
+
+            // Populate the maximum statistics.
+            HitResult maxBasicResult = rulesetInstance.GetHitResults()
+                                                      .Select(h => h.result)
+                                                      .Where(h => h.IsBasic())
+                                                      .OrderByDescending(Judgement.ToNumericResult).First();
+
+            foreach ((HitResult result, int count) in score.Statistics)
+            {
+                switch (result)
+                {
+                    case HitResult.LargeTickHit:
+                    case HitResult.LargeTickMiss:
+                        score.MaximumStatistics[HitResult.LargeTickHit] = score.MaximumStatistics.GetValueOrDefault(HitResult.LargeTickHit) + count;
+                        break;
+
+                    case HitResult.SmallTickHit:
+                    case HitResult.SmallTickMiss:
+                        score.MaximumStatistics[HitResult.SmallTickHit] = score.MaximumStatistics.GetValueOrDefault(HitResult.SmallTickHit) + count;
+                        break;
+
+                    case HitResult.IgnoreHit:
+                    case HitResult.IgnoreMiss:
+                    case HitResult.SmallBonus:
+                    case HitResult.LargeBonus:
+                        break;
+
+                    default:
+                        score.MaximumStatistics[maxBasicResult] = score.MaximumStatistics.GetValueOrDefault(maxBasicResult) + count;
+                        break;
+                }
+            }
+
+            if (!score.IsLegacyScore)
+                return;
+
+#pragma warning disable CS0618
+            // In osu! and osu!mania, some judgements affect combo but aren't stored to scores.
+            // A special hit result is used to pad out the combo value to match, based on the max combo from the difficulty attributes.
+            var calculator = rulesetInstance.CreateDifficultyCalculator(beatmaps().GetWorkingBeatmap(beatmap));
+            var attributes = calculator.Calculate(score.Mods);
+
+            int maxComboFromStatistics = score.MaximumStatistics.Where(kvp => kvp.Key.AffectsCombo()).Select(kvp => kvp.Value).DefaultIfEmpty(0).Sum();
+            if (attributes.MaxCombo > maxComboFromStatistics)
+                score.MaximumStatistics[HitResult.LegacyComboIncrease] = attributes.MaxCombo - maxComboFromStatistics;
+#pragma warning restore CS0618
+        }
+
         protected override void PostImport(ScoreInfo model, Realm realm, bool batchImport)
         {
             base.PostImport(model, realm, batchImport);

osu.Game/Scoring/ScoreManager.cs

@@ -28,7 +28,8 @@ namespace osu.Game.Scoring
         private readonly OsuConfigManager configManager;
         private readonly ScoreImporter scoreImporter;
 
-        public ScoreManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, RealmAccess realm, IAPIProvider api, OsuConfigManager configManager = null)
+        public ScoreManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, RealmAccess realm, IAPIProvider api,
+                            OsuConfigManager configManager = null)
             : base(storage, realm)
         {
             this.configManager = configManager;
@@ -178,6 +179,12 @@ namespace osu.Game.Scoring
         public Live<ScoreInfo> Import(ScoreInfo item, ArchiveReader archive = null, bool batchImport = false, CancellationToken cancellationToken = default) =>
             scoreImporter.ImportModel(item, archive, batchImport, cancellationToken);
 
+        /// <summary>
+        /// Populates the <see cref="ScoreInfo.MaximumStatistics"/> for a given <see cref="ScoreInfo"/>.
+        /// </summary>
+        /// <param name="score">The score to populate the statistics of.</param>
+        public void PopulateMaximumStatistics(ScoreInfo score) => scoreImporter.PopulateMaximumStatistics(score);
+
         #region Implementation of IPresentImports<ScoreInfo>
 
         public Action<IEnumerable<Live<ScoreInfo>>> PresentImport