Refactor classic osu!catch combo counter and place it in HUD overlay

osu.Game.Rulesets.Catch.Tests.Android/osu.Game.Rulesets.Catch.Tests.Android.csproj

@@ -19,6 +19,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj" />
+    <ProjectReference Include="..\osu.Game.Tests\osu.Game.Tests.csproj" />
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch.Tests/TestSceneCatchSkinMigration.cs

@@ -0,0 +1,84 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. 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.Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Database;
+using osu.Game.Overlays;
+using osu.Game.Overlays.SkinEditor;
+using osu.Game.Rulesets.Catch.Skinning.Legacy;
+using osu.Game.Screens.Edit;
+using osu.Game.Skinning;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [HeadlessTest]
+    public partial class TestSceneCatchSkinMigration : PlayerTestScene
+    {
+        private SkinEditor skinEditor = null!;
+
+        protected override bool Autoplay => true;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        [Cached]
+        public readonly EditorClipboard Clipboard = new EditorClipboard();
+
+        [Resolved]
+        private SkinManager skins { get; set; } = null!;
+
+        private SkinnableContainer targetContainer => Player.ChildrenOfType<SkinnableContainer>().First();
+
+        private SkinnableContainer rulesetHUDTarget => Player.ChildrenOfType<SkinnableContainer>()
+                                                             .Single(c => c.Lookup.Lookup == GlobalSkinnableContainers.MainHUDComponents && c.Lookup.Ruleset != null);
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("reset skin", () => skins.CurrentSkinInfo.SetDefault());
+            AddUntilStep("wait for hud load", () => targetContainer.ComponentsLoaded);
+
+            AddStep("reload skin editor", () =>
+            {
+                if (skinEditor.IsNotNull())
+                    skinEditor.Expire();
+                Player.ScaleTo(0.4f);
+                LoadComponentAsync(skinEditor = new SkinEditor(Player), Add);
+            });
+            AddUntilStep("wait for loaded", () => skinEditor.IsLoaded);
+        }
+
+        [Test]
+        public void TestMigrationLegacyCatch()
+        {
+            AddStep("import old classic skin", () => skins.CurrentSkinInfo.Value = importSkinFromArchives(@"classic-layout-version-0.osk").SkinInfo);
+            AddAssert("layout loaded", () => skins.CurrentSkin.Value.LayoutInfos, () => NUnit.Framework.Contains.Key(GlobalSkinnableContainers.MainHUDComponents));
+            AddUntilStep("wait for load", () => rulesetHUDTarget.ComponentsLoaded);
+
+            AddAssert("catch specific combo counter in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyCatchComboCounter>(), () => Has.One.Items);
+            AddAssert("correct anchor/origin", () =>
+            {
+                var catchComboCounter = rulesetHUDTarget.Components.OfType<LegacyCatchComboCounter>().Single();
+                return catchComboCounter.Anchor == Anchor.CentreLeft && catchComboCounter.Origin == Anchor.Centre;
+            });
+        }
+
+        private Skin importSkinFromArchives(string filename)
+        {
+            var imported = skins.Import(new ImportTask(TestResources.OpenResource($@"Archives/{filename}"), filename)).GetResultSafely();
+            return imported.PerformRead(skinInfo => skins.GetSkin(skinInfo));
+        }
+
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+    }
+}

osu.Game.Rulesets.Catch.Tests/TestSceneComboCounter.cs

@@ -1,88 +1,102 @@
 // Copyright (c) ppy Pty Ltd <[email protected]>. 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.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Catch.Skinning.Legacy;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
