From 19a0eaade9b48f65bbf51ebbac98ba32b98b9dba Mon Sep 17 00:00:00 2001
From: Sebastian Krajewski <mail@wieku.me>
Date: Thu, 6 Aug 2020 04:41:44 +0200
Subject: [PATCH 01/25] Allow storyboard sprites to load textures from skins

---
 .../Drawables/DrawableStoryboardSprite.cs     | 39 ++++++++++++++++---
 1 file changed, 34 insertions(+), 5 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index d8d3248659..d40af903a6 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Skinning;
 
 namespace osu.Game.Storyboards.Drawables
 {
@@ -17,6 +18,12 @@ namespace osu.Game.Storyboards.Drawables
     {
         public StoryboardSprite Sprite { get; }
 
+        private ISkinSource currentSkin;
+
+        private TextureStore storyboardTextureStore;
+
+        private string texturePath;
+
         private bool flipH;
 
         public bool FlipH
@@ -114,14 +121,36 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
+        private void load(ISkinSource skin, IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
         {
-            var path = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-            if (path == null)
-                return;
+            if (skin != null)
+            {
+                currentSkin = skin;
+                skin.SourceChanged += onChange;
+            }
+
+            storyboardTextureStore = textureStore;
+
+            texturePath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
+
+            skinChanged();
 
-            Texture = textureStore.Get(path);
             Sprite.ApplyTransforms(this);
         }
+
+        private void onChange() =>
+            // schedule required to avoid calls after disposed.
+            // note that this has the side-effect of components only performing a possible texture change when they are alive.
+            Scheduler.AddOnce(skinChanged);
+
+        private void skinChanged()
+        {
+            var newTexture = currentSkin?.GetTexture(Sprite.Path) ?? storyboardTextureStore?.Get(texturePath);
+
+            if (Texture == newTexture) return;
+
+            Size = Vector2.Zero; // Sprite size needs to be recalculated (e.g. aspect ratio of combo number textures may differ between skins)
+            Texture = newTexture;
+        }
     }
 }

From e0ae2b3ebf20e1454af64b001e81365e301f221b Mon Sep 17 00:00:00 2001
From: Sebastian Krajewski <mail@wieku.me>
Date: Thu, 6 Aug 2020 17:07:36 +0200
Subject: [PATCH 02/25] Switch to SkinReloadableDrawable

---
 .../Drawables/DrawableStoryboardSprite.cs     | 30 ++++++++-----------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index d40af903a6..d4f27bf4aa 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -14,11 +14,11 @@ using osu.Game.Skinning;
 
 namespace osu.Game.Storyboards.Drawables
 {
-    public class DrawableStoryboardSprite : Sprite, IFlippable, IVectorScalable
+    public class DrawableStoryboardSprite : SkinReloadableDrawable, IFlippable, IVectorScalable
     {
         public StoryboardSprite Sprite { get; }
 
-        private ISkinSource currentSkin;
+        private Sprite drawableSprite;
 
         private TextureStore storyboardTextureStore;
 
@@ -123,34 +123,28 @@ namespace osu.Game.Storyboards.Drawables
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
         {
-            if (skin != null)
+            InternalChild = drawableSprite = new Sprite
             {
-                currentSkin = skin;
-                skin.SourceChanged += onChange;
-            }
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
 
             storyboardTextureStore = textureStore;
 
             texturePath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
 
-            skinChanged();
-
             Sprite.ApplyTransforms(this);
         }
 
-        private void onChange() =>
-            // schedule required to avoid calls after disposed.
-            // note that this has the side-effect of components only performing a possible texture change when they are alive.
-            Scheduler.AddOnce(skinChanged);
-
-        private void skinChanged()
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
         {
-            var newTexture = currentSkin?.GetTexture(Sprite.Path) ?? storyboardTextureStore?.Get(texturePath);
+            base.SkinChanged(skin, allowFallback);
+            var newTexture = skin?.GetTexture(Sprite.Path) ?? storyboardTextureStore?.Get(texturePath);
 
-            if (Texture == newTexture) return;
+            if (drawableSprite.Texture == newTexture) return;
 
-            Size = Vector2.Zero; // Sprite size needs to be recalculated (e.g. aspect ratio of combo number textures may differ between skins)
-            Texture = newTexture;
+            drawableSprite.Size = Vector2.Zero; // Sprite size needs to be recalculated (e.g. aspect ratio of combo number textures may differ between skins)
+            drawableSprite.Texture = newTexture;
         }
     }
 }

From 7cf225520fdfb93bffc18fc84eed087aa29d7cea Mon Sep 17 00:00:00 2001
From: Sebastian Krajewski <mail@wieku.me>
Date: Sat, 8 Aug 2020 02:43:39 +0200
Subject: [PATCH 03/25] Change from BDL to Resolved

---
 osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index d4f27bf4aa..45c74da892 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -20,7 +20,8 @@ namespace osu.Game.Storyboards.Drawables
 
         private Sprite drawableSprite;
 
-        private TextureStore storyboardTextureStore;
+        [Resolved]
+        private TextureStore storyboardTextureStore { get; set; }
 
         private string texturePath;
 
@@ -121,7 +122,7 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(ISkinSource skin, IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
+        private void load(IBindable<WorkingBeatmap> beatmap)
         {
             InternalChild = drawableSprite = new Sprite
             {
@@ -129,8 +130,6 @@ namespace osu.Game.Storyboards.Drawables
                 Origin = Anchor.Centre
             };
 
-            storyboardTextureStore = textureStore;
-
             texturePath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
 
             Sprite.ApplyTransforms(this);

From cf76d777623d32947d1285384c71f540a586dea3 Mon Sep 17 00:00:00 2001
From: Sebastian Krajewski <mail@wieku.me>
Date: Fri, 9 Oct 2020 17:34:01 +0200
Subject: [PATCH 04/25] Fix osu!classic skin elements not showing up in
 storyboards

---
 osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index 45c74da892..cd09cafbce 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.IO;
 using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -138,7 +139,8 @@ namespace osu.Game.Storyboards.Drawables
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
         {
             base.SkinChanged(skin, allowFallback);
-            var newTexture = skin?.GetTexture(Sprite.Path) ?? storyboardTextureStore?.Get(texturePath);
+
+            var newTexture = skin?.GetTexture(Path.GetFileNameWithoutExtension(Sprite.Path)) ?? storyboardTextureStore?.Get(texturePath);
 
             if (drawableSprite.Texture == newTexture) return;
 

From f41fc71e42c9301889a8cff230a723a8ba8007d8 Mon Sep 17 00:00:00 2001
From: Sebastian Krajewski <mail@wieku.me>
Date: Fri, 9 Oct 2020 18:02:21 +0200
Subject: [PATCH 05/25] Allow storyboard animations to load textures from skins

---
 .../Drawables/DrawableStoryboardAnimation.cs  | 47 +++++++++++++++----
 1 file changed, 39 insertions(+), 8 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
index 72e52f6106..963cf37fea 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.IO;
 using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -10,13 +12,22 @@ using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Skinning;
 
 namespace osu.Game.Storyboards.Drawables
 {
-    public class DrawableStoryboardAnimation : TextureAnimation, IFlippable, IVectorScalable
+    public class DrawableStoryboardAnimation : SkinReloadableDrawable, IFlippable, IVectorScalable
     {
         public StoryboardAnimation Animation { get; }
 
+        private TextureAnimation drawableTextureAnimation;
+
+        [Resolved]
+        private TextureStore storyboardTextureStore { get; set; }
+
+        private readonly List<string> texturePathsRaw = new List<string>();
+        private readonly List<string> texturePaths = new List<string>();
+
         private bool flipH;
 
         public bool FlipH
@@ -108,28 +119,48 @@ namespace osu.Game.Storyboards.Drawables
             Animation = animation;
             Origin = animation.Origin;
             Position = animation.InitialPosition;
-            Loop = animation.LoopType == AnimationLoopType.LoopForever;
 
             LifetimeStart = animation.StartTime;
             LifetimeEnd = animation.EndTime;
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
+        private void load(IBindable<WorkingBeatmap> beatmap)
         {
+            InternalChild = drawableTextureAnimation = new TextureAnimation
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Loop = Animation.LoopType == AnimationLoopType.LoopForever
+            };
+
             for (var frame = 0; frame < Animation.FrameCount; frame++)
             {
                 var framePath = Animation.Path.Replace(".", frame + ".");
+                texturePathsRaw.Add(Path.GetFileNameWithoutExtension(framePath));
 
                 var path = beatmap.Value.BeatmapSetInfo.Files.Find(f => f.Filename.Equals(framePath, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-                if (path == null)
-                    continue;
-
-                var texture = textureStore.Get(path);
-                AddFrame(texture, Animation.FrameDelay);
+                texturePaths.Add(path);
             }
 
             Animation.ApplyTransforms(this);
         }
+
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        {
+            base.SkinChanged(skin, allowFallback);
+
+            drawableTextureAnimation.ClearFrames();
+
+            for (var frame = 0; frame < Animation.FrameCount; frame++)
+            {
+                var texture = skin?.GetTexture(texturePathsRaw[frame]) ?? storyboardTextureStore?.Get(texturePaths[frame]);
+
+                if (texture == null)
+                    continue;
+
+                drawableTextureAnimation.AddFrame(texture, Animation.FrameDelay);
+            }
+        }
     }
 }

From 2c7880e9d6118d01ca5c0150780f1cf136c357df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Tue, 20 Oct 2020 18:27:03 +0200
Subject: [PATCH 06/25] Add failing test case

---
 .../Visual/Gameplay/TestScenePlayerLoader.cs  | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs
index 888a2f2197..9b31dd045a 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs
@@ -265,6 +265,26 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
             AddAssert($"epilepsy warning {(warning ? "present" : "absent")}", () => this.ChildrenOfType<EpilepsyWarning>().Any() == warning);
+
+            if (warning)
+            {
+                AddUntilStep("sound volume decreased", () => Beatmap.Value.Track.AggregateVolume.Value == 0.25);
+                AddUntilStep("sound volume restored", () => Beatmap.Value.Track.AggregateVolume.Value == 1);
+            }
+        }
+
+        [Test]
+        public void TestEpilepsyWarningEarlyExit()
+        {
+            AddStep("set epilepsy warning", () => epilepsyWarning = true);
+            AddStep("load dummy beatmap", () => ResetPlayer(false));
+
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
+
+            AddUntilStep("wait for epilepsy warning", () => loader.ChildrenOfType<EpilepsyWarning>().Single().Alpha > 0);
+            AddStep("exit early", () => loader.Exit());
+
+            AddUntilStep("sound volume restored", () => Beatmap.Value.Track.AggregateVolume.Value == 1);
         }
 
         private class TestPlayerLoaderContainer : Container

From e54836a63e4051bc517d1d044cfe566490fabf33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Mon, 19 Oct 2020 22:27:59 +0200
Subject: [PATCH 07/25] Use SkinnableSprite to avoid unnecessary reloads

---
 .../Drawables/DrawableStoryboardAnimation.cs  | 52 +++++--------------
 .../Drawables/DrawableStoryboardSprite.cs     | 39 ++++----------
 2 files changed, 24 insertions(+), 67 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
index 963cf37fea..c3b6dde44b 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
@@ -2,13 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.IO;
 using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -16,18 +15,10 @@ using osu.Game.Skinning;
 
 namespace osu.Game.Storyboards.Drawables
 {
-    public class DrawableStoryboardAnimation : SkinReloadableDrawable, IFlippable, IVectorScalable
+    public class DrawableStoryboardAnimation : DrawableAnimation, IFlippable, IVectorScalable
     {
         public StoryboardAnimation Animation { get; }
 
-        private TextureAnimation drawableTextureAnimation;
-
-        [Resolved]
-        private TextureStore storyboardTextureStore { get; set; }
-
-        private readonly List<string> texturePathsRaw = new List<string>();
-        private readonly List<string> texturePaths = new List<string>();
-
         private bool flipH;
 
         public bool FlipH
@@ -119,48 +110,31 @@ namespace osu.Game.Storyboards.Drawables
             Animation = animation;
             Origin = animation.Origin;
             Position = animation.InitialPosition;
+            Loop = animation.LoopType == AnimationLoopType.LoopForever;
 
             LifetimeStart = animation.StartTime;
             LifetimeEnd = animation.EndTime;
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap)
+        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
         {
-            InternalChild = drawableTextureAnimation = new TextureAnimation
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Loop = Animation.LoopType == AnimationLoopType.LoopForever
-            };
-
             for (var frame = 0; frame < Animation.FrameCount; frame++)
             {
                 var framePath = Animation.Path.Replace(".", frame + ".");
-                texturePathsRaw.Add(Path.GetFileNameWithoutExtension(framePath));
 
-                var path = beatmap.Value.BeatmapSetInfo.Files.Find(f => f.Filename.Equals(framePath, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-                texturePaths.Add(path);
+                var storyboardPath = beatmap.Value.BeatmapSetInfo.Files.Find(f => f.Filename.Equals(framePath, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
+                var frameSprite = storyboardPath != null
+                    ? (Drawable)new Sprite
+                    {
+                        Texture = textureStore.Get(storyboardPath)
+                    }
+                    : new SkinnableSprite(framePath); // fall back to skin textures if not found in storyboard files.
+
+                AddFrame(frameSprite, Animation.FrameDelay);
             }
 
             Animation.ApplyTransforms(this);
         }
-
-        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-        {
-            base.SkinChanged(skin, allowFallback);
-
-            drawableTextureAnimation.ClearFrames();
-
-            for (var frame = 0; frame < Animation.FrameCount; frame++)
-            {
-                var texture = skin?.GetTexture(texturePathsRaw[frame]) ?? storyboardTextureStore?.Get(texturePaths[frame]);
-
-                if (texture == null)
-                    continue;
-
-                drawableTextureAnimation.AddFrame(texture, Animation.FrameDelay);
-            }
-        }
     }
 }
diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index cd09cafbce..95774de898 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -2,11 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.IO;
 using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
@@ -15,17 +15,10 @@ using osu.Game.Skinning;
 
 namespace osu.Game.Storyboards.Drawables
 {
-    public class DrawableStoryboardSprite : SkinReloadableDrawable, IFlippable, IVectorScalable
+    public class DrawableStoryboardSprite : CompositeDrawable, IFlippable, IVectorScalable
     {
         public StoryboardSprite Sprite { get; }
 
-        private Sprite drawableSprite;
-
-        [Resolved]
-        private TextureStore storyboardTextureStore { get; set; }
-
-        private string texturePath;
-
         private bool flipH;
 
         public bool FlipH
@@ -123,29 +116,19 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap)
+        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
         {
-            InternalChild = drawableSprite = new Sprite
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre
-            };
+            var storyboardPath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
+            var sprite = storyboardPath != null
+                ? (Drawable)new Sprite
+                {
+                    Texture = textureStore.Get(storyboardPath)
+                }
+                : new SkinnableSprite(Sprite.Path); // fall back to skin textures if not found in storyboard files.
 
-            texturePath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
+            InternalChild = sprite.With(s => s.Anchor = s.Origin = Anchor.Centre);
 
             Sprite.ApplyTransforms(this);
         }
-
-        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-        {
-            base.SkinChanged(skin, allowFallback);
-
-            var newTexture = skin?.GetTexture(Path.GetFileNameWithoutExtension(Sprite.Path)) ?? storyboardTextureStore?.Get(texturePath);
-
-            if (drawableSprite.Texture == newTexture) return;
-
-            drawableSprite.Size = Vector2.Zero; // Sprite size needs to be recalculated (e.g. aspect ratio of combo number textures may differ between skins)
-            drawableSprite.Texture = newTexture;
-        }
     }
 }

From cdd56ece871a9999288196a859033a44665a3c10 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Mon, 19 Oct 2020 23:32:04 +0200
Subject: [PATCH 08/25] Read UseSkinSprites when decoding storyboards

---
 .../Beatmaps/Formats/LegacyStoryboardDecoder.cs  | 16 ++++++++++++++++
 osu.Game/Storyboards/Storyboard.cs               |  5 +++++
 2 files changed, 21 insertions(+)

diff --git a/osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs b/osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs
index 269449ef80..e2550d1ca4 100644
--- a/osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs
@@ -48,6 +48,10 @@ namespace osu.Game.Beatmaps.Formats
 
             switch (section)
             {
+                case Section.General:
+                    handleGeneral(storyboard, line);
+                    return;
+
                 case Section.Events:
                     handleEvents(line);
                     return;
@@ -60,6 +64,18 @@ namespace osu.Game.Beatmaps.Formats
             base.ParseLine(storyboard, section, line);
         }
 
+        private void handleGeneral(Storyboard storyboard, string line)
+        {
+            var pair = SplitKeyVal(line);
+
+            switch (pair.Key)
+            {
+                case "UseSkinSprites":
+                    storyboard.UseSkinSprites = pair.Value == "1";
+                    break;
+            }
+        }
+
         private void handleEvents(string line)
         {
             var depth = 0;
diff --git a/osu.Game/Storyboards/Storyboard.cs b/osu.Game/Storyboards/Storyboard.cs
index b0fb583d62..daafdf015d 100644
--- a/osu.Game/Storyboards/Storyboard.cs
+++ b/osu.Game/Storyboards/Storyboard.cs
@@ -15,6 +15,11 @@ namespace osu.Game.Storyboards
 
         public BeatmapInfo BeatmapInfo = new BeatmapInfo();
 
+        /// <summary>
+        /// Whether the storyboard can fall back to skin sprites in case no matching storyboard sprites are found.
+        /// </summary>
+        public bool UseSkinSprites { get; set; }
+
         public bool HasDrawable => Layers.Any(l => l.Elements.Any(e => e.IsDrawable));
 
         public double FirstEventTime => Layers.Min(l => l.Elements.FirstOrDefault()?.StartTime ?? 0);

From 58a54c5b6c71c01315dd5effeb33f08a61449db0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Mon, 19 Oct 2020 23:40:20 +0200
Subject: [PATCH 09/25] Utilise UseSkinSprites value in storyboard sprite logic

---
 osu.Game/Storyboards/Drawables/DrawableStoryboard.cs  |  1 +
 .../Drawables/DrawableStoryboardAnimation.cs          | 11 ++++-------
 .../Storyboards/Drawables/DrawableStoryboardSprite.cs | 11 ++++-------
 3 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
index ec461fa095..4bc28e6cef 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
@@ -15,6 +15,7 @@ namespace osu.Game.Storyboards.Drawables
 {
     public class DrawableStoryboard : Container<DrawableStoryboardLayer>
     {
+        [Cached]
         public Storyboard Storyboard { get; }
 
         protected override Container<DrawableStoryboardLayer> Content { get; }
diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
index c3b6dde44b..8382f91d1f 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
@@ -117,19 +117,16 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
+        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore, Storyboard storyboard)
         {
             for (var frame = 0; frame < Animation.FrameCount; frame++)
             {
                 var framePath = Animation.Path.Replace(".", frame + ".");
 
                 var storyboardPath = beatmap.Value.BeatmapSetInfo.Files.Find(f => f.Filename.Equals(framePath, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-                var frameSprite = storyboardPath != null
-                    ? (Drawable)new Sprite
-                    {
-                        Texture = textureStore.Get(storyboardPath)
-                    }
-                    : new SkinnableSprite(framePath); // fall back to skin textures if not found in storyboard files.
+                var frameSprite = storyboard.UseSkinSprites && storyboardPath == null
+                    ? (Drawable)new SkinnableSprite(framePath)
+                    : new Sprite { Texture = textureStore.Get(storyboardPath) };
 
                 AddFrame(frameSprite, Animation.FrameDelay);
             }
diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index 95774de898..9599375c76 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -116,15 +116,12 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore)
+        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore, Storyboard storyboard)
         {
             var storyboardPath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-            var sprite = storyboardPath != null
-                ? (Drawable)new Sprite
-                {
-                    Texture = textureStore.Get(storyboardPath)
-                }
-                : new SkinnableSprite(Sprite.Path); // fall back to skin textures if not found in storyboard files.
+            var sprite = storyboard.UseSkinSprites && storyboardPath == null
+                ? (Drawable)new SkinnableSprite(Sprite.Path)
+                : new Sprite { Texture = textureStore.Get(storyboardPath) };
 
             InternalChild = sprite.With(s => s.Anchor = s.Origin = Anchor.Centre);
 

From 8c14c9e1c4eb36789b150d14e273e6b6ccf1f772 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Tue, 20 Oct 2020 22:42:47 +0200
Subject: [PATCH 10/25] Add basic test coverage

---
 .../TestSceneDrawableStoryboardSprite.cs      | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 osu.Game.Tests/Visual/Gameplay/TestSceneDrawableStoryboardSprite.cs

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableStoryboardSprite.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableStoryboardSprite.cs
new file mode 100644
index 0000000000..9501026edc
--- /dev/null
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableStoryboardSprite.cs
@@ -0,0 +1,65 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+using osu.Game.Storyboards.Drawables;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneDrawableStoryboardSprite : SkinnableTestScene
+    {
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [Cached]
+        private Storyboard storyboard { get; set; } = new Storyboard();
+
+        [Test]
+        public void TestSkinSpriteDisallowedByDefault()
+        {
+            const string lookup_name = "hitcircleoverlay";
+
+            AddStep("allow skin lookup", () => storyboard.UseSkinSprites = false);
+
+            AddStep("create sprites", () => SetContents(
+                () => createSprite(lookup_name, Anchor.TopLeft, Vector2.Zero)));
+
+            assertSpritesFromSkin(false);
+        }
+
+        [Test]
+        public void TestAllowLookupFromSkin()
+        {
+            const string lookup_name = "hitcircleoverlay";
+
+            AddStep("allow skin lookup", () => storyboard.UseSkinSprites = true);
+
+            AddStep("create sprites", () => SetContents(
+                () => createSprite(lookup_name, Anchor.Centre, Vector2.Zero)));
+
+            assertSpritesFromSkin(true);
+        }
+
+        private DrawableStoryboardSprite createSprite(string lookupName, Anchor origin, Vector2 initialPosition)
+            => new DrawableStoryboardSprite(
+                new StoryboardSprite(lookupName, origin, initialPosition)
+            ).With(s =>
+            {
+                s.LifetimeStart = double.MinValue;
+                s.LifetimeEnd = double.MaxValue;
+            });
+
+        private void assertSpritesFromSkin(bool fromSkin) =>
+            AddAssert($"sprites are {(fromSkin ? "from skin" : "from storyboard")}",
+                () => this.ChildrenOfType<DrawableStoryboardSprite>()
+                          .All(sprite => sprite.ChildrenOfType<SkinnableSprite>().Any() == fromSkin));
+    }
+}

From 670775cecbe8d642a229b22d5854f0c2f519383d Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Wed, 21 Oct 2020 18:57:48 +0200
Subject: [PATCH 11/25] Make beatmap wedge difficulty indicator color update
 dynamically.

---
 osu.Game/Screens/Select/BeatmapInfoWedge.cs | 26 +++++++++++++++------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index 2a3eb8c67a..6085e266d7 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -39,6 +39,11 @@ namespace osu.Game.Screens.Select
 
         private readonly IBindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
 
+        [Resolved]
+        private BeatmapDifficultyManager difficultyManager { get; set; }
+
+        private IBindable<StarDifficulty> beatmapDifficulty;
+
         protected BufferedWedgeInfo Info;
 
         public BeatmapInfoWedge()
@@ -88,6 +93,11 @@ namespace osu.Game.Screens.Select
                 if (beatmap == value) return;
 
                 beatmap = value;
+
+                beatmapDifficulty?.UnbindAll();
+                beatmapDifficulty = difficultyManager.GetBindableDifficulty(beatmap.BeatmapInfo);
+                beatmapDifficulty.BindValueChanged(_ => updateDisplay());
+
                 updateDisplay();
             }
         }
@@ -113,7 +123,7 @@ namespace osu.Game.Screens.Select
                 return;
             }
 
-            LoadComponentAsync(loadingInfo = new BufferedWedgeInfo(beatmap, ruleset.Value)
+            LoadComponentAsync(loadingInfo = new BufferedWedgeInfo(beatmap, ruleset.Value, beatmapDifficulty.Value)
             {
                 Shear = -Shear,
                 Depth = Info?.Depth + 1 ?? 0
@@ -141,12 +151,14 @@ namespace osu.Game.Screens.Select
 
             private readonly WorkingBeatmap beatmap;
             private readonly RulesetInfo ruleset;
+            private readonly StarDifficulty starDifficulty;
 
-            public BufferedWedgeInfo(WorkingBeatmap beatmap, RulesetInfo userRuleset)
+            public BufferedWedgeInfo(WorkingBeatmap beatmap, RulesetInfo userRuleset, StarDifficulty difficulty)
                 : base(pixelSnapping: true)
             {
                 this.beatmap = beatmap;
                 ruleset = userRuleset ?? beatmap.BeatmapInfo.Ruleset;
+                starDifficulty = difficulty;
             }
 
             [BackgroundDependencyLoader]
@@ -190,7 +202,7 @@ namespace osu.Game.Screens.Select
                             },
                         },
                     },
-                    new DifficultyColourBar(beatmapInfo)
+                    new DifficultyColourBar(starDifficulty)
                     {
                         RelativeSizeAxes = Axes.Y,
                         Width = 20,
@@ -447,11 +459,11 @@ namespace osu.Game.Screens.Select
 
             private class DifficultyColourBar : Container
             {
-                private readonly BeatmapInfo beatmap;
+                private readonly StarDifficulty difficulty;
 
-                public DifficultyColourBar(BeatmapInfo beatmap)
+                public DifficultyColourBar(StarDifficulty difficulty)
                 {
-                    this.beatmap = beatmap;
+                    this.difficulty = difficulty;
                 }
 
                 [BackgroundDependencyLoader]
@@ -459,7 +471,7 @@ namespace osu.Game.Screens.Select
                 {
                     const float full_opacity_ratio = 0.7f;
 
-                    var difficultyColour = colours.ForDifficultyRating(beatmap.DifficultyRating);
+                    var difficultyColour = colours.ForDifficultyRating(difficulty.DifficultyRating);
 
                     Children = new Drawable[]
                     {

From cf69eacae9164311f973d10eb60bebf96330456c Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Wed, 21 Oct 2020 19:05:14 +0200
Subject: [PATCH 12/25] Make StarRatingDisplay dynamic.

---
 .../Ranking/Expanded/StarRatingDisplay.cs     | 25 +++++++++++++++----
 osu.Game/Screens/Select/BeatmapInfoWedge.cs   |  6 ++---
 2 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs b/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
index 4b38b298f1..402ab99908 100644
--- a/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
+++ b/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
@@ -24,6 +24,8 @@ namespace osu.Game.Screens.Ranking.Expanded
     {
         private readonly BeatmapInfo beatmap;
 
+        private StarDifficulty? difficulty;
+
         /// <summary>
         /// Creates a new <see cref="StarRatingDisplay"/>.
         /// </summary>
@@ -31,20 +33,33 @@ namespace osu.Game.Screens.Ranking.Expanded
         public StarRatingDisplay(BeatmapInfo beatmap)
         {
             this.beatmap = beatmap;
-            AutoSizeAxes = Axes.Both;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="StarRatingDisplay"/> using an already computed <see cref="StarDifficulty"/>.
+        /// </summary>
+        /// <param name="starDifficulty">The already computed <see cref="StarDifficulty"/> to display the star difficulty of.</param>
+        public StarRatingDisplay(StarDifficulty starDifficulty)
+        {
+            difficulty = starDifficulty;
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load(OsuColour colours, BeatmapDifficultyManager difficultyManager)
         {
-            var starRatingParts = beatmap.StarDifficulty.ToString("0.00", CultureInfo.InvariantCulture).Split('.');
+            AutoSizeAxes = Axes.Both;
+
+            if (!difficulty.HasValue)
+                difficulty = difficultyManager.GetDifficulty(beatmap);
+
+            var starRatingParts = difficulty.Value.Stars.ToString("0.00", CultureInfo.InvariantCulture).Split('.');
             string wholePart = starRatingParts[0];
             string fractionPart = starRatingParts[1];
             string separator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
 
-            ColourInfo backgroundColour = beatmap.DifficultyRating == DifficultyRating.ExpertPlus
+            ColourInfo backgroundColour = difficulty.Value.DifficultyRating == DifficultyRating.ExpertPlus
                 ? ColourInfo.GradientVertical(Color4Extensions.FromHex("#C1C1C1"), Color4Extensions.FromHex("#595959"))
-                : (ColourInfo)colours.ForDifficultyRating(beatmap.DifficultyRating);
+                : (ColourInfo)colours.ForDifficultyRating(difficulty.Value.DifficultyRating);
 
             InternalChildren = new Drawable[]
             {
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index 6085e266d7..bdfcc2fd96 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -238,7 +238,7 @@ namespace osu.Game.Screens.Select
                         Shear = wedged_container_shear,
                         Children = new[]
                         {
-                            createStarRatingDisplay(beatmapInfo).With(display =>
+                            createStarRatingDisplay(starDifficulty).With(display =>
                             {
                                 display.Anchor = Anchor.TopRight;
                                 display.Origin = Anchor.TopRight;
@@ -305,8 +305,8 @@ namespace osu.Game.Screens.Select
                     StatusPill.Hide();
             }
 
-            private static Drawable createStarRatingDisplay(BeatmapInfo beatmapInfo) => beatmapInfo.StarDifficulty > 0
-                ? new StarRatingDisplay(beatmapInfo)
+            private static Drawable createStarRatingDisplay(StarDifficulty difficulty) => difficulty.Stars > 0
+                ? new StarRatingDisplay(difficulty)
                 {
                     Margin = new MarginPadding { Bottom = 5 }
                 }

From 5a00a05a95d3c7c1dba85a8beb2e4758da321942 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 22 Oct 2020 14:49:48 +0900
Subject: [PATCH 13/25] Add missing schedule call

---
 osu.Game/Overlays/Toolbar/ToolbarUserButton.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osu.Game/Overlays/Toolbar/ToolbarUserButton.cs b/osu.Game/Overlays/Toolbar/ToolbarUserButton.cs
index 9417224049..db4e491d9a 100644
--- a/osu.Game/Overlays/Toolbar/ToolbarUserButton.cs
+++ b/osu.Game/Overlays/Toolbar/ToolbarUserButton.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = login;
         }
 
-        private void onlineStateChanged(ValueChangedEvent<APIState> state)
+        private void onlineStateChanged(ValueChangedEvent<APIState> state) => Schedule(() =>
         {
             switch (state.NewValue)
             {
@@ -72,6 +72,6 @@ namespace osu.Game.Overlays.Toolbar
                     avatar.User = api.LocalUser.Value;
                     break;
             }
-        }
+        });
     }
 }

From c6db832efa940ee40d238fc036ab67b2f51f2c76 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 22 Oct 2020 14:56:20 +0900
Subject: [PATCH 14/25] Add xmldoc notes about thread safety of api bindables

---
 osu.Game/Online/API/IAPIProvider.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osu.Game/Online/API/IAPIProvider.cs b/osu.Game/Online/API/IAPIProvider.cs
index 256d2ed151..fc675639bf 100644
--- a/osu.Game/Online/API/IAPIProvider.cs
+++ b/osu.Game/Online/API/IAPIProvider.cs
@@ -11,11 +11,13 @@ namespace osu.Game.Online.API
     {
         /// <summary>
         /// The local user.
+        /// This is not thread-safe and should be scheduled locally if consumed from a drawable component.
         /// </summary>
         Bindable<User> LocalUser { get; }
 
         /// <summary>
         /// The current user's activity.
+        /// This is not thread-safe and should be scheduled locally if consumed from a drawable component.
         /// </summary>
         Bindable<UserActivity> Activity { get; }
 
@@ -35,6 +37,10 @@ namespace osu.Game.Online.API
         /// </summary>
         string Endpoint { get; }
 
+        /// <summary>
+        /// The current connection state of the API.
+        /// This is not thread-safe and should be scheduled locally if consumed from a drawable component.
+        /// </summary>
         IBindable<APIState> State { get; }
 
         /// <summary>

From 9141f48b047c0a59fa49c0dfadfef578900753f0 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 23 Oct 2020 14:57:27 +0900
Subject: [PATCH 15/25] Remove beatmap-based ctor to promote single flow

---
 .../Expanded/ExpandedPanelMiddleContent.cs    |  5 +++--
 .../Ranking/Expanded/StarRatingDisplay.cs     | 22 ++++---------------
 2 files changed, 7 insertions(+), 20 deletions(-)

diff --git a/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs b/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
index 5aac449adb..30747438c3 100644
--- a/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
+++ b/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
@@ -7,6 +7,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -51,7 +52,7 @@ namespace osu.Game.Screens.Ranking.Expanded
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(BeatmapDifficultyManager beatmapDifficultyManager)
         {
             var beatmap = score.Beatmap;
             var metadata = beatmap.BeatmapSet?.Metadata ?? beatmap.Metadata;
@@ -138,7 +139,7 @@ namespace osu.Game.Screens.Ranking.Expanded
                                     Spacing = new Vector2(5, 0),
                                     Children = new Drawable[]
                                     {
-                                        new StarRatingDisplay(beatmap)
+                                        new StarRatingDisplay(beatmapDifficultyManager.GetDifficulty(beatmap, score.Ruleset, score.Mods))
                                         {
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft
diff --git a/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs b/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
index 402ab99908..ffb12d474b 100644
--- a/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
+++ b/osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
@@ -22,18 +22,7 @@ namespace osu.Game.Screens.Ranking.Expanded
     /// </summary>
     public class StarRatingDisplay : CompositeDrawable
     {
-        private readonly BeatmapInfo beatmap;
-
-        private StarDifficulty? difficulty;
-
-        /// <summary>
-        /// Creates a new <see cref="StarRatingDisplay"/>.
-        /// </summary>
-        /// <param name="beatmap">The <see cref="BeatmapInfo"/> to display the star difficulty of.</param>
-        public StarRatingDisplay(BeatmapInfo beatmap)
-        {
-            this.beatmap = beatmap;
-        }
+        private readonly StarDifficulty difficulty;
 
         /// <summary>
         /// Creates a new <see cref="StarRatingDisplay"/> using an already computed <see cref="StarDifficulty"/>.
@@ -49,17 +38,14 @@ namespace osu.Game.Screens.Ranking.Expanded
         {
             AutoSizeAxes = Axes.Both;
 
-            if (!difficulty.HasValue)
-                difficulty = difficultyManager.GetDifficulty(beatmap);
-
-            var starRatingParts = difficulty.Value.Stars.ToString("0.00", CultureInfo.InvariantCulture).Split('.');
+            var starRatingParts = difficulty.Stars.ToString("0.00", CultureInfo.InvariantCulture).Split('.');
             string wholePart = starRatingParts[0];
             string fractionPart = starRatingParts[1];
             string separator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
 
-            ColourInfo backgroundColour = difficulty.Value.DifficultyRating == DifficultyRating.ExpertPlus
+            ColourInfo backgroundColour = difficulty.DifficultyRating == DifficultyRating.ExpertPlus
                 ? ColourInfo.GradientVertical(Color4Extensions.FromHex("#C1C1C1"), Color4Extensions.FromHex("#595959"))
-                : (ColourInfo)colours.ForDifficultyRating(difficulty.Value.DifficultyRating);
+                : (ColourInfo)colours.ForDifficultyRating(difficulty.DifficultyRating);
 
             InternalChildren = new Drawable[]
             {

From 9404096a28c49a2c9370d6dd2d07a893d86f82df Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 23 Oct 2020 15:06:00 +0900
Subject: [PATCH 16/25] Update tests to match new constructor

---
 .../Visual/Ranking/TestSceneStarRatingDisplay.cs   | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneStarRatingDisplay.cs b/osu.Game.Tests/Visual/Ranking/TestSceneStarRatingDisplay.cs
index d12f32e470..d0067c3396 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneStarRatingDisplay.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneStarRatingDisplay.cs
@@ -18,13 +18,13 @@ namespace osu.Game.Tests.Visual.Ranking
                 Origin = Anchor.Centre,
                 Children = new Drawable[]
                 {
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 1.23 }),
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 2.34 }),
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 3.45 }),
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 4.56 }),
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 5.67 }),
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 6.78 }),
-                    new StarRatingDisplay(new BeatmapInfo { StarDifficulty = 10.11 }),
+                    new StarRatingDisplay(new StarDifficulty(1.23, 0)),
+                    new StarRatingDisplay(new StarDifficulty(2.34, 0)),
+                    new StarRatingDisplay(new StarDifficulty(3.45, 0)),
+                    new StarRatingDisplay(new StarDifficulty(4.56, 0)),
+                    new StarRatingDisplay(new StarDifficulty(5.67, 0)),
+                    new StarRatingDisplay(new StarDifficulty(6.78, 0)),
+                    new StarRatingDisplay(new StarDifficulty(10.11, 0)),
                 }
             };
         }

From 1b84402b966744babc95e20790f83fa3061b9f8f Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 23 Oct 2020 15:33:38 +0900
Subject: [PATCH 17/25] Centralise and share logic for storyboard frame lookup
 method

---
 .../Drawables/DrawableStoryboardAnimation.cs  | 19 +++++--------------
 .../Drawables/DrawableStoryboardSprite.cs     | 16 +++++-----------
 osu.Game/Storyboards/Storyboard.cs            | 19 +++++++++++++++++++
 3 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
index 8382f91d1f..97de239e4a 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs
@@ -2,16 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osuTK;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
-using osu.Game.Beatmaps;
-using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Storyboards.Drawables
 {
@@ -117,18 +113,13 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore, Storyboard storyboard)
+        private void load(TextureStore textureStore, Storyboard storyboard)
         {
-            for (var frame = 0; frame < Animation.FrameCount; frame++)
+            for (int frame = 0; frame < Animation.FrameCount; frame++)
             {
-                var framePath = Animation.Path.Replace(".", frame + ".");
+                string framePath = Animation.Path.Replace(".", frame + ".");
 
-                var storyboardPath = beatmap.Value.BeatmapSetInfo.Files.Find(f => f.Filename.Equals(framePath, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-                var frameSprite = storyboard.UseSkinSprites && storyboardPath == null
-                    ? (Drawable)new SkinnableSprite(framePath)
-                    : new Sprite { Texture = textureStore.Get(storyboardPath) };
-
-                AddFrame(frameSprite, Animation.FrameDelay);
+                AddFrame(storyboard.CreateSpriteFromResourcePath(framePath, textureStore), Animation.FrameDelay);
             }
 
             Animation.ApplyTransforms(this);
diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index 9599375c76..1adbe688e7 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -2,16 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osuTK;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
-using osu.Game.Beatmaps;
-using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Storyboards.Drawables
 {
@@ -116,14 +112,12 @@ namespace osu.Game.Storyboards.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, TextureStore textureStore, Storyboard storyboard)
+        private void load(TextureStore textureStore, Storyboard storyboard)
         {
-            var storyboardPath = beatmap.Value.BeatmapSetInfo?.Files?.Find(f => f.Filename.Equals(Sprite.Path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-            var sprite = storyboard.UseSkinSprites && storyboardPath == null
-                ? (Drawable)new SkinnableSprite(Sprite.Path)
-                : new Sprite { Texture = textureStore.Get(storyboardPath) };
+            var drawable = storyboard.CreateSpriteFromResourcePath(Sprite.Path, textureStore);
 
-            InternalChild = sprite.With(s => s.Anchor = s.Origin = Anchor.Centre);
+            if (drawable != null)
+                InternalChild = drawable.With(s => s.Anchor = s.Origin = Anchor.Centre);
 
             Sprite.ApplyTransforms(this);
         }
diff --git a/osu.Game/Storyboards/Storyboard.cs b/osu.Game/Storyboards/Storyboard.cs
index daafdf015d..e0d18eab00 100644
--- a/osu.Game/Storyboards/Storyboard.cs
+++ b/osu.Game/Storyboards/Storyboard.cs
@@ -1,9 +1,14 @@
 // 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
+using osu.Game.Skinning;
 using osu.Game.Storyboards.Drawables;
 
 namespace osu.Game.Storyboards
@@ -69,5 +74,19 @@ namespace osu.Game.Storyboards
             drawable.Width = drawable.Height * (BeatmapInfo.WidescreenStoryboard ? 16 / 9f : 4 / 3f);
             return drawable;
         }
+
+        public Drawable CreateSpriteFromResourcePath(string path, TextureStore textureStore)
+        {
+            Drawable drawable = null;
+            var storyboardPath = BeatmapInfo.BeatmapSet?.Files?.Find(f => f.Filename.Equals(path, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
+
+            if (storyboardPath != null)
+                drawable = new Sprite { Texture = textureStore.Get(storyboardPath) };
+            // if the texture isn't available locally in the beatmap, some storyboards choose to source from the underlying skin lookup hierarchy.
+            else if (UseSkinSprites)
+                drawable = new SkinnableSprite(path);
+
+            return drawable;
+        }
     }
 }

From 4f746792fba1f427357675b0c054ff84b2bd95b0 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 23 Oct 2020 15:46:24 +0900
Subject: [PATCH 18/25] Fix regression causing storyboard sprites to have
 incorrect origin support

---
 osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
index 1adbe688e7..7b1a6d54da 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs
@@ -109,6 +109,8 @@ namespace osu.Game.Storyboards.Drawables
 
             LifetimeStart = sprite.StartTime;
             LifetimeEnd = sprite.EndTime;
+
+            AutoSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
@@ -117,7 +119,7 @@ namespace osu.Game.Storyboards.Drawables
             var drawable = storyboard.CreateSpriteFromResourcePath(Sprite.Path, textureStore);
 
             if (drawable != null)
-                InternalChild = drawable.With(s => s.Anchor = s.Origin = Anchor.Centre);
+                InternalChild = drawable;
 
             Sprite.ApplyTransforms(this);
         }

From 73174961f02f01123f1c3cef900bf8a9475d8e90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Tue, 20 Oct 2020 21:22:47 +0200
Subject: [PATCH 19/25] Rework animation sequence for readability

---
 osu.Game/Screens/Play/PlayerLoader.cs | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index fae0bfb295..be3bad1517 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -331,18 +331,11 @@ namespace osu.Game.Screens.Play
                     {
                         const double epilepsy_display_length = 3000;
 
-                        pushSequence.Schedule(() =>
-                        {
-                            epilepsyWarning.State.Value = Visibility.Visible;
-
-                            this.Delay(epilepsy_display_length).Schedule(() =>
-                            {
-                                epilepsyWarning.Hide();
-                                epilepsyWarning.Expire();
-                            });
-                        });
-
-                        pushSequence.Delay(epilepsy_display_length);
+                        pushSequence
+                            .Schedule(() => epilepsyWarning.State.Value = Visibility.Visible)
+                            .Delay(epilepsy_display_length)
+                            .Schedule(() => epilepsyWarning.Hide())
+                            .Delay(EpilepsyWarning.FADE_DURATION);
                     }
 
                     pushSequence.Schedule(() =>

From e101ba5cba4eb63ef287a60d7d1bd121893f741d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 24 Oct 2020 22:58:13 +0200
Subject: [PATCH 20/25] Move volume manipulations to player loader

---
 osu.Game/Screens/Play/EpilepsyWarning.cs | 18 ------------------
 osu.Game/Screens/Play/PlayerLoader.cs    | 23 +++++++++++++++++++++--
 2 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/osu.Game/Screens/Play/EpilepsyWarning.cs b/osu.Game/Screens/Play/EpilepsyWarning.cs
index e3cf0cd227..6121a0c2a3 100644
--- a/osu.Game/Screens/Play/EpilepsyWarning.cs
+++ b/osu.Game/Screens/Play/EpilepsyWarning.cs
@@ -2,8 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -18,11 +16,6 @@ namespace osu.Game.Screens.Play
 {
     public class EpilepsyWarning : VisibilityContainer
     {
-        public const double FADE_DURATION = 500;
-
-        private readonly BindableDouble trackVolumeOnEpilepsyWarning = new BindableDouble(1f);
-
-        private Track track;
 
         public EpilepsyWarning()
         {
@@ -77,26 +70,15 @@ namespace osu.Game.Screens.Play
                     }
                 }
             };
-
-            track = beatmap.Value.Track;
-            track.AddAdjustment(AdjustableProperty.Volume, trackVolumeOnEpilepsyWarning);
         }
 
         protected override void PopIn()
         {
-            this.TransformBindableTo(trackVolumeOnEpilepsyWarning, 0.25, FADE_DURATION);
-
             DimmableBackground?.FadeColour(OsuColour.Gray(0.5f), FADE_DURATION, Easing.OutQuint);
 
             this.FadeIn(FADE_DURATION, Easing.OutQuint);
         }
 
         protected override void PopOut() => this.FadeOut(FADE_DURATION);
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            track?.RemoveAdjustment(AdjustableProperty.Volume, trackVolumeOnEpilepsyWarning);
-        }
     }
 }
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index be3bad1517..fe774527b8 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -104,6 +104,9 @@ namespace osu.Game.Screens.Play
         [Resolved]
         private AudioManager audioManager { get; set; }
 
+        [Resolved]
+        private MusicController musicController { get; set; }
+
         public PlayerLoader(Func<Player> createPlayer)
         {
             this.createPlayer = createPlayer;
@@ -332,9 +335,17 @@ namespace osu.Game.Screens.Play
                         const double epilepsy_display_length = 3000;
 
                         pushSequence
-                            .Schedule(() => epilepsyWarning.State.Value = Visibility.Visible)
+                            .Schedule(() =>
+                            {
+                                musicController.CurrentTrack.VolumeTo(0.25, EpilepsyWarning.FADE_DURATION, Easing.OutQuint);
+                                epilepsyWarning.State.Value = Visibility.Visible;
+                            })
                             .Delay(epilepsy_display_length)
-                            .Schedule(() => epilepsyWarning.Hide())
+                            .Schedule(() =>
+                            {
+                                epilepsyWarning.Hide();
+                                epilepsyWarning.Expire();
+                            })
                             .Delay(EpilepsyWarning.FADE_DURATION);
                     }
 
@@ -348,6 +359,10 @@ namespace osu.Game.Screens.Play
                         // Note that this may change if the player we load requested a re-run.
                         ValidForResume = false;
 
+                        // restore full volume immediately - there's a usually a period of silence at start of gameplay anyway.
+                        // note that this is delayed slightly to avoid volume spikes just before push.
+                        musicController.CurrentTrack.Delay(50).VolumeTo(1);
+
                         if (player.LoadedBeatmapSuccessfully)
                             this.Push(player);
                         else
@@ -363,6 +378,10 @@ namespace osu.Game.Screens.Play
 
         private void cancelLoad()
         {
+            // in case the epilepsy warning is being displayed, restore full volume.
+            if (epilepsyWarning?.IsAlive == true)
+                musicController.CurrentTrack.VolumeTo(1, EpilepsyWarning.FADE_DURATION, Easing.OutQuint);
+
             scheduledPushPlayer?.Cancel();
             scheduledPushPlayer = null;
         }

From 85e14f3f0c8b3e194cb51057e4e9b2970dda7a21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 24 Oct 2020 22:58:43 +0200
Subject: [PATCH 21/25] Shorten fade duration to make fade out snappier

---
 osu.Game/Screens/Play/EpilepsyWarning.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osu.Game/Screens/Play/EpilepsyWarning.cs b/osu.Game/Screens/Play/EpilepsyWarning.cs
index 6121a0c2a3..dc42427fbf 100644
--- a/osu.Game/Screens/Play/EpilepsyWarning.cs
+++ b/osu.Game/Screens/Play/EpilepsyWarning.cs
@@ -16,6 +16,7 @@ namespace osu.Game.Screens.Play
 {
     public class EpilepsyWarning : VisibilityContainer
     {
+        public const double FADE_DURATION = 250;
 
         public EpilepsyWarning()
         {

From 8b04cd2cb0a79a81432bff9f488d12300240ebac Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Sun, 25 Oct 2020 20:28:24 +0900
Subject: [PATCH 22/25] Fix a potential null reference when loading carousel
 difficulties

---
 osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs
index 703b91c517..93f95e76cc 100644
--- a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs
+++ b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs
@@ -140,7 +140,7 @@ namespace osu.Game.Screens.Select.Carousel
                 LoadComponentAsync(beatmapContainer, loaded =>
                 {
                     // make sure the pooled target hasn't changed.
-                    if (carouselBeatmapSet != Item)
+                    if (beatmapContainer != loaded)
                         return;
 
                     Content.Child = loaded;

From 0542a45c43a14a16eec8a99570c070e642104fd0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sun, 25 Oct 2020 12:33:35 +0100
Subject: [PATCH 23/25] Change to manual adjustment add/remove

---
 osu.Game/Screens/Play/PlayerLoader.cs | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index fe774527b8..42074ac241 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -55,6 +55,8 @@ namespace osu.Game.Screens.Play
 
         private bool backgroundBrightnessReduction;
 
+        private readonly BindableDouble volumeAdjustment = new BindableDouble(1);
+
         protected bool BackgroundBrightnessReduction
         {
             set
@@ -104,9 +106,6 @@ namespace osu.Game.Screens.Play
         [Resolved]
         private AudioManager audioManager { get; set; }
 
-        [Resolved]
-        private MusicController musicController { get; set; }
-
         public PlayerLoader(Func<Player> createPlayer)
         {
             this.createPlayer = createPlayer;
@@ -172,6 +171,7 @@ namespace osu.Game.Screens.Play
 
             if (epilepsyWarning != null)
                 epilepsyWarning.DimmableBackground = Background;
+            Beatmap.Value.Track.AddAdjustment(AdjustableProperty.Volume, volumeAdjustment);
 
             content.ScaleTo(0.7f);
             Background?.FadeColour(Color4.White, 800, Easing.OutQuint);
@@ -200,6 +200,11 @@ namespace osu.Game.Screens.Play
             cancelLoad();
 
             BackgroundBrightnessReduction = false;
+
+            // we're moving to player, so a period of silence is upcoming.
+            // stop the track before removing adjustment to avoid a volume spike.
+            Beatmap.Value.Track.Stop();
+            Beatmap.Value.Track.RemoveAdjustment(AdjustableProperty.Volume, volumeAdjustment);
         }
 
         public override bool OnExiting(IScreen next)
@@ -211,6 +216,7 @@ namespace osu.Game.Screens.Play
 
             Background.EnableUserDim.Value = false;
             BackgroundBrightnessReduction = false;
+            Beatmap.Value.Track.RemoveAdjustment(AdjustableProperty.Volume, volumeAdjustment);
 
             return base.OnExiting(next);
         }
@@ -335,11 +341,8 @@ namespace osu.Game.Screens.Play
                         const double epilepsy_display_length = 3000;
 
                         pushSequence
-                            .Schedule(() =>
-                            {
-                                musicController.CurrentTrack.VolumeTo(0.25, EpilepsyWarning.FADE_DURATION, Easing.OutQuint);
-                                epilepsyWarning.State.Value = Visibility.Visible;
-                            })
+                            .Schedule(() => epilepsyWarning.State.Value = Visibility.Visible)
+                            .TransformBindableTo(volumeAdjustment, 0.25, EpilepsyWarning.FADE_DURATION, Easing.OutQuint)
                             .Delay(epilepsy_display_length)
                             .Schedule(() =>
                             {
@@ -359,10 +362,6 @@ namespace osu.Game.Screens.Play
                         // Note that this may change if the player we load requested a re-run.
                         ValidForResume = false;
 
-                        // restore full volume immediately - there's a usually a period of silence at start of gameplay anyway.
-                        // note that this is delayed slightly to avoid volume spikes just before push.
-                        musicController.CurrentTrack.Delay(50).VolumeTo(1);
-
                         if (player.LoadedBeatmapSuccessfully)
                             this.Push(player);
                         else
@@ -378,10 +377,6 @@ namespace osu.Game.Screens.Play
 
         private void cancelLoad()
         {
-            // in case the epilepsy warning is being displayed, restore full volume.
-            if (epilepsyWarning?.IsAlive == true)
-                musicController.CurrentTrack.VolumeTo(1, EpilepsyWarning.FADE_DURATION, Easing.OutQuint);
-
             scheduledPushPlayer?.Cancel();
             scheduledPushPlayer = null;
         }

From 0a23e994e2de7a23927928e4a051d6372a7c8dfb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sun, 25 Oct 2020 23:24:14 +0100
Subject: [PATCH 24/25] Hide sliderend & repeat circles in traceable mod

---
 osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
index d7582f3196..e1d197fb1d 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Bindables;
 using System.Collections.Generic;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -49,9 +50,16 @@ namespace osu.Game.Rulesets.Osu.Mods
             {
                 case DrawableHitCircle circle:
                     // we only want to see the approach circle
-                    using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
-                        circle.CirclePiece.Hide();
+                    applyCirclePieceState(circle, circle.CirclePiece);
+                    break;
 
+                case DrawableSliderTail sliderTail:
+                    applyCirclePieceState(sliderTail);
+                    break;
+
+                case DrawableSliderRepeat sliderRepeat:
+                    // show only the repeat arrow
+                    applyCirclePieceState(sliderRepeat, sliderRepeat.CirclePiece);
                     break;
 
                 case DrawableSlider slider:
@@ -61,6 +69,13 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
         }
 
+        private void applyCirclePieceState(DrawableOsuHitObject hitObject, IDrawable hitCircle = null)
+        {
+            var h = hitObject.HitObject;
+            using (hitObject.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
+                (hitCircle ?? hitObject).Hide();
+        }
+
         private void applySliderState(DrawableSlider slider)
         {
             ((PlaySliderBody)slider.Body.Drawable).AccentColour = slider.AccentColour.Value.Opacity(0);

From 5ef1b5dcb521a7d75f4f8dd6e7e82c934a3c195c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sun, 25 Oct 2020 23:55:22 +0100
Subject: [PATCH 25/25] Remove unused locals

---
 osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
index e1d197fb1d..bb2213aa31 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
@@ -39,11 +39,9 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         protected void ApplyTraceableState(DrawableHitObject drawable, ArmedState state)
         {
-            if (!(drawable is DrawableOsuHitObject drawableOsu))
+            if (!(drawable is DrawableOsuHitObject))
                 return;
 
-            var h = drawableOsu.HitObject;
-
             //todo: expose and hide spinner background somehow
 
             switch (drawable)