Remove unnecessary skin lookup logic

osu.Game/Screens/Ranking/Expanded/Accuracy/AccuracyCircle.cs

@@ -8,11 +8,11 @@ using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Platform;
 using osu.Framework.Utils;
+using osu.Game.Audio;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
@@ -110,20 +110,18 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
         private Container<RankBadge> badges;
         private RankText rankText;
 
-        private DrawableSample scoreTickSound;
+        private PoolableSkinnableSample scoreTickSound;
-        private DrawableSample badgeTickSound;
+        private PoolableSkinnableSample badgeTickSound;
-        private DrawableSample badgeMaxSound;
+        private PoolableSkinnableSample badgeMaxSound;
-        private DrawableSample swooshUpSound;
+        private PoolableSkinnableSample swooshUpSound;
-        private DrawableSample rankImpactSound;
+        private PoolableSkinnableSample rankImpactSound;
-        private DrawableSample rankApplauseSound;
+        private PoolableSkinnableSample rankApplauseSound;
-        private DrawableSample legacySkinApplauseSound;
 
         private Bindable<double> tickPlaybackRate = new Bindable<double>();
         private double lastTickPlaybackTime;
         private bool isTicking;
 
         private readonly bool sfxEnabled;
-        private bool legacySkin => legacySkinApplauseSound != null;
 
         public AccuracyCircle(ScoreInfo score, bool sfxEnabled = false)
         {
@@ -253,50 +251,41 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
             };
 
             if (sfxEnabled)
-            {
-                Drawable legacySkinApplause = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.Applause));
-
-                if (legacySkinApplause != null)
-                {
-                    AddInternal(legacySkinApplause);
-                    legacySkinApplauseSound = legacySkinApplause as DrawableSample;
-                }
-                else
             {
                 tickPlaybackRate = new Bindable<double>(sfx_score_tick_debounce_rate_start);
 
                 switch (score.Rank)
                 {
                     case ScoreRank.D:
-                            rankImpactSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultRank_D)) as DrawableSample;
+                        rankImpactSound = new PoolableSkinnableSample(new SampleInfo(@"Results/rank-impact-fail-d"));
-                            rankApplauseSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultApplause_D)) as DrawableSample;
+                        rankApplauseSound = new PoolableSkinnableSample(new SampleInfo(@"applause", @"Results/applause-d"));
                         break;
 
                     case ScoreRank.C:
-                            rankImpactSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultRank_C)) as DrawableSample;
+                        rankImpactSound = new PoolableSkinnableSample(new SampleInfo(@"Results/rank-impact-fail"));
-                            rankApplauseSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultApplause_C)) as DrawableSample;
+                        rankApplauseSound = new PoolableSkinnableSample(new SampleInfo(@"applause", @"Results/applause-c"));
                         break;
 
                     case ScoreRank.B:
-                            rankImpactSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultRank_B)) as DrawableSample;
+                        rankImpactSound = new PoolableSkinnableSample(new SampleInfo(@"Results/rank-impact-fail"));
-                            rankApplauseSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultApplause_B)) as DrawableSample;
+                        rankApplauseSound = new PoolableSkinnableSample(new SampleInfo(@"applause", @"Results/applause-b"));
                         break;
 
                     case ScoreRank.A:
-                            rankImpactSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultRank_A)) as DrawableSample;
+                        rankImpactSound = new PoolableSkinnableSample(new SampleInfo(@"Results/rank-impact-pass"));
-                            rankApplauseSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultApplause_A)) as DrawableSample;
+                        rankApplauseSound = new PoolableSkinnableSample(new SampleInfo(@"applause", @"Results/applause-a"));
                         break;
 
                     case ScoreRank.S:
                     case ScoreRank.SH:
-                            rankImpactSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultRank_S)) as DrawableSample;
+                        rankImpactSound = new PoolableSkinnableSample(new SampleInfo(@"Results/rank-impact-pass"));
-                            rankApplauseSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultApplause_S)) as DrawableSample;
+                        rankApplauseSound = new PoolableSkinnableSample(new SampleInfo(@"applause", @"Results/applause-s"));
                         break;
 
                     case ScoreRank.X:
                     case ScoreRank.XH:
-                            rankImpactSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultRank_SS)) as DrawableSample;
+                        rankImpactSound = new PoolableSkinnableSample(new SampleInfo(@"Results/rank-impact-pass-ss"));
-                            rankApplauseSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultApplause_SS)) as DrawableSample;
+                        rankApplauseSound = new PoolableSkinnableSample(new SampleInfo(@"applause", @"Results/applause-s"));
                         break;
                 }
 
@@ -304,14 +293,13 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
                 {
                     rankImpactSound,
                     rankApplauseSound,
-                        scoreTickSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultScoreTick)) as DrawableSample,
+                    scoreTickSound = new PoolableSkinnableSample(new SampleInfo(@"Results/score-tick")),
-                        badgeTickSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultBadgeTick)) as DrawableSample,
+                    badgeTickSound = new PoolableSkinnableSample(new SampleInfo(@"Results/badge-dink")),
-                        badgeMaxSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultBadgeTickMax)) as DrawableSample,
+                    badgeMaxSound = new PoolableSkinnableSample(new SampleInfo(@"Results/badge-dink-max")),
-                        swooshUpSound = skin.GetDrawableComponent(new GameplaySkinComponent<GameplaySkinSamples>(GameplaySkinSamples.ResultSwooshUp)) as DrawableSample
+                    swooshUpSound = new PoolableSkinnableSample(new SampleInfo(@"Results/swoosh-up")),
                 });
             }
         }
-        }
 
         private ScoreRank getRank(ScoreRank rank)
         {
@@ -341,7 +329,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
 
             this.ScaleTo(0).Then().ScaleTo(1, APPEAR_DURATION, Easing.OutQuint);
 
-            if (sfxEnabled && !legacySkin)
+            if (sfxEnabled)
             {
                 this.Delay(sfx_swoosh_pre_delay).Schedule(() =>
                 {
@@ -359,7 +347,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
 
                 accuracyCircle.FillTo(targetAccuracy, ACCURACY_TRANSFORM_DURATION, ACCURACY_TRANSFORM_EASING);
 
-                if (sfxEnabled && !legacySkin)
+                if (sfxEnabled)
                 {
                     Schedule(() =>
                     {
@@ -382,11 +370,12 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
                     {
                         badge.Appear();
 
-                        if (sfxEnabled && !legacySkin)
+                        if (sfxEnabled)
                         {
                             Schedule(() =>
                             {
-                                DrawableSample dink = badgeNum < badges.Count - 1 ? badgeTickSound : badgeMaxSound;
+                                var dink = badgeNum < badges.Count - 1 ? badgeTickSound : badgeMaxSound;
+
                                 dink.FrequencyTo(1 + badgeNum++ * 0.05);
                                 dink.VolumeTo(sfx_badge_dink_volume);
                                 dink.Play();
@@ -401,10 +390,6 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
 
                     if (!sfxEnabled) return;
 
-                    legacySkinApplauseSound?.Play();
-
-                    if (legacySkin) return;
-
                     Schedule(() =>
                     {
                         isTicking = false;

osu.Game/Skinning/DefaultSkin.cs

@@ -7,7 +7,6 @@ using JetBrains.Annotations;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
@@ -25,27 +24,6 @@ namespace osu.Game.Skinning
     {
         private readonly IStorageResourceProvider resources;
 
-        private static readonly IReadOnlyDictionary<GameplaySkinSamples, string> sample_mapping
-            = new Dictionary<GameplaySkinSamples, string>
-            {
-                { GameplaySkinSamples.ResultScoreTick, @"Results/score-tick" },
-                { GameplaySkinSamples.ResultBadgeTick, @"Results/badge-dink" },
-                { GameplaySkinSamples.ResultBadgeTickMax, @"Results/badge-dink-max" },
-                { GameplaySkinSamples.ResultSwooshUp, @"Results/swoosh-up" },
-                { GameplaySkinSamples.ResultRank_D, @"Results/rank-impact-fail-d" },
-                { GameplaySkinSamples.ResultRank_B, @"Results/rank-impact-fail" },
-                { GameplaySkinSamples.ResultRank_C, @"Results/rank-impact-fail" },
-                { GameplaySkinSamples.ResultRank_A, @"Results/rank-impact-pass" },
-                { GameplaySkinSamples.ResultRank_S, @"Results/rank-impact-pass" },
-                { GameplaySkinSamples.ResultRank_SS, @"Results/rank-impact-pass-ss" },
-                { GameplaySkinSamples.ResultApplause_D, @"Results/applause-d" },
-                { GameplaySkinSamples.ResultApplause_B, @"Results/applause-b" },
-                { GameplaySkinSamples.ResultApplause_C, @"Results/applause-c" },
-                { GameplaySkinSamples.ResultApplause_A, @"Results/applause-a" },
-                { GameplaySkinSamples.ResultApplause_S, @"Results/applause-s" },
-                { GameplaySkinSamples.ResultApplause_SS, @"Results/applause-s" }
-            };
-
         public DefaultSkin(IStorageResourceProvider resources)
             : this(SkinInfo.Default, resources)
         {
@@ -80,12 +58,6 @@ namespace osu.Game.Skinning
 
             switch (component)
             {
-                case GameplaySkinComponent<GameplaySkinSamples> sample:
-                    if (sample_mapping.ContainsKey(sample.Component))
-                        return new DrawableSample(GetSample(new SampleInfo(sample_mapping[sample.Component])));
-
-                    break;
-
                 case SkinnableTargetComponent target:
                     switch (target.Target)
                     {

osu.Game/Skinning/GameplaySkinSamples.cs

@@ -1,29 +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.
-
-namespace osu.Game.Skinning
-{
-    public enum GameplaySkinSamples
-    {
-        // legacy
-        Applause,
-
-        // results screen
-        ResultScoreTick,
-        ResultBadgeTick,
-        ResultBadgeTickMax,
-        ResultSwooshUp,
-        ResultRank_D,
-        ResultRank_B,
-        ResultRank_C,
-        ResultRank_A,
-        ResultRank_S,
-        ResultRank_SS,
-        ResultApplause_D,
-        ResultApplause_B,
-        ResultApplause_C,
-        ResultApplause_A,
-        ResultApplause_S,
-        ResultApplause_SS
-    }
-}

osu.Game/Skinning/LegacySkin.cs

@@ -10,7 +10,6 @@ using JetBrains.Annotations;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
@@ -397,43 +396,6 @@ namespace osu.Game.Skinning
 
                     return null;
 
-                case GameplaySkinComponent<GameplaySkinSamples> sampleComponent:
-                    var applause = GetSample(new SampleInfo("applause"));
-
-                    switch (sampleComponent.Component)
-                    {
-                        case GameplaySkinSamples.Applause:
-                            if (applause != null)
-                                return new DrawableSample(applause);
-
-                            break;
-
-                        case GameplaySkinSamples.ResultScoreTick:
-                        case GameplaySkinSamples.ResultBadgeTick:
-                        case GameplaySkinSamples.ResultBadgeTickMax:
-                        case GameplaySkinSamples.ResultSwooshUp:
-                        case GameplaySkinSamples.ResultRank_D:
-                        case GameplaySkinSamples.ResultRank_B:
-                        case GameplaySkinSamples.ResultRank_C:
-                        case GameplaySkinSamples.ResultRank_A:
-                        case GameplaySkinSamples.ResultRank_S:
-                        case GameplaySkinSamples.ResultRank_SS:
-                        case GameplaySkinSamples.ResultApplause_D:
-                        case GameplaySkinSamples.ResultApplause_B:
-                        case GameplaySkinSamples.ResultApplause_C:
-                        case GameplaySkinSamples.ResultApplause_A:
-                        case GameplaySkinSamples.ResultApplause_S:
-                        case GameplaySkinSamples.ResultApplause_SS:
-                            if (applause != null)
-                                // Legacy skins don't have sounds for the result screen, but may instead have an 'applause' sound.
-                                // This lets a legacy skin's applause sound play instead of result screen sounds (as to not play over each other)
-                                return Drawable.Empty();
-
-                            break;
-                    }
-
-                    break;
-
                 case GameplaySkinComponent<HitResult> resultComponent:
                     // TODO: this should be inside the judgement pieces.
                     Func<Drawable> createDrawable = () => getJudgementAnimation(resultComponent.Component);