-using osu.Game.Tests.Visual;
-using osuTK;
+using osu.Game.Skinning;
+using osu.Game.Tests.Gameplay;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     public partial class TestSceneComboCounter : CatchSkinnableTestScene
     {
-        private ScoreProcessor scoreProcessor = null!;
+        private readonly GameplayState gameplayState = TestGameplayState.Create(new CatchRuleset());
 
-        private Color4 judgedObjectColour = Color4.White;
+        [Cached(typeof(ScoreProcessor))]
+        private ScoreProcessor scoreProcessor;
 
-        private readonly Bindable<bool> showHud = new Bindable<bool>(true);
+        private Color4? judgedObjectColour;
+
+        public TestSceneComboCounter()
+        {
+            scoreProcessor = gameplayState.ScoreProcessor;
+        }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Dependencies.CacheAs<Player>(new TestPlayer
-            {
-                ShowingOverlayComponents = { BindTarget = showHud },
-            });
+            scoreProcessor.NewJudgement += result => gameplayState.ApplyResult(result);
+
+            Dependencies.CacheAs(gameplayState);
         }
 
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            scoreProcessor = new ScoreProcessor(new CatchRuleset());
-
-            showHud.Value = true;
-
-            SetContents(_ => new CatchComboDisplay
+            SetContents(skin =>
             {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Scale = new Vector2(2.5f),
+                if (skin is LegacySkin)
+                {
+                    return new LegacyCatchComboCounter
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    };
+                }
+
+                return Empty();
             });
         });
 
         [Test]
         public void TestCatchComboCounter()
         {
-            AddRepeatStep("perform hit", () => performJudgement(HitResult.Great), 20);
-            AddStep("perform miss", () => performJudgement(HitResult.Miss));
-
-            AddStep("randomize judged object colour", () =>
+            AddRepeatStep("perform hit", () =>
             {
-                judgedObjectColour = new Color4(
-                    RNG.NextSingle(1f),
-                    RNG.NextSingle(1f),
-                    RNG.NextSingle(1f),
-                    1f
-                );
-            });
+                if (judgedObjectColour == null || RNG.NextDouble() > 0.8)
+                {
+                    judgedObjectColour = new Color4(
+                        RNG.NextSingle(1f),
+                        RNG.NextSingle(1f),
+                        RNG.NextSingle(1f),
+                        1f
+                    );
+                }
 
-            AddStep("set hud to never show", () => showHud.Value = false);
-            AddRepeatStep("perform hit", () => performJudgement(HitResult.Great), 5);
+                performJudgement(HitResult.Great);
+            }, 20);
 
-            AddStep("set hud to show", () => showHud.Value = true);
-            AddRepeatStep("perform hit", () => performJudgement(HitResult.Great), 5);
+            AddStep("perform miss", () => performJudgement(HitResult.Miss));
         }
 
         private void performJudgement(HitResult type, Judgement? judgement = null)
         {
-            var judgedObject = new DrawableFruit(new Fruit()) { AccentColour = { Value = judgedObjectColour } };
+            var judgedObject = new DrawableFruit(new ColourfulFruit(judgedObjectColour!.Value));
 
             var result = new JudgementResult(judgedObject.HitObject, judgement ?? new Judgement()) { Type = type };
             scoreProcessor.ApplyResult(result);
+        }
+
+        private class ColourfulFruit : Fruit, IHasComboInformation
+        {
+            private readonly Color4 colour;
+
+            public ColourfulFruit(Color4 colour)
+            {
+                this.colour = colour;
+            }
 
-            foreach (var counter in CreatedDrawables.Cast<CatchComboDisplay>())
-                counter.OnNewResult(judgedObject, result);
+            Color4 IHasComboInformation.GetComboColour(ISkin skin) => colour;
         }
     }
 }

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -11,5 +11,6 @@
   </PropertyGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj" />
+    <ProjectReference Include="..\osu.Game.Tests\osu.Game.Tests.csproj" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs

@@ -43,7 +43,6 @@ public CatchLegacySkinTransformer(ISkin skin)
                     switch (containerLookup.Lookup)
                     {
                         case GlobalSkinnableContainers.MainHUDComponents:
-                            // todo: remove CatchSkinComponents.CatchComboCounter and refactor LegacyCatchComboCounter to be added here instead.
                             return new DefaultSkinComponentsContainer(container =>
                             {
                                 var keyCounter = container.OfType<LegacyKeyCounterDisplay>().FirstOrDefault();
@@ -55,11 +54,20 @@ public CatchLegacySkinTransformer(ISkin skin)
                                     keyCounter.Origin = Anchor.TopRight;
                                     keyCounter.Position = new Vector2(0, -40) * 1.6f;
                                 }
+
+                                var combo = container.OfType<LegacyCatchComboCounter>().FirstOrDefault();
+
+                                if (combo != null)
+                                {
+                                    combo.Anchor = Anchor.CentreLeft;
+                                    combo.Origin = Anchor.Centre;
+                                }
                             })
                             {
                                 Children = new Drawable[]
                                 {
                                     new LegacyKeyCounterDisplay(),
+                                    new LegacyCatchComboCounter(),
                                 }
                             };
                     }