Merge branch 'master' into rename-beatmap-info-beatmap-fields

.github/workflows/diffcalc.yml

@@ -53,6 +53,7 @@ jobs:
   diffcalc:
     name: Run
     runs-on: self-hosted
+    timeout-minutes: 1440
     if: needs.metadata.outputs.continue == 'yes'
     needs: metadata
     strategy:

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1004.0" />
     <PackageReference Include="ppy.osu.Framework.Android" Version="2021.929.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModHidden.cs

@@ -4,13 +4,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Screens.Play;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
@@ -122,7 +120,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
         private bool checkSomeHit() => Player.ScoreProcessor.JudgedHits >= 4;
 
         private bool objectWithIncreasedVisibilityHasIndex(int index)
-            => Player.Mods.Value.OfType<TestOsuModHidden>().Single().FirstObject == Player.ChildrenOfType<GameplayBeatmap>().Single().HitObjects[index];
+            => Player.Mods.Value.OfType<TestOsuModHidden>().Single().FirstObject == Player.GameplayState.Beatmap.HitObjects[index];
 
         private class TestOsuModHidden : OsuModHidden
         {

osu.Game.Rulesets.Osu.Tests/Resources/special-skin/skin.ini

@@ -0,0 +1,3 @@
+[General]
+Version: latest
+HitCircleOverlayAboveNumber: 0

osu.Game.Rulesets.Osu.Tests/TestSceneGameplayCursor.cs

@@ -17,6 +17,7 @@ using osu.Framework.Testing.Input;
 using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.UI.Cursor;
 using osu.Game.Screens.Play;
@@ -29,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.Tests
     public class TestSceneGameplayCursor : OsuSkinnableTestScene
     {
         [Cached]
-        private GameplayBeatmap gameplayBeatmap;
+        private GameplayState gameplayState;
 
         private OsuCursorContainer lastContainer;
 
@@ -40,7 +41,8 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestSceneGameplayCursor()
         {
-            gameplayBeatmap = new GameplayBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
+            var ruleset = new OsuRuleset();
+            gameplayState = new GameplayState(CreateBeatmap(ruleset.RulesetInfo), ruleset, Array.Empty<Mod>());
 
             AddStep("change background colour", () =>
             {
@@ -57,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddSliderStep("circle size", 0f, 10f, 0f, val =>
             {
                 config.SetValue(OsuSetting.AutoCursorSize, true);
-                gameplayBeatmap.BeatmapInfo.BaseDifficulty.CircleSize = val;
+                gameplayState.Beatmap.BeatmapInfo.BaseDifficulty.CircleSize = val;
                 Scheduler.AddOnce(() => loadContent(false));
             });
 
@@ -73,7 +75,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         public void TestSizing(int circleSize, float userScale)
         {
             AddStep($"set user scale to {userScale}", () => config.SetValue(OsuSetting.GameplayCursorSize, userScale));
-            AddStep($"adjust cs to {circleSize}", () => gameplayBeatmap.BeatmapInfo.BaseDifficulty.CircleSize = circleSize);
+            AddStep($"adjust cs to {circleSize}", () => gameplayState.Beatmap.BeatmapInfo.BaseDifficulty.CircleSize = circleSize);
             AddStep("turn on autosizing", () => config.SetValue(OsuSetting.AutoCursorSize, true));
 
             AddStep("load content", () => loadContent());

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyCursorParticles.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         private OsuPlayfield playfield { get; set; }
 
         [Resolved(canBeNull: true)]
-        private GameplayBeatmap gameplayBeatmap { get; set; }
+        private GameplayState gameplayState { get; set; }
 
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, OsuColour colours)
@@ -75,12 +75,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
         protected override void Update()
         {
-            if (playfield == null || gameplayBeatmap == null) return;
+            if (playfield == null || gameplayState == null) return;
 
             DrawableHitObject kiaiHitObject = null;
 
             // Check whether currently in a kiai section first. This is only done as an optimisation to avoid enumerating AliveObjects when not necessary.
-            if (gameplayBeatmap.ControlPointInfo.EffectPointAt(Time.Current).KiaiMode)
+            if (gameplayState.Beatmap.ControlPointInfo.EffectPointAt(Time.Current).KiaiMode)
                 kiaiHitObject = playfield.HitObjectContainer.AliveObjects.FirstOrDefault(isTracking);
 
             kiaiSpewer.Active.Value = kiaiHitObject != null;

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyMainCirclePiece.cs

@@ -35,8 +35,9 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
         private Drawable hitCircleSprite;
 
-        protected Drawable HitCircleOverlay { get; private set; }
+        protected Container OverlayLayer { get; private set; }
 
+        private Drawable hitCircleOverlay;
         private SkinnableSpriteText hitCircleText;
 
         private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
@@ -78,17 +79,22 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                 },
-                HitCircleOverlay = new KiaiFlashingSprite
+                OverlayLayer = new Container
                 {
-                    Texture = overlayTexture,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                },
+                    Child = hitCircleOverlay = new KiaiFlashingSprite
+                    {
+                        Texture = overlayTexture,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                }
             };
 
             if (hasNumber)
             {
-                AddInternal(hitCircleText = new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
+                OverlayLayer.Add(hitCircleText = new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
                 {
                     Font = OsuFont.Numeric.With(size: 40),
                     UseFullGlyphHeight = false,
@@ -102,7 +108,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
             bool overlayAboveNumber = skin.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.HitCircleOverlayAboveNumber)?.Value ?? true;
 
             if (overlayAboveNumber)
-                ChangeInternalChildDepth(HitCircleOverlay, float.MinValue);
+                OverlayLayer.ChangeChildDepth(hitCircleOverlay, float.MinValue);
 
             accentColour.BindTo(drawableObject.AccentColour);
             indexInCurrentCombo.BindTo(drawableOsuObject.IndexInCurrentComboBindable);
@@ -147,8 +153,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         hitCircleSprite.FadeOut(legacy_fade_duration, Easing.Out);
                         hitCircleSprite.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
 
-                        HitCircleOverlay.FadeOut(legacy_fade_duration, Easing.Out);
+                        hitCircleOverlay.FadeOut(legacy_fade_duration, Easing.Out);
-                        HitCircleOverlay.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
+                        hitCircleOverlay.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
 
                         if (hasNumber)
                         {

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderHeadHitCircle.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         [Resolved(canBeNull: true)]
         private DrawableHitObject drawableHitObject { get; set; }
 
-        private Drawable proxiedHitCircleOverlay;
+        private Drawable proxiedOverlayLayer;
 
         public LegacySliderHeadHitCircle()
             : base("sliderstartcircle")
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            proxiedHitCircleOverlay = HitCircleOverlay.CreateProxy();
+            proxiedOverlayLayer = OverlayLayer.CreateProxy();
 
             if (drawableHitObject != null)
             {
@@ -35,11 +35,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
         private void onHitObjectApplied(DrawableHitObject drawableObject)
         {
-            Debug.Assert(proxiedHitCircleOverlay.Parent == null);
+            Debug.Assert(proxiedOverlayLayer.Parent == null);
 
             // see logic in LegacyReverseArrow.
             (drawableObject as DrawableSliderHead)?.DrawableSlider
-                                                  .OverlayElementContainer.Add(proxiedHitCircleOverlay.With(d => d.Depth = float.MinValue));
+                                                  .OverlayElementContainer.Add(proxiedOverlayLayer.With(d => d.Depth = float.MinValue));
         }
 
         protected override void Dispose(bool isDisposing)

osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         }
 
         [Resolved(canBeNull: true)]
-        private GameplayBeatmap beatmap { get; set; }
+        private GameplayState state { get; set; }
 
         [Resolved]
         private OsuConfigManager config { get; set; }
@@ -96,10 +96,10 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         {
             float scale = userCursorScale.Value;
 
-            if (autoCursorScale.Value && beatmap != null)
+            if (autoCursorScale.Value && state != null)
             {
                 // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
-                scale *= GetScaleForCircleSize(beatmap.BeatmapInfo.BaseDifficulty.CircleSize);
+                scale *= GetScaleForCircleSize(state.Beatmap.BeatmapInfo.BaseDifficulty.CircleSize);
             }
 
             cursorScale.Value = scale;

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyTaikoScroller.cs

@@ -25,10 +25,10 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(GameplayBeatmap gameplayBeatmap)
+        private void load(GameplayState gameplayState)
         {
-            if (gameplayBeatmap != null)
+            if (gameplayState != null)
-                ((IBindable<JudgementResult>)LastResult).BindTo(gameplayBeatmap.LastJudgementResult);
+                ((IBindable<JudgementResult>)LastResult).BindTo(gameplayState.LastJudgementResult);
         }
 
         private bool passing;

osu.Game.Rulesets.Taiko/UI/DrawableTaikoMascot.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(TextureStore textures, GameplayBeatmap gameplayBeatmap)
+        private void load(TextureStore textures, GameplayState gameplayState)
         {
             InternalChildren = new[]
             {
@@ -49,8 +49,8 @@ namespace osu.Game.Rulesets.Taiko.UI
                 animations[TaikoMascotAnimationState.Fail] = new TaikoMascotAnimation(TaikoMascotAnimationState.Fail),
             };
 
-            if (gameplayBeatmap != null)
+            if (gameplayState != null)
-                ((IBindable<JudgementResult>)LastResult).BindTo(gameplayBeatmap.LastJudgementResult);
+                ((IBindable<JudgementResult>)LastResult).BindTo(gameplayState.LastJudgementResult);
         }
 
         protected override void LoadComplete()

osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs

@@ -149,5 +149,32 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[5]).LoopType);
             }
         }
+
+        [Test]
+        public void TestDecodeLoopCount()
+        {
+            // all loop sequences in loop-count.osb have a total duration of 2000ms (fade in 0->1000ms, fade out 1000->2000ms).
+            const double loop_duration = 2000;
+
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("loop-count.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+
+                // stable ensures that any loop command executes at least once, even if the loop count specified in the .osb is zero or negative.
+                StoryboardSprite zeroTimes = background.Elements.OfType<StoryboardSprite>().Single(s => s.Path == "zero-times.png");
+                Assert.That(zeroTimes.EndTime, Is.EqualTo(1000 + loop_duration));
+
+                StoryboardSprite oneTime = background.Elements.OfType<StoryboardSprite>().Single(s => s.Path == "one-time.png");
+                Assert.That(oneTime.EndTime, Is.EqualTo(4000 + loop_duration));
+
+                StoryboardSprite manyTimes = background.Elements.OfType<StoryboardSprite>().Single(s => s.Path == "many-times.png");
+                Assert.That(manyTimes.EndTime, Is.EqualTo(9000 + 40 * loop_duration));
+            }
+        }
     }
 }

osu.Game.Tests/Database/GeneralUsageTests.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+#nullable enable
+
+namespace osu.Game.Tests.Database
+{
+    [TestFixture]
+    public class GeneralUsageTests : RealmTest
+    {
+        /// <summary>
+        /// Just test the construction of a new database works.
+        /// </summary>
+        [Test]
+        public void TestConstructRealm()
+        {
+            RunTestWithRealm((realmFactory, _) => { realmFactory.CreateContext().Refresh(); });
+        }
+
+        [Test]
+        public void TestBlockOperations()
+        {
+            RunTestWithRealm((realmFactory, _) =>
+            {
+                using (realmFactory.BlockAllOperations())
+                {
+                }
+            });
+        }
+
+        [Test]
+        public void TestBlockOperationsWithContention()
+        {
+            RunTestWithRealm((realmFactory, _) =>
+            {
+                ManualResetEventSlim stopThreadedUsage = new ManualResetEventSlim();
+                ManualResetEventSlim hasThreadedUsage = new ManualResetEventSlim();
+
+                Task.Factory.StartNew(() =>
+                {
+                    using (realmFactory.CreateContext())
+                    {
+                        hasThreadedUsage.Set();
+
+                        stopThreadedUsage.Wait();
+                    }
+                }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler);
+
+                hasThreadedUsage.Wait();
+
+                Assert.Throws<TimeoutException>(() =>
+                {
+                    using (realmFactory.BlockAllOperations())
+                    {
+                    }
+                });
+
+                stopThreadedUsage.Set();
+            });
+        }
+    }
+}

osu.Game.Tests/Database/RealmTest.cs

@@ -0,0 +1,83 @@
+// 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 System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Nito.AsyncEx;
+using NUnit.Framework;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Database;
+
+#nullable enable
+
+namespace osu.Game.Tests.Database
+{
+    [TestFixture]
+    public abstract class RealmTest
+    {
+        private static readonly TemporaryNativeStorage storage;
+
+        static RealmTest()
+        {
+            storage = new TemporaryNativeStorage("realm-test");
+            storage.DeleteDirectory(string.Empty);
+        }
+
+        protected void RunTestWithRealm(Action<RealmContextFactory, Storage> testAction, [CallerMemberName] string caller = "")
+        {
+            AsyncContext.Run(() =>
+            {
+                var testStorage = storage.GetStorageForDirectory(caller);
+
+                using (var realmFactory = new RealmContextFactory(testStorage, caller))
+                {
+                    Logger.Log($"Running test using realm file {testStorage.GetFullPath(realmFactory.Filename)}");
+                    testAction(realmFactory, testStorage);
+
+                    realmFactory.Dispose();
+
+                    Logger.Log($"Final database size: {getFileSize(testStorage, realmFactory)}");
+                    realmFactory.Compact();
+                    Logger.Log($"Final database size after compact: {getFileSize(testStorage, realmFactory)}");
+                }
+            });
+        }
+
+        protected void RunTestWithRealmAsync(Func<RealmContextFactory, Storage, Task> testAction, [CallerMemberName] string caller = "")
+        {
+            AsyncContext.Run(async () =>
+            {
+                var testStorage = storage.GetStorageForDirectory(caller);
+
+                using (var realmFactory = new RealmContextFactory(testStorage, caller))
+                {
+                    Logger.Log($"Running test using realm file {testStorage.GetFullPath(realmFactory.Filename)}");
+                    await testAction(realmFactory, testStorage);
+
+                    realmFactory.Dispose();
+
+                    Logger.Log($"Final database size: {getFileSize(testStorage, realmFactory)}");
+                    realmFactory.Compact();
+                    Logger.Log($"Final database size after compact: {getFileSize(testStorage, realmFactory)}");
+                }
+            });
+        }
+
+        private static long getFileSize(Storage testStorage, RealmContextFactory realmFactory)
+        {
+            try
+            {
+                using (var stream = testStorage.GetStream(realmFactory.Filename))
+                    return stream?.Length ?? 0;
+            }
+            catch
+            {
+                // windows runs may error due to file still being open.
+                return 0;
+            }
+        }
+    }
+}

osu.Game.Tests/Resources/loop-count.osb

@@ -0,0 +1,15 @@
+osu file format v14
+
+[Events]
+Sprite,Background,TopCentre,"zero-times.png",320,240
+ L,1000,0
+  F,0,0,1000,0,1
+  F,0,1000,2000,1,0
+Sprite,Background,TopCentre,"one-time.png",320,240
+ L,4000,1
+  F,0,0,1000,0,1
+  F,0,1000,2000,1,0
+Sprite,Background,TopCentre,"many-times.png",320,240
+ L,9000,40
+  F,0,0,1000,0,1
+  F,0,1000,2000,1,0

osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecorder.cs

@@ -1,6 +1,7 @@
 // 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 System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -17,6 +18,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Replays;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
@@ -38,7 +41,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private TestReplayRecorder recorder;
 
         [Cached]
-        private GameplayBeatmap gameplayBeatmap = new GameplayBeatmap(new Beatmap());
+        private GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), Array.Empty<Mod>());
 
         [SetUp]
         public void SetUp() => Schedule(() =>
@@ -57,7 +60,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                             Recorder = recorder = new TestReplayRecorder(new Score
                             {
                                 Replay = replay,
-                                ScoreInfo = { Beatmap = gameplayBeatmap.BeatmapInfo }
+                                ScoreInfo = { Beatmap = gameplayState.Beatmap.BeatmapInfo }
                             })
                             {
                                 ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),

osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecording.cs

@@ -1,6 +1,7 @@
 // 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 System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -13,6 +14,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Replays;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
@@ -30,7 +33,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private readonly TestRulesetInputManager recordingManager;
 
         [Cached]
-        private GameplayBeatmap gameplayBeatmap = new GameplayBeatmap(new Beatmap());
+        private GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), Array.Empty<Mod>());
 
         public TestSceneReplayRecording()
         {
@@ -48,7 +51,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                             Recorder = new TestReplayRecorder(new Score
                             {
                                 Replay = replay,
-                                ScoreInfo = { Beatmap = gameplayBeatmap.BeatmapInfo }
+                                ScoreInfo = { Beatmap = gameplayState.Beatmap.BeatmapInfo }
                             })
                             {
                                 ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos)

osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs

@@ -25,6 +25,8 @@ using osu.Game.Online.Spectator;
 using osu.Game.Replays;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.UI;
@@ -62,7 +64,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private SpectatorClient spectatorClient { get; set; }
 
         [Cached]
-        private GameplayBeatmap gameplayBeatmap = new GameplayBeatmap(new Beatmap());
+        private GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), Array.Empty<Mod>());
 
         [SetUp]
         public void SetUp() => Schedule(() =>

osu.Game.Tests/Visual/Settings/TestSceneKeyBindingPanel.cs

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Framework.Threading;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Settings.Sections.Input;
 using osuTK.Input;
@@ -230,6 +231,22 @@ namespace osu.Game.Tests.Visual.Settings
             AddAssert("first binding selected", () => multiBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().First().IsBinding);
         }
 
+        [Test]
+        public void TestFilteringHidesResetSectionButtons()
+        {
+            SearchTextBox searchTextBox = null;
+
+            AddStep("add any search term", () =>
+            {
+                searchTextBox = panel.ChildrenOfType<SearchTextBox>().Single();
+                searchTextBox.Current.Value = "chat";
+            });
+            AddUntilStep("all reset section bindings buttons hidden", () => panel.ChildrenOfType<ResetButton>().All(button => button.Alpha == 0));
+
+            AddStep("clear search term", () => searchTextBox.Current.Value = string.Empty);
+            AddUntilStep("all reset section bindings buttons shown", () => panel.ChildrenOfType<ResetButton>().All(button => button.Alpha == 1));
+        }
+
         private void checkBinding(string name, string keyName)
         {
             AddAssert($"Check {name} is bound to {keyName}", () =>

osu.Game.Tests/Visual/UserInterface/TestSceneOsuFont.cs

@@ -0,0 +1,77 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneOsuFont : OsuTestScene
+    {
+        private OsuSpriteText spriteText;
+
+        private readonly BindableBool useAlternates = new BindableBool();
+        private readonly Bindable<FontWeight> weight = new Bindable<FontWeight>(FontWeight.Regular);
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = spriteText = new OsuSpriteText
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                RelativeSizeAxes = Axes.X,
+                AllowMultiline = true,
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            useAlternates.BindValueChanged(_ => updateFont());
+            weight.BindValueChanged(_ => updateFont(), true);
+        }
+
+        private void updateFont()
+        {
+            FontUsage usage = useAlternates.Value ? OsuFont.TorusAlternate : OsuFont.Torus;
+            spriteText.Font = usage.With(size: 40, weight: weight.Value);
+        }
+
+        [Test]
+        public void TestTorusAlternates()
+        {
+            AddStep("set all ASCII letters", () => spriteText.Text = @"ABCDEFGHIJKLMNOPQRSTUVWXYZ
+abcdefghijklmnopqrstuvwxyz");
+            AddStep("set all alternates", () => spriteText.Text = @"A Á Ă Â Ä À Ā Ą Å Ã
+Æ B D Ð Ď Đ E É Ě Ê
+Ë Ė È Ē Ę F G Ğ Ģ Ġ
+H I Í Î Ï İ Ì Ī Į K
+Ķ O Œ P Þ Q R Ŕ Ř Ŗ
+T Ŧ Ť Ţ Ț V W Ẃ Ŵ Ẅ
+Ẁ X Y Ý Ŷ Ÿ Ỳ a á ă
+â ä à ā ą å ã æ b d
+ď đ e é ě ê ë ė è ē
+ę f g ğ ģ ġ k ķ m n
+ń ň ņ ŋ ñ o œ p þ q
+t ŧ ť ţ ț u ú û ü ù
+ű ū ų ů w ẃ ŵ ẅ ẁ x
+y ý ŷ ÿ ỳ");
+
+            AddToggleStep("toggle alternates", alternates => useAlternates.Value = alternates);
+
+            addSetWeightStep(FontWeight.Light);
+            addSetWeightStep(FontWeight.Regular);
+            addSetWeightStep(FontWeight.SemiBold);
+            addSetWeightStep(FontWeight.Bold);
+
+            void addSetWeightStep(FontWeight newWeight) => AddStep($"set weight {newWeight}", () => weight.Value = newWeight);
+        }
+    }
+}

osu.Game.Tests/osu.Game.Tests.csproj

@@ -4,6 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Nito.AsyncEx" Version="5.1.2" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -176,8 +176,8 @@ namespace osu.Game.Beatmaps.Formats
                     case "L":
                     {
                         var startTime = Parsing.ParseDouble(split[1]);
-                        var loopCount = Parsing.ParseInt(split[2]);
+                        var repeatCount = Parsing.ParseInt(split[2]);
-                        timelineGroup = storyboardSprite?.AddLoop(startTime, loopCount);
+                        timelineGroup = storyboardSprite?.AddLoop(startTime, Math.Max(0, repeatCount - 1));
                         break;
                     }
 

osu.Game/Database/RealmContextFactory.cs

@@ -135,23 +135,46 @@ namespace osu.Game.Database
             if (IsDisposed)
                 throw new ObjectDisposedException(nameof(RealmContextFactory));
 
+            // TODO: this can be added for safety once we figure how to bypass in test
+            // if (!ThreadSafety.IsUpdateThread)
+            //     throw new InvalidOperationException($"{nameof(BlockAllOperations)} must be called from the update thread.");
+
             Logger.Log(@"Blocking realm operations.", LoggingTarget.Database);
 
-            contextCreationLock.Wait();
+            try
-
-            lock (contextLock)
             {
-                context?.Dispose();
+                contextCreationLock.Wait();
-                context = null;
+
+                lock (contextLock)
+                {
+                    context?.Dispose();
+                    context = null;
+                }
+
+                const int sleep_length = 200;
+                int timeout = 5000;
+
+                // see https://github.com/realm/realm-dotnet/discussions/2657
+                while (!Compact())
+                {
+                    Thread.Sleep(sleep_length);
+                    timeout -= sleep_length;
+
+                    if (timeout < 0)
+                        throw new TimeoutException("Took too long to acquire lock");
+                }
+            }
+            catch
+            {
+                contextCreationLock.Release();
+                throw;
             }
 
-            return new InvokeOnDisposal<RealmContextFactory>(this, endBlockingSection);
+            return new InvokeOnDisposal<RealmContextFactory>(this, factory =>
-
-            static void endBlockingSection(RealmContextFactory factory)
             {
                 factory.contextCreationLock.Release();
                 Logger.Log(@"Restoring realm operations.", LoggingTarget.Database);
-            }
+            });
         }
 
         protected override void Dispose(bool isDisposing)
@@ -163,8 +186,8 @@ namespace osu.Game.Database
 
             if (!IsDisposed)
             {
-                // intentionally block all operations indefinitely. this ensures that nothing can start consuming a new context after disposal.
+                // intentionally block context creation indefinitely. this ensures that nothing can start consuming a new context after disposal.
-                BlockAllOperations();
+                contextCreationLock.Wait();
                 contextCreationLock.Dispose();
             }
 

osu.Game/Graphics/OsuFont.cs

@@ -21,6 +21,8 @@ namespace osu.Game.Graphics
 
         public static FontUsage Torus => GetFont(Typeface.Torus, weight: FontWeight.Regular);
 
+        public static FontUsage TorusAlternate => GetFont(Typeface.TorusAlternate, weight: FontWeight.Regular);
+
         public static FontUsage Inter => GetFont(Typeface.Inter, weight: FontWeight.Regular);
 
         /// <summary>
@@ -57,6 +59,9 @@ namespace osu.Game.Graphics
                 case Typeface.Torus:
                     return "Torus";
 
+                case Typeface.TorusAlternate:
+                    return "Torus-Alternate";
+
                 case Typeface.Inter:
                     return "Inter";
             }
@@ -113,6 +118,7 @@ namespace osu.Game.Graphics
     {
         Venera,
         Torus,
+        TorusAlternate,
         Inter,
     }
 

osu.Game/Online/Spectator/SpectatorClient.cs

@@ -134,7 +134,7 @@ namespace osu.Game.Online.Spectator
             return Task.CompletedTask;
         }
 
-        public void BeginPlaying(GameplayBeatmap beatmap, Score score)
+        public void BeginPlaying(GameplayState state, Score score)
         {
             Debug.Assert(ThreadSafety.IsUpdateThread);
 
@@ -148,7 +148,7 @@ namespace osu.Game.Online.Spectator
             currentState.RulesetID = score.ScoreInfo.RulesetID;
             currentState.Mods = score.ScoreInfo.Mods.Select(m => new APIMod(m)).ToArray();
 
-            currentBeatmap = beatmap.PlayableBeatmap;
+            currentBeatmap = state.Beatmap;
             currentScore = score;
 
             BeginPlayingInternal(currentState);

osu.Game/OsuGameBase.cs

@@ -347,6 +347,11 @@ namespace osu.Game
             AddFont(Resources, @"Fonts/Torus/Torus-SemiBold");
             AddFont(Resources, @"Fonts/Torus/Torus-Bold");
 
+            AddFont(Resources, @"Fonts/Torus-Alternate/Torus-Alternate-Regular");
+            AddFont(Resources, @"Fonts/Torus-Alternate/Torus-Alternate-Light");
+            AddFont(Resources, @"Fonts/Torus-Alternate/Torus-Alternate-SemiBold");
+            AddFont(Resources, @"Fonts/Torus-Alternate/Torus-Alternate-Bold");
+
             AddFont(Resources, @"Fonts/Inter/Inter-Regular");
             AddFont(Resources, @"Fonts/Inter/Inter-RegularItalic");
             AddFont(Resources, @"Fonts/Inter/Inter-Light");

osu.Game/Overlays/ChatOverlay.cs

@@ -284,6 +284,10 @@ namespace osu.Game.Overlays
                     if (currentChannel.Value != e.NewValue)
                         return;
 
+                    // check once more to ensure the channel hasn't since been removed from the loaded channels list (may have been left by some automated means).
+                    if (loadedChannels.Contains(loaded))
+                        return;
+
                     loading.Hide();
 
                     currentChannelContainer.Clear(false);
@@ -444,10 +448,9 @@ namespace osu.Game.Overlays
 
                         if (loaded != null)
                         {
-                            loadedChannels.Remove(loaded);
-
                             // Because the container is only cleared in the async load callback of a new channel, it is forcefully cleared
                             // to ensure that the previous channel doesn't get updated after it's disposed
+                            loadedChannels.Remove(loaded);
                             currentChannelContainer.Remove(loaded);
                             loaded.Dispose();
                         }

osu.Game/Overlays/Settings/Sections/Input/KeyBindingsSubsection.cs

@@ -75,5 +75,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
 
             Content.CornerRadius = 5;
         }
+
+        // Empty FilterTerms so that the ResetButton is visible only when the whole subsection is visible.
+        public override IEnumerable<string> FilterTerms => Enumerable.Empty<string>();
     }
 }

osu.Game/Rulesets/UI/ReplayRecorder.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.UI
         private SpectatorClient spectatorClient { get; set; }
 
         [Resolved]
-        private GameplayBeatmap gameplayBeatmap { get; set; }
+        private GameplayState gameplayState { get; set; }
 
         protected ReplayRecorder(Score target)
         {
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.UI
 
             inputManager = GetContainingInputManager();
 
-            spectatorClient?.BeginPlaying(gameplayBeatmap, target);
+            spectatorClient?.BeginPlaying(gameplayState, target);
         }
 
         protected override void Dispose(bool isDisposing)

osu.Game/Screens/OnlinePlay/Header.cs

@@ -72,21 +72,21 @@ namespace osu.Game.Screens.OnlinePlay
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
-                                Font = OsuFont.GetFont(size: 24),
+                                Font = OsuFont.TorusAlternate.With(size: 24),
                                 Text = mainTitle
                             },
                             dot = new OsuSpriteText
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
-                                Font = OsuFont.GetFont(size: 24),
+                                Font = OsuFont.TorusAlternate.With(size: 24),
                                 Text = "·"
                             },
                             pageTitle = new OsuSpriteText
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
-                                Font = OsuFont.GetFont(size: 24),
+                                Font = OsuFont.TorusAlternate.With(size: 24),
                                 Text = "Lounge"
                             }
                         }

osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs

@@ -213,8 +213,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         {
         }
 
-        protected override void StartGameplay(int userId, GameplayState gameplayState)
+        protected override void StartGameplay(int userId, SpectatorGameplayState spectatorGameplayState)
-            => instances.Single(i => i.UserId == userId).LoadScore(gameplayState.Score);
+            => instances.Single(i => i.UserId == userId).LoadScore(spectatorGameplayState.Score);
 
         protected override void EndGameplay(int userId)
         {

osu.Game/Screens/Play/GameplayBeatmap.cs

@@ -1,56 +0,0 @@
-// 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.Collections.Generic;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Beatmaps.Timing;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Screens.Play
-{
-    public class GameplayBeatmap : Component, IBeatmap
-    {
-        public readonly IBeatmap PlayableBeatmap;
-
-        public GameplayBeatmap(IBeatmap playableBeatmap)
-        {
-            PlayableBeatmap = playableBeatmap;
-        }
-
-        public BeatmapInfo BeatmapInfo
-        {
-            get => PlayableBeatmap.BeatmapInfo;
-            set => PlayableBeatmap.BeatmapInfo = value;
-        }
-
-        public BeatmapMetadata Metadata => PlayableBeatmap.Metadata;
-
-        public ControlPointInfo ControlPointInfo
-        {
-            get => PlayableBeatmap.ControlPointInfo;
-            set => PlayableBeatmap.ControlPointInfo = value;
-        }
-
-        public List<BreakPeriod> Breaks => PlayableBeatmap.Breaks;
-
-        public double TotalBreakTime => PlayableBeatmap.TotalBreakTime;
-
-        public IReadOnlyList<HitObject> HitObjects => PlayableBeatmap.HitObjects;
-
-        public IEnumerable<BeatmapStatistic> GetStatistics() => PlayableBeatmap.GetStatistics();
-
-        public double GetMostCommonBeatLength() => PlayableBeatmap.GetMostCommonBeatLength();
-
-        public IBeatmap Clone() => PlayableBeatmap.Clone();
-
-        private readonly Bindable<JudgementResult> lastJudgementResult = new Bindable<JudgementResult>();
-
-        public IBindable<JudgementResult> LastJudgementResult => lastJudgementResult;
-
-        public void ApplyResult(JudgementResult result) => lastJudgementResult.Value = result;
-    }
-}

osu.Game/Screens/Play/GameplayState.cs

@@ -0,0 +1,55 @@
+// 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.Collections.Generic;
+using osu.Framework.Bindables;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
+
+#nullable enable
+
+namespace osu.Game.Screens.Play
+{
+    /// <summary>
+    /// The state of an active gameplay session, generally constructed and exposed by <see cref="Player"/>.
+    /// </summary>
+    public class GameplayState
+    {
+        /// <summary>
+        /// The final post-convert post-mod-application beatmap.
+        /// </summary>
+        public readonly IBeatmap Beatmap;
+
+        /// <summary>
+        /// The ruleset used in gameplay.
+        /// </summary>
+        public readonly Ruleset Ruleset;
+
+        /// <summary>
+        /// The mods applied to the gameplay.
+        /// </summary>
+        public IReadOnlyList<Mod> Mods;
+
+        /// <summary>
+        /// A bindable tracking the last judgement result applied to any hit object.
+        /// </summary>
+        public IBindable<JudgementResult> LastJudgementResult => lastJudgementResult;
+
+        private readonly Bindable<JudgementResult> lastJudgementResult = new Bindable<JudgementResult>();
+
+        public GameplayState(IBeatmap beatmap, Ruleset ruleset, IReadOnlyList<Mod> mods)
+        {
+            Beatmap = beatmap;
+            Ruleset = ruleset;
+            Mods = mods;
+        }
+
+        /// <summary>
+        /// Applies the score change of a <see cref="JudgementResult"/> to this <see cref="GameplayState"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="JudgementResult"/> to apply.</param>
+        public void ApplyResult(JudgementResult result) => lastJudgementResult.Value = result;
+    }
+}

osu.Game/Screens/Play/Player.cs

@@ -93,9 +93,9 @@ namespace osu.Game.Screens.Play
         [Resolved]
         private SpectatorClient spectatorClient { get; set; }
 
-        protected Ruleset GameplayRuleset { get; private set; }
+        public GameplayState GameplayState { get; private set; }
 
-        protected GameplayBeatmap GameplayBeatmap { get; private set; }
+        private Ruleset ruleset;
 
         private Sample sampleRestart;
 
@@ -165,7 +165,7 @@ namespace osu.Game.Screens.Play
 
             // ensure the score is in a consistent state with the current player.
             Score.ScoreInfo.Beatmap = Beatmap.Value.BeatmapInfo;
-            Score.ScoreInfo.Ruleset = GameplayRuleset.RulesetInfo;
+            Score.ScoreInfo.Ruleset = ruleset.RulesetInfo;
             Score.ScoreInfo.Mods = Mods.Value.ToArray();
 
             PrepareReplay();
@@ -206,16 +206,16 @@ namespace osu.Game.Screens.Play
             if (game is OsuGame osuGame)
                 LocalUserPlaying.BindTo(osuGame.LocalUserPlaying);
 
-            DrawableRuleset = GameplayRuleset.CreateDrawableRulesetWith(playableBeatmap, Mods.Value);
+            DrawableRuleset = ruleset.CreateDrawableRulesetWith(playableBeatmap, Mods.Value);
             dependencies.CacheAs(DrawableRuleset);
 
-            ScoreProcessor = GameplayRuleset.CreateScoreProcessor();
+            ScoreProcessor = ruleset.CreateScoreProcessor();
             ScoreProcessor.ApplyBeatmap(playableBeatmap);
             ScoreProcessor.Mods.BindTo(Mods);
 
             dependencies.CacheAs(ScoreProcessor);
 
-            HealthProcessor = GameplayRuleset.CreateHealthProcessor(playableBeatmap.HitObjects[0].StartTime);
+            HealthProcessor = ruleset.CreateHealthProcessor(playableBeatmap.HitObjects[0].StartTime);
             HealthProcessor.ApplyBeatmap(playableBeatmap);
 
             dependencies.CacheAs(HealthProcessor);
@@ -225,12 +225,11 @@ namespace osu.Game.Screens.Play
 
             InternalChild = GameplayClockContainer = CreateGameplayClockContainer(Beatmap.Value, DrawableRuleset.GameplayStartTime);
 
-            AddInternal(GameplayBeatmap = new GameplayBeatmap(playableBeatmap));
+            dependencies.CacheAs(GameplayState = new GameplayState(playableBeatmap, ruleset, Mods.Value));
+
             AddInternal(screenSuspension = new ScreenSuspensionHandler(GameplayClockContainer));
 
-            dependencies.CacheAs(GameplayBeatmap);
+            var rulesetSkinProvider = new RulesetSkinProvidingContainer(ruleset, playableBeatmap, Beatmap.Value.Skin);
-
-            var rulesetSkinProvider = new RulesetSkinProvidingContainer(GameplayRuleset, playableBeatmap, Beatmap.Value.Skin);
 
             // load the skinning hierarchy first.
             // this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.
@@ -280,7 +279,7 @@ namespace osu.Game.Screens.Play
             {
                 HealthProcessor.ApplyResult(r);
                 ScoreProcessor.ApplyResult(r);
-                GameplayBeatmap.ApplyResult(r);
+                GameplayState.ApplyResult(r);
             };
 
             DrawableRuleset.RevertResult += r =>
@@ -478,17 +477,17 @@ namespace osu.Game.Screens.Play
                     throw new InvalidOperationException("Beatmap was not loaded");
 
                 var rulesetInfo = Ruleset.Value ?? Beatmap.Value.BeatmapInfo.Ruleset;
-                GameplayRuleset = rulesetInfo.CreateInstance();
+                ruleset = rulesetInfo.CreateInstance();
 
                 try
                 {
-                    playable = Beatmap.Value.GetPlayableBeatmap(GameplayRuleset.RulesetInfo, Mods.Value);
+                    playable = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo, Mods.Value);
                 }
                 catch (BeatmapInvalidForRulesetException)
                 {
                     // A playable beatmap may not be creatable with the user's preferred ruleset, so try using the beatmap's default ruleset
                     rulesetInfo = Beatmap.Value.BeatmapInfo.Ruleset;
-                    GameplayRuleset = rulesetInfo.CreateInstance();
+                    ruleset = rulesetInfo.CreateInstance();
 
                     playable = Beatmap.Value.GetPlayableBeatmap(rulesetInfo, Mods.Value);
                 }
@@ -1010,7 +1009,7 @@ namespace osu.Game.Screens.Play
 
             using (var stream = new MemoryStream())
             {
-                new LegacyScoreEncoder(score, GameplayBeatmap.PlayableBeatmap).Encode(stream);
+                new LegacyScoreEncoder(score, GameplayState.Beatmap).Encode(stream);
                 replayReader = new LegacyByteArrayReader(stream.ToArray(), "replay.osr");
             }
 

osu.Game/Screens/Play/ReplayPlayer.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Screens.Play
             DrawableRuleset?.SetReplayScore(Score);
         }
 
-        protected override Score CreateScore() => createScore(GameplayBeatmap.PlayableBeatmap, Mods.Value);
+        protected override Score CreateScore() => createScore(GameplayState.Beatmap, Mods.Value);
 
         // Don't re-import replay scores as they're already present in the database.
         protected override Task ImportScore(Score score) => Task.CompletedTask;
@@ -78,7 +78,7 @@ namespace osu.Game.Screens.Play
 
             void keyboardSeek(int direction)
             {
-                double target = Math.Clamp(GameplayClockContainer.CurrentTime + direction * keyboard_seek_amount, 0, GameplayBeatmap.HitObjects.Last().GetEndTime());
+                double target = Math.Clamp(GameplayClockContainer.CurrentTime + direction * keyboard_seek_amount, 0, GameplayState.Beatmap.HitObjects.Last().GetEndTime());
 
                 Seek(target);
             }

osu.Game/Screens/Play/SoloSpectator.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Screens.Play
         /// The player's immediate online gameplay state.
         /// This doesn't always reflect the gameplay state being watched.
         /// </summary>
-        private GameplayState immediateGameplayState;
+        private SpectatorGameplayState immediateSpectatorGameplayState;
 
         private GetBeatmapSetRequest onlineBeatmapRequest;
 
@@ -146,7 +146,7 @@ namespace osu.Game.Screens.Play
                                 Width = 250,
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
-                                Action = () => scheduleStart(immediateGameplayState),
+                                Action = () => scheduleStart(immediateSpectatorGameplayState),
                                 Enabled = { Value = false }
                             }
                         }
@@ -167,18 +167,18 @@ namespace osu.Game.Screens.Play
             showBeatmapPanel(spectatorState);
         }
 
-        protected override void StartGameplay(int userId, GameplayState gameplayState)
+        protected override void StartGameplay(int userId, SpectatorGameplayState spectatorGameplayState)
         {
-            immediateGameplayState = gameplayState;
+            immediateSpectatorGameplayState = spectatorGameplayState;
             watchButton.Enabled.Value = true;
 
-            scheduleStart(gameplayState);
+            scheduleStart(spectatorGameplayState);
         }
 
         protected override void EndGameplay(int userId)
         {
             scheduledStart?.Cancel();
-            immediateGameplayState = null;
+            immediateSpectatorGameplayState = null;
             watchButton.Enabled.Value = false;
 
             clearDisplay();
@@ -194,7 +194,7 @@ namespace osu.Game.Screens.Play
 
         private ScheduledDelegate scheduledStart;
 
-        private void scheduleStart(GameplayState gameplayState)
+        private void scheduleStart(SpectatorGameplayState spectatorGameplayState)
         {
             // This function may be called multiple times in quick succession once the screen becomes current again.
             scheduledStart?.Cancel();
@@ -203,15 +203,15 @@ namespace osu.Game.Screens.Play
                 if (this.IsCurrentScreen())
                     start();
                 else
-                    scheduleStart(gameplayState);
+                    scheduleStart(spectatorGameplayState);
             });
 
             void start()
             {
-                Beatmap.Value = gameplayState.Beatmap;
+                Beatmap.Value = spectatorGameplayState.Beatmap;
-                Ruleset.Value = gameplayState.Ruleset.RulesetInfo;
+                Ruleset.Value = spectatorGameplayState.Ruleset.RulesetInfo;
 
-                this.Push(new SpectatorPlayerLoader(gameplayState.Score, () => new SoloSpectatorPlayer(gameplayState.Score)));
+                this.Push(new SpectatorPlayerLoader(spectatorGameplayState.Score, () => new SoloSpectatorPlayer(spectatorGameplayState.Score)));
             }
         }
 

osu.Game/Screens/Play/SpectatorPlayer.cs

@@ -66,8 +66,8 @@ namespace osu.Game.Screens.Play
 
             foreach (var frame in bundle.Frames)
             {
-                IConvertibleReplayFrame convertibleFrame = GameplayRuleset.CreateConvertibleReplayFrame();
+                IConvertibleReplayFrame convertibleFrame = GameplayState.Ruleset.CreateConvertibleReplayFrame();
-                convertibleFrame.FromLegacy(frame, GameplayBeatmap.PlayableBeatmap);
+                convertibleFrame.FromLegacy(frame, GameplayState.Beatmap);
 
                 var convertedFrame = (ReplayFrame)convertibleFrame;
                 convertedFrame.Time = frame.Time;

osu.Game/Screens/Spectate/SpectatorGameplayState.cs

@@ -8,9 +8,9 @@ using osu.Game.Scoring;
 namespace osu.Game.Screens.Spectate
 {
     /// <summary>
-    /// The gameplay state of a spectated user. This class is immutable.
+    /// An immutable spectator gameplay state.
     /// </summary>
-    public class GameplayState
+    public class SpectatorGameplayState
     {
         /// <summary>
         /// The score which the user is playing.
@@ -27,7 +27,7 @@ namespace osu.Game.Screens.Spectate
         /// </summary>
         public readonly WorkingBeatmap Beatmap;
 
-        public GameplayState(Score score, Ruleset ruleset, WorkingBeatmap beatmap)
+        public SpectatorGameplayState(Score score, Ruleset ruleset, WorkingBeatmap beatmap)
         {
             Score = score;
             Ruleset = ruleset;

osu.Game/Screens/Spectate/SpectatorScreen.cs

@@ -43,7 +43,7 @@ namespace osu.Game.Screens.Spectate
         private readonly IBindableDictionary<int, SpectatorState> playingUserStates = new BindableDictionary<int, SpectatorState>();
 
         private readonly Dictionary<int, User> userMap = new Dictionary<int, User>();
-        private readonly Dictionary<int, GameplayState> gameplayStates = new Dictionary<int, GameplayState>();
+        private readonly Dictionary<int, SpectatorGameplayState> gameplayStates = new Dictionary<int, SpectatorGameplayState>();
 
         private IBindable<WeakReference<BeatmapSetInfo>> managerUpdated;
 
@@ -173,7 +173,7 @@ namespace osu.Game.Screens.Spectate
                 Replay = new Replay { HasReceivedAllFrames = false },
             };
 
-            var gameplayState = new GameplayState(score, resolvedRuleset, beatmaps.GetWorkingBeatmap(resolvedBeatmap));
+            var gameplayState = new SpectatorGameplayState(score, resolvedRuleset, beatmaps.GetWorkingBeatmap(resolvedBeatmap));
 
             gameplayStates[userId] = gameplayState;
             Schedule(() => StartGameplay(userId, gameplayState));
@@ -190,8 +190,8 @@ namespace osu.Game.Screens.Spectate
         /// Starts gameplay for a user.
         /// </summary>
         /// <param name="userId">The user to start gameplay for.</param>
-        /// <param name="gameplayState">The gameplay state.</param>
+        /// <param name="spectatorGameplayState">The gameplay state.</param>
-        protected abstract void StartGameplay(int userId, [NotNull] GameplayState gameplayState);
+        protected abstract void StartGameplay(int userId, [NotNull] SpectatorGameplayState spectatorGameplayState);
 
         /// <summary>
         /// Ends gameplay for a user.

osu.Game/Skinning/Skin.cs

@@ -11,6 +11,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.Logging;
 using osu.Game.Audio;
 using osu.Game.IO;
 using osu.Game.Screens.Play.HUD;
@@ -55,13 +56,20 @@ namespace osu.Game.Skinning
                 if (bytes == null)
                     continue;
 
-                string jsonContent = Encoding.UTF8.GetString(bytes);
+                try
-                var deserializedContent = JsonConvert.DeserializeObject<IEnumerable<SkinnableInfo>>(jsonContent);
+                {
+                    string jsonContent = Encoding.UTF8.GetString(bytes);
+                    var deserializedContent = JsonConvert.DeserializeObject<IEnumerable<SkinnableInfo>>(jsonContent);
 
-                if (deserializedContent == null)
+                    if (deserializedContent == null)
-                    continue;
+                        continue;
 
-                DrawableComponentInfo[skinnableTarget] = deserializedContent.ToArray();
+                    DrawableComponentInfo[skinnableTarget] = deserializedContent.ToArray();
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex, "Failed to load skin configuration.");
+                }
             }
         }
 

osu.Game/Storyboards/CommandLoop.cs

@@ -1,6 +1,7 @@
 // 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 System.Collections.Generic;
 
 namespace osu.Game.Storyboards
@@ -8,20 +9,31 @@ namespace osu.Game.Storyboards
     public class CommandLoop : CommandTimelineGroup
     {
         public double LoopStartTime;
-        public int LoopCount;
+
+        /// <summary>
+        /// The total number of times this loop is played back. Always greater than zero.
+        /// </summary>
+        public readonly int TotalIterations;
 
         public override double StartTime => LoopStartTime + CommandsStartTime;
-        public override double EndTime => StartTime + CommandsDuration * LoopCount;
+        public override double EndTime => StartTime + CommandsDuration * TotalIterations;
 
-        public CommandLoop(double startTime, int loopCount)
+        /// <summary>
+        /// Construct a new command loop.
+        /// </summary>
+        /// <param name="startTime">The start time of the loop.</param>
+        /// <param name="repeatCount">The number of times the loop should repeat. Should be greater than zero. Zero means a single playback.</param>
+        public CommandLoop(double startTime, int repeatCount)
         {
+            if (repeatCount < 0) throw new ArgumentException("Repeat count must be zero or above.", nameof(repeatCount));
+
             LoopStartTime = startTime;
-            LoopCount = loopCount;
+            TotalIterations = repeatCount + 1;
         }
 
         public override IEnumerable<CommandTimeline<T>.TypedCommand> GetCommands<T>(CommandTimelineSelector<T> timelineSelector, double offset = 0)
         {
-            for (var loop = 0; loop < LoopCount; loop++)
+            for (var loop = 0; loop < TotalIterations; loop++)
             {
                 var loopOffset = LoopStartTime + loop * CommandsDuration;
                 foreach (var command in base.GetCommands(timelineSelector, offset + loopOffset))
@@ -30,6 +42,6 @@ namespace osu.Game.Storyboards
         }
 
         public override string ToString()
-            => $"{LoopStartTime} x{LoopCount}";
+            => $"{LoopStartTime} x{TotalIterations}";
     }
 }

osu.Game/Storyboards/StoryboardSprite.cs

@@ -1,13 +1,13 @@
 // 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 osuTK;
-using osu.Framework.Graphics;
-using osu.Game.Storyboards.Drawables;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
+using osu.Framework.Graphics;
+using osu.Game.Storyboards.Drawables;
+using osuTK;
 
 namespace osu.Game.Storyboards
 {
@@ -78,9 +78,9 @@ namespace osu.Game.Storyboards
             InitialPosition = initialPosition;
         }
 
-        public CommandLoop AddLoop(double startTime, int loopCount)
+        public CommandLoop AddLoop(double startTime, int repeatCount)
         {
-            var loop = new CommandLoop(startTime, loopCount);
+            var loop = new CommandLoop(startTime, repeatCount);
             loops.Add(loop);
             return loop;
         }

osu.Game/Tests/Visual/TestPlayer.cs

@@ -84,7 +84,7 @@ namespace osu.Game.Tests.Visual
 
             if (autoplayMod != null)
             {
-                DrawableRuleset?.SetReplayScore(autoplayMod.CreateReplayScore(GameplayBeatmap.PlayableBeatmap, Mods.Value));
+                DrawableRuleset?.SetReplayScore(autoplayMod.CreateReplayScore(GameplayState.Beatmap, Mods.Value));
                 return;
             }
 

osu.Game/osu.Game.csproj

@@ -37,7 +37,7 @@
     </PackageReference>
     <PackageReference Include="Realm" Version="10.6.0" />
     <PackageReference Include="ppy.osu.Framework" Version="2021.929.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1004.0" />
     <PackageReference Include="Sentry" Version="3.9.4" />
     <PackageReference Include="SharpCompress" Version="0.29.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />

osu.iOS.props

@@ -71,7 +71,7 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.929.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1004.0" />
   </ItemGroup>
   <!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
   <PropertyGroup>