Add versioned playable prewarm and persisted slider ticks metadata

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/013bac5c-f284-486b-a01e-396d84a127ce

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>

Author: Copilot

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -142,27 +142,23 @@ private void load(OsuRulesetConfigManager? config, IBeatmap? beatmap)
 
             // handle edge cases where a beatmap has a slider with many repeats.
             int maxRepeatsOnOneSlider;
-            int maxTicksOnOneSlider = 0;
+            int maxTicksOnOneSlider;
 
             // Use persisted metadata when available to avoid a full beatmap scan.
             // Fall back to scanning the loaded beatmap if metadata has not yet been computed.
             int persistedMaxRepeats = beatmap?.BeatmapInfo.MaxSliderRepeats ?? -1;
+            int persistedMaxTicks = beatmap?.BeatmapInfo.MaxSliderTicks ?? -1;
 
-            if (persistedMaxRepeats >= 0)
+            if (persistedMaxRepeats >= 0 && persistedMaxTicks >= 0)
             {
                 maxRepeatsOnOneSlider = persistedMaxRepeats;
-
-                // Still scan for tick counts since MaxSliderTicks is not yet persisted.
-                if (osuBeatmap != null)
-                {
-                    foreach (var slider in osuBeatmap.HitObjects.OfType<Slider>())
-                        maxTicksOnOneSlider = Math.Max(maxTicksOnOneSlider, slider.NestedHitObjects.OfType<SliderTick>().Count());
-                }
+                maxTicksOnOneSlider = persistedMaxTicks;
             }
             else
             {
                 // Fallback: scan all sliders when persisted metadata is not available.
                 maxRepeatsOnOneSlider = 0;
+                maxTicksOnOneSlider = 0;
 
                 if (osuBeatmap != null)
                 {

osu.Game.Tests/Beatmaps/BeatmapInfoStartupMetadataTest.cs

@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using System.Numerics;
+using System.Threading;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Tests.Beatmaps
+{
+    [TestFixture]
+    public class BeatmapInfoStartupMetadataTest
+    {
+        [Test]
+        public void TestSliderStartupMetadataCalculated()
+        {
+            var beatmap = new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new Slider
+                    {
+                        StartTime = 0,
+                        RepeatCount = 2,
+                        Path = new SliderPath(PathType.LINEAR, new[] { Vector2.Zero, new Vector2(200, 0) }),
+                    },
+                    new Slider
+                    {
+                        StartTime = 1500,
+                        RepeatCount = 4,
+                        Path = new SliderPath(PathType.LINEAR, new[] { Vector2.Zero, new Vector2(400, 0) }),
+                    },
+                }
+            };
+
+            foreach (var hitObject in beatmap.HitObjects)
+                hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty, CancellationToken.None);
+
+            var info = new BeatmapInfo();
+            info.UpdateStatisticsFromBeatmap(beatmap);
+
+            Assert.That(info.MaxSliderRepeats, Is.EqualTo(4));
+            Assert.That(info.MaxSliderTicks, Is.GreaterThan(0));
+            Assert.That(beatmap.HitObjects.OfType<Slider>().Any(s => s.NestedHitObjects.OfType<SliderTick>().Any()), Is.True);
+        }
+    }
+}

osu.Game.Tests/Beatmaps/PlayableBeatmapCacheTest.cs

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Tests.Beatmaps
+{
+    [TestFixture]
+    public class PlayableBeatmapCacheTest
+    {
+        [Test]
+        public void TestReturnsClone()
+        {
+            var cache = new PlayableBeatmapCache();
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Hash = "hash"
+                }
+            };
+
+            cache.CachePlayableBeatmap(beatmap.BeatmapInfo, beatmap.BeatmapInfo.Ruleset, Array.Empty<Mod>(), beatmap);
+
+            Assert.That(cache.TryGetPlayableBeatmap(beatmap.BeatmapInfo, beatmap.BeatmapInfo.Ruleset, Array.Empty<Mod>(), out var retrieved), Is.True);
+            Assert.That(retrieved, Is.Not.SameAs(beatmap));
+        }
+
+        [Test]
+        public void TestHashChangeMissesCache()
+        {
+            var cache = new PlayableBeatmapCache();
+            var beatmapInfo = new BeatmapInfo
+            {
+                Hash = "hash-a"
+            };
+
+            var beatmap = new Beatmap { BeatmapInfo = beatmapInfo };
+
+            cache.CachePlayableBeatmap(beatmapInfo, beatmapInfo.Ruleset, Array.Empty<Mod>(), beatmap);
+            Assert.That(cache.TryGetPlayableBeatmap(beatmapInfo, beatmapInfo.Ruleset, Array.Empty<Mod>(), out _), Is.True);
+
+            beatmapInfo.Hash = "hash-b";
+            Assert.That(cache.TryGetPlayableBeatmap(beatmapInfo, beatmapInfo.Ruleset, Array.Empty<Mod>(), out _), Is.False);
+        }
+    }
+}

osu.Game.Tournament/Models/TournamentBeatmap.cs

@@ -28,6 +28,8 @@ public class TournamentBeatmap : IBeatmapInfo, IBeatmapSetOnlineInfo
 
         public int MaxSliderRepeats { get; set; }
 
+        public int MaxSliderTicks { get; set; }
+
         public IBeatmapMetadataInfo Metadata { get; set; } = new BeatmapMetadata();
 
         public IBeatmapDifficultyInfo Difficulty { get; set; } = new BeatmapDifficulty();
@@ -52,6 +54,8 @@ public TournamentBeatmap(APIBeatmap beatmap)
             Covers = beatmap.BeatmapSet?.Covers ?? new BeatmapSetOnlineCovers();
             EndTimeObjectCount = beatmap.EndTimeObjectCount;
             TotalObjectCount = beatmap.TotalObjectCount;
+            MaxSliderRepeats = beatmap.MaxSliderRepeats;
+            MaxSliderTicks = beatmap.MaxSliderTicks;
             Ruleset = beatmap.Ruleset;
         }
 

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -129,6 +129,13 @@ public BeatmapOnlineStatus Status
         /// </summary>
         public int MaxSliderRepeats { get; set; } = -1;
 
+        /// <summary>
+        /// The maximum number of slider ticks found on a single slider in the beatmap.
+        /// Only relevant for rulesets that expose slider ticks (currently osu!).
+        /// Defaults to -1 (meaning not-yet-calculated).
+        /// </summary>
+        public int MaxSliderTicks { get; set; } = -1;
+
         /// <summary>
         /// Reset any fetched online linking information (and history).
         /// </summary>

osu.Game/Beatmaps/BeatmapInfoExtensions.cs

@@ -30,6 +30,14 @@ public static void UpdateStatisticsFromBeatmap(this BeatmapInfo beatmapInfo, IBe
                                                    .Select(h => h.RepeatCount)
                                                    .DefaultIfEmpty(0)
                                                    .Max();
+
+            // Slider tick objects are generated as nested hit objects after defaults have been applied.
+            // This method is called both with raw and playable beatmaps; for raw beatmaps this will
+            // naturally become 0 and later be backfilled by background processing.
+            beatmapInfo.MaxSliderTicks = beatmap.HitObjects
+                                                .Select(h => h.NestedHitObjects.Count(n => n.GetType().Name == "SliderTick"))
+                                                .DefaultIfEmpty(0)
+                                                .Max();
         }
 
         /// <summary>

osu.Game/Beatmaps/BeatmapUpdater.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Extensions.ObjectExtensions;
@@ -10,7 +9,6 @@
 using osu.Framework.Threading;
 using osu.Game.Database;
 using osu.Game.Online.API;
-using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Beatmaps
 {
@@ -59,9 +57,10 @@ public void Process(BeatmapSetInfo beatmapSet, MetadataLookupScope lookupScope =
 
                     var ruleset = working.BeatmapInfo.Ruleset.CreateInstance();
                     var calculator = ruleset.CreateDifficultyCalculator(working);
+                    var playable = working.GetPlayableBeatmap(working.BeatmapInfo.Ruleset);
 
                     beatmap.StarRating = calculator.Calculate().StarRating;
-                    beatmap.UpdateStatisticsFromBeatmap(working.Beatmap);
+                    beatmap.UpdateStatisticsFromBeatmap(playable);
                 }
 
                 // And invalidate again afterwards as re-fetching the most up-to-date database metadata will be required.
@@ -77,15 +76,9 @@ public void ProcessObjectCounts(BeatmapInfo beatmapInfo, MetadataLookupScope loo
                 workingBeatmapCache.Invalidate(beatmapInfo);
 
                 var working = workingBeatmapCache.GetWorkingBeatmap(beatmapInfo);
-                var beatmap = working.Beatmap;
-
-                beatmapInfo.EndTimeObjectCount = beatmap.HitObjects.Count(h => h is IHasDuration);
-                beatmapInfo.TotalObjectCount = beatmap.HitObjects.Count;
-                beatmapInfo.MaxSliderRepeats = beatmap.HitObjects
-                                                      .OfType<IHasRepeats>()
-                                                      .Select(h => h.RepeatCount)
-                                                      .DefaultIfEmpty(0)
-                                                      .Max();
+                var playable = working.GetPlayableBeatmap(beatmapInfo.Ruleset);
+
+                beatmapInfo.UpdateStatisticsFromBeatmap(playable);
 
                 // And invalidate again afterwards as re-fetching the most up-to-date database metadata will be required.
                 workingBeatmapCache.Invalidate(beatmapInfo);

osu.Game/Beatmaps/IBeatmapInfo.cs

@@ -84,5 +84,12 @@ public interface IBeatmapInfo : IHasOnlineID<int>, IEquatable<IBeatmapInfo>
         /// Defaults to -1 (meaning not-yet-calculated).
         /// </summary>
         int MaxSliderRepeats { get; }
+
+        /// <summary>
+        /// The maximum number of slider ticks on a single slider in the beatmap.
+        /// Only meaningful for rulesets that have slider ticks (e.g. osu!).
+        /// Defaults to -1 (meaning not-yet-calculated).
+        /// </summary>
+        int MaxSliderTicks { get; }
     }
 }

osu.Game/Beatmaps/PlayableBeatmapCache.cs

@@ -8,6 +8,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
+using osu.Game;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 
@@ -21,7 +22,7 @@ namespace osu.Game.Beatmaps
     /// <remarks>
     /// <para>
     /// The cache stores one <em>canonical</em> (immutable) copy keyed by
-    /// <c>(BeatmapInfo.ID, rulesetShortName, orderedModsKey)</c>.
+    /// <c>(BeatmapInfo.ID + BeatmapInfo.Hash, rulesetShortName, orderedModsKey, gameVersion)</c>.
     /// Callers receive a shallow <see cref="IBeatmap.Clone"/> so that gameplay state does not
     /// bleed across sessions while still reusing the pre-built hit-object graph.
     /// </para>
@@ -33,20 +34,23 @@ namespace osu.Game.Beatmaps
     /// </remarks>
     public class PlayableBeatmapCache : Component
     {
-        private readonly record struct CacheKey(Guid BeatmapId, string RulesetShortName, string ModsKey);
+        private readonly record struct CacheKey(Guid BeatmapId, string BeatmapHash, string RulesetShortName, string ModsKey, string GameVersion);
 
         private readonly Dictionary<CacheKey, IBeatmap> cache = new Dictionary<CacheKey, IBeatmap>();
 
         private WorkingBeatmapCache? workingBeatmapCache;
+        private string gameVersion = string.Empty;
 
-        [BackgroundDependencyLoader]
-        private void load(IWorkingBeatmapCache beatmapCache)
+        [BackgroundDependencyLoader(true)]
+        private void load(IWorkingBeatmapCache beatmapCache, OsuGameBase? game)
         {
             if (beatmapCache is WorkingBeatmapCache concrete)
             {
                 workingBeatmapCache = concrete;
                 workingBeatmapCache.OnInvalidated += handleInvalidated;
             }
+
+            gameVersion = game?.VersionHash ?? typeof(OsuGameBase).Assembly.GetName().Version?.ToString() ?? "unknown";
         }
 
         /// <summary>
@@ -110,15 +114,15 @@ private void handleInvalidated(WorkingBeatmap working)
             }
         }
 
-        private static CacheKey makeKey(BeatmapInfo beatmapInfo, IRulesetInfo ruleset, IReadOnlyList<Mod> mods)
+        private CacheKey makeKey(BeatmapInfo beatmapInfo, IRulesetInfo ruleset, IReadOnlyList<Mod> mods)
         {
             // Build a deterministic key from ordered mod acronyms and their settings hash.
             // Mod.GetHashCode() accounts for both the type and any user-adjustable settings.
             string modsKey = string.Join(';', mods
                                               .OrderBy(m => m.Acronym)
                                               .Select(m => $"{m.Acronym}:{m.GetHashCode()}"));
 
-            return new CacheKey(beatmapInfo.ID, ruleset.ShortName, modsKey);
+            return new CacheKey(beatmapInfo.ID, beatmapInfo.Hash, ruleset.ShortName, modsKey, gameVersion);
         }
 
         protected override void Dispose(bool isDisposing)

osu.Game/Database/BackgroundDataStoreProcessor.cs

@@ -295,7 +295,7 @@ private void processBeatmapsWithMissingObjectCounts()
 
             realmAccess.Run(r =>
             {
-                foreach (var b in r.All<BeatmapInfo>().Where(b => b.TotalObjectCount < 0 || b.EndTimeObjectCount < 0 || b.MaxSliderRepeats < 0))
+                foreach (var b in r.All<BeatmapInfo>().Where(b => b.TotalObjectCount < 0 || b.EndTimeObjectCount < 0 || b.MaxSliderRepeats < 0 || b.MaxSliderTicks < 0))
                     beatmapIds.Add(b.ID);
             });