Merge remote-tracking branch 'upstream/master' into update-framework

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

@@ -0,0 +1,66 @@
+// 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.IO;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.IO.Stores;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public abstract class SkinnableTestScene : OsuGridTestScene
+    {
+        private Skin metricsSkin;
+        private Skin defaultSkin;
+        private Skin specialSkin;
+
+        protected SkinnableTestScene()
+            : base(2, 2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            var skins = new SkinManager(LocalStorage, ContextFactory, null, audio);
+
+            metricsSkin = getSkinFromResources(skins, "metrics_skin");
+            defaultSkin = getSkinFromResources(skins, "default_skin");
+            specialSkin = getSkinFromResources(skins, "special_skin");
+        }
+
+        public void SetContents(Func<Drawable> creationFunction)
+        {
+            Cell(0).Child = new LocalSkinOverrideContainer(null) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+            Cell(1).Child = new LocalSkinOverrideContainer(metricsSkin) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+            Cell(2).Child = new LocalSkinOverrideContainer(defaultSkin) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+            Cell(3).Child = new LocalSkinOverrideContainer(specialSkin) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+        }
+
+        private static Skin getSkinFromResources(SkinManager skins, string name)
+        {
+            using (var storage = new DllResourceStore("osu.Game.Rulesets.Osu.Tests.dll"))
+            {
+                var tempName = Path.GetTempFileName();
+
+                File.Delete(tempName);
+                Directory.CreateDirectory(tempName);
+
+                var files = storage.GetAvailableResources().Where(f => f.StartsWith($"Resources/{name}"));
+
+                foreach (var file in files)
+                    using (var stream = storage.GetStream(file))
+                    using (var newFile = File.Create(Path.Combine(tempName, Path.GetFileName(file))))
+                        stream.CopyTo(newFile);
+
+                return skins.GetSkin(skins.Import(tempName).Result);
+            }
+        }
+    }
+}

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

@@ -7,7 +7,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Tests.Visual;
 using osuTK;
 using System.Collections.Generic;
 using System;
@@ -19,37 +18,32 @@ using osu.Game.Rulesets.Scoring;
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestSceneHitCircle : OsuTestScene
+    public class TestSceneHitCircle : SkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(DrawableHitCircle)
         };
 
-        private readonly Container content;
-        protected override Container<Drawable> Content => content;
-
         private int depthIndex;
 
         public TestSceneHitCircle()
         {
-            base.Content.Add(content = new OsuInputManager(new RulesetInfo { ID = 0 }));
+            AddStep("Miss Big Single", () => SetContents(() => testSingle(2)));
-
+            AddStep("Miss Medium Single", () => SetContents(() => testSingle(5)));
-            AddStep("Miss Big Single", () => testSingle(2));
+            AddStep("Miss Small Single", () => SetContents(() => testSingle(7)));
-            AddStep("Miss Medium Single", () => testSingle(5));
+            AddStep("Hit Big Single", () => SetContents(() => testSingle(2, true)));
-            AddStep("Miss Small Single", () => testSingle(7));
+            AddStep("Hit Medium Single", () => SetContents(() => testSingle(5, true)));
-            AddStep("Hit Big Single", () => testSingle(2, true));
+            AddStep("Hit Small Single", () => SetContents(() => testSingle(7, true)));
-            AddStep("Hit Medium Single", () => testSingle(5, true));
+            AddStep("Miss Big Stream", () => SetContents(() => testStream(2)));
-            AddStep("Hit Small Single", () => testSingle(7, true));
+            AddStep("Miss Medium Stream", () => SetContents(() => testStream(5)));
-            AddStep("Miss Big Stream", () => testStream(2));
+            AddStep("Miss Small Stream", () => SetContents(() => testStream(7)));
-            AddStep("Miss Medium Stream", () => testStream(5));
+            AddStep("Hit Big Stream", () => SetContents(() => testStream(2, true)));
-            AddStep("Miss Small Stream", () => testStream(7));
+            AddStep("Hit Medium Stream", () => SetContents(() => testStream(5, true)));
-            AddStep("Hit Big Stream", () => testStream(2, true));
+            AddStep("Hit Small Stream", () => SetContents(() => testStream(7, true)));
-            AddStep("Hit Medium Stream", () => testStream(5, true));
-            AddStep("Hit Small Stream", () => testStream(7, true));
         }
 
-        private void testSingle(float circleSize, bool auto = false, double timeOffset = 0, Vector2? positionOffset = null)
+        private Drawable testSingle(float circleSize, bool auto = false, double timeOffset = 0, Vector2? positionOffset = null)
         {
             positionOffset = positionOffset ?? Vector2.Zero;
 
@@ -61,27 +55,33 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             circle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = circleSize });
 
-            var drawable = new TestDrawableHitCircle(circle, auto)
+            var drawable = CreateDrawableHitCircle(circle, auto);
-            {
-                Anchor = Anchor.Centre,
-                Depth = depthIndex++
-            };
 
             foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
-            Add(drawable);
+            return drawable;
         }
 
-        private void testStream(float circleSize, bool auto = false)
+        protected virtual TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto) => new TestDrawableHitCircle(circle, auto)
         {
+            Anchor = Anchor.Centre,
+            Depth = depthIndex++
+        };
+
+        private Drawable testStream(float circleSize, bool auto = false)
+        {
+            var container = new Container { RelativeSizeAxes = Axes.Both };
+
             Vector2 pos = new Vector2(-250, 0);
 
             for (int i = 0; i <= 1000; i += 100)
             {
-                testSingle(circleSize, auto, i, pos);
+                container.Add(testSingle(circleSize, auto, i, pos));
                 pos.X += 50;
             }
+
+            return container;
         }
 
         protected class TestDrawableHitCircle : DrawableHitCircle

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

@@ -1,23 +1,22 @@
 // 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 osu.Framework.Graphics;
 using osu.Framework.MathUtils;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     public class TestSceneShaking : TestSceneHitCircle
     {
-        public override void Add(Drawable drawable)
+        protected override TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto)
         {
-            base.Add(drawable);
+            var drawableHitObject = base.CreateDrawableHitCircle(circle, auto);
 
-            if (drawable is TestDrawableHitCircle hitObject)
+            Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(),
-            {
+                drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current);
-                Scheduler.AddDelayed(() => hitObject.TriggerJudgement(),
+
-                    hitObject.HitObject.StartTime - (hitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current);
+            return drawableHitObject;
-            }
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs

@@ -6,33 +6,29 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using osuTK;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
     {
         public ApproachCircle ApproachCircle;
-        private readonly CirclePiece circle;
-        private readonly RingPiece ring;
-        private readonly FlashPiece flash;
-        private readonly ExplodePiece explode;
-        private readonly NumberPiece number;
-        private readonly GlowPiece glow;
 
         private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
         private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
         private readonly IBindable<float> scaleBindable = new Bindable<float>();
 
-        public OsuAction? HitAction => circle.HitAction;
+        public OsuAction? HitAction => hitArea.HitAction;
-
-        private readonly Container explodeContainer;
 
         private readonly Container scaleContainer;
 
+        private readonly HitArea hitArea;
+
         public DrawableHitCircle(HitCircle h)
             : base(h)
         {
@@ -47,44 +43,30 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     RelativeSizeAxes = Axes.Both,
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    Child = explodeContainer = new Container
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
+                        hitArea = new HitArea
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        Children = new Drawable[]
                         {
-                            glow = new GlowPiece(),
+                            Hit = () =>
-                            circle = new CirclePiece
                             {
-                                Hit = () =>
+                                if (AllJudged)
-                                {
+                                    return false;
-                                    if (AllJudged)
-                                        return false;
 
-                                    UpdateResult(true);
+                                UpdateResult(true);
-                                    return true;
+                                return true;
-                                },
                             },
-                            number = new NumberPiece
+                        },
-                            {
+                        new SkinnableDrawable("Play/osu/hitcircle", _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
-                                Text = (HitObject.IndexInCurrentCombo + 1).ToString(),
+                        ApproachCircle = new ApproachCircle
-                            },
+                        {
-                            ring = new RingPiece(),
+                            Alpha = 0,
-                            flash = new FlashPiece(),
+                            Scale = new Vector2(4),
-                            explode = new ExplodePiece(),
-                            ApproachCircle = new ApproachCircle
-                            {
-                                Alpha = 0,
-                                Scale = new Vector2(4),
-                            }
                         }
                     }
                 },
             };
 
-            //may not be so correct
+            Size = hitArea.DrawSize;
-            Size = circle.DrawSize;
         }
 
         [BackgroundDependencyLoader]
@@ -98,13 +80,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             stackHeightBindable.BindTo(HitObject.StackHeightBindable);
             scaleBindable.BindTo(HitObject.ScaleBindable);
 
-            AccentColour.BindValueChanged(colour =>
+            AccentColour.BindValueChanged(accent => ApproachCircle.Colour = accent.NewValue, true);
-            {
-                explode.Colour = colour.NewValue;
-                glow.Colour = colour.NewValue;
-                circle.Colour = colour.NewValue;
-                ApproachCircle.Colour = colour.NewValue;
-            }, true);
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
@@ -139,8 +115,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
-            glow.FadeOut(400);
-
             switch (state)
             {
                 case ArmedState.Idle:
@@ -148,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
                     Expire(true);
 
-                    circle.HitAction = null;
+                    hitArea.HitAction = null;
 
                     // override lifetime end as FadeIn may have been changed externally, causing out expiration to be too early.
                     LifetimeEnd = HitObject.StartTime + HitObject.HitWindows.HalfWindowFor(HitResult.Miss);
@@ -163,29 +137,50 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 case ArmedState.Hit:
                     ApproachCircle.FadeOut(50);
 
-                    const double flash_in = 40;
+                    // todo: temporary / arbitrary
-                    flash.FadeTo(0.8f, flash_in)
+                    this.Delay(800).Expire();
-                         .Then()
-                         .FadeOut(100);
-
-                    explode.FadeIn(flash_in);
-                    explodeContainer.ScaleTo(1.5f, 400, Easing.OutQuad);
-
-                    using (BeginDelayedSequence(flash_in, true))
-                    {
-                        //after the flash, we can hide some elements that were behind it
-                        ring.FadeOut();
-                        circle.FadeOut();
-                        number.FadeOut();
-
-                        this.FadeOut(800);
-                    }
-
-                    Expire();
                     break;
             }
         }
 
         public Drawable ProxiedLayer => ApproachCircle;
+
+        private class HitArea : Drawable, IKeyBindingHandler<OsuAction>
+        {
+            // IsHovered is used
+            public override bool HandlePositionalInput => true;
+
+            public Func<bool> Hit;
+
+            public OsuAction? HitAction;
+
+            public HitArea()
+            {
+                Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+            }
+
+            public bool OnPressed(OsuAction action)
+            {
+                switch (action)
+                {
+                    case OsuAction.LeftButton:
+                    case OsuAction.RightButton:
+                        if (IsHovered && (Hit?.Invoke() ?? false))
+                        {
+                            HitAction = action;
+                            return true;
+                        }
+
+                        break;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(OsuAction action) => false;
+        }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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 osu.Game.Rulesets.Objects.Drawables;

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/CirclePiece.cs

@@ -1,24 +1,17 @@
 // 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 osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.Bindings;
+using osu.Framework.Graphics.Sprites;
-using osu.Game.Skinning;
+using osu.Framework.Graphics.Textures;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class CirclePiece : Container, IKeyBindingHandler<OsuAction>
+    public class CirclePiece : CompositeDrawable
     {
-        // IsHovered is used
-        public override bool HandlePositionalInput => true;
-
-        public Func<bool> Hit;
-
-        public OsuAction? HitAction;
-
         public CirclePiece()
         {
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
@@ -27,28 +20,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
-
-            InternalChild = new SkinnableDrawable("Play/osu/hitcircle", _ => new DefaultCirclePiece());
         }
 
-        public bool OnPressed(OsuAction action)
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
         {
-            switch (action)
+            InternalChildren = new Drawable[]
             {
-                case OsuAction.LeftButton:
+                new Sprite
-                case OsuAction.RightButton:
+                {
-                    if (IsHovered && (Hit?.Invoke() ?? false))
+                    Anchor = Anchor.Centre,
-                    {
+                    Origin = Anchor.Centre,
-                        HitAction = action;
+                    Texture = textures.Get(@"Play/osu/disc"),
-                        return true;
+                },
-                    }
+                new TrianglesPiece
-
+                {
-                    break;
+                    RelativeSizeAxes = Axes.Both,
-            }
+                    Blending = BlendingMode.Additive,
-
+                    Alpha = 0.5f,
-            return false;
+                }
+            };
         }
-
-        public bool OnReleased(OsuAction action) => false;
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/DefaultCirclePiece.cs

@@ -1,35 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-
-namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
-{
-    public class DefaultCirclePiece : Container
-    {
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            RelativeSizeAxes = Axes.Both;
-            Children = new Drawable[]
-            {
-                new Sprite
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Texture = textures.Get(@"Play/osu/disc"),
-                },
-                new TrianglesPiece
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Blending = BlendingMode.Additive,
-                    Alpha = 0.5f,
-                }
-            };
-        }
-    }
-}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/MainCirclePiece.cs

@@ -0,0 +1,94 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class MainCirclePiece : CompositeDrawable
+    {
+        private readonly CirclePiece circle;
+        private readonly RingPiece ring;
+        private readonly FlashPiece flash;
+        private readonly ExplodePiece explode;
+        private readonly NumberPiece number;
+        private readonly GlowPiece glow;
+
+        public MainCirclePiece(int index)
+        {
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            InternalChildren = new Drawable[]
+            {
+                glow = new GlowPiece(),
+                circle = new CirclePiece(),
+                number = new NumberPiece
+                {
+                    Text = (index + 1).ToString(),
+                },
+                ring = new RingPiece(),
+                flash = new FlashPiece(),
+                explode = new ExplodePiece(),
+            };
+        }
+
+        private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
+
+        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+
+        [BackgroundDependencyLoader]
+        private void load(DrawableHitObject drawableObject)
+        {
+            state.BindTo(drawableObject.State);
+            state.BindValueChanged(updateState, true);
+
+            accentColour.BindTo(drawableObject.AccentColour);
+            accentColour.BindValueChanged(colour =>
+            {
+                explode.Colour = colour.NewValue;
+                glow.Colour = colour.NewValue;
+                circle.Colour = colour.NewValue;
+            }, true);
+        }
+
+        private void updateState(ValueChangedEvent<ArmedState> state)
+        {
+            glow.FadeOut(400);
+
+            switch (state.NewValue)
+            {
+                case ArmedState.Hit:
+                    const double flash_in = 40;
+                    const double flash_out = 100;
+
+                    flash.FadeTo(0.8f, flash_in)
+                         .Then()
+                         .FadeOut(flash_out);
+
+                    explode.FadeIn(flash_in);
+                    this.ScaleTo(1.5f, 400, Easing.OutQuad);
+
+                    using (BeginDelayedSequence(flash_in, true))
+                    {
+                        //after the flash, we can hide some elements that were behind it
+                        ring.FadeOut();
+                        circle.FadeOut();
+                        number.FadeOut();
+
+                        this.FadeOut(800);
+                    }
+
+                    break;
+            }
+        }
+    }
+}

osu.Game/Skinning/LegacySkin.cs

@@ -6,15 +6,22 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+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.IO.Stores;
 using osu.Game.Database;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Skinning
 {
@@ -36,6 +43,8 @@ namespace osu.Game.Skinning
         {
         }
 
+        private readonly bool hasHitCircle;
+
         protected LegacySkin(SkinInfo skin, IResourceStore<byte[]> storage, AudioManager audioManager, string filename)
             : base(skin)
         {
@@ -49,8 +58,6 @@ namespace osu.Game.Skinning
             Samples = audioManager.GetSampleStore(storage);
             Textures = new TextureStore(new TextureLoaderStore(storage));
 
-            bool hasHitCircle = false;
-
             using (var testStream = storage.GetStream("hitcircle"))
                 hasHitCircle |= testStream != null;
 
@@ -71,6 +78,12 @@ namespace osu.Game.Skinning
         {
             switch (componentName)
             {
+                case "Play/osu/hitcircle":
+                    if (!hasHitCircle)
+                        return null;
+
+                    return new LegacyMainCirclePiece();
+
                 case "Play/Miss":
                     componentName = "hit0";
                     break;
@@ -243,5 +256,70 @@ namespace osu.Game.Skinning
                 return texture;
             }
         }
+
+        public class LegacyMainCirclePiece : CompositeDrawable
+        {
+            public LegacyMainCirclePiece()
+            {
+                Size = new Vector2(128);
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+            }
+
+            private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
+
+            private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+
+            [BackgroundDependencyLoader]
+            private void load(DrawableHitObject drawableObject, ISkinSource skin)
+            {
+                Sprite hitCircleSprite;
+
+                InternalChildren = new Drawable[]
+                {
+                    hitCircleSprite = new Sprite
+                    {
+                        Texture = skin.GetTexture("hitcircle"),
+                        Colour = drawableObject.AccentColour.Value,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                    new SkinnableSpriteText("Play/osu/number-text", _ => new OsuSpriteText
+                    {
+                        Font = OsuFont.Numeric.With(size: 40),
+                        UseFullGlyphHeight = false,
+                    }, confineMode: ConfineMode.NoScaling)
+                    {
+                        Text = (((IHasComboInformation)drawableObject.HitObject).IndexInCurrentCombo + 1).ToString()
+                    },
+                    new Sprite
+                    {
+                        Texture = skin.GetTexture("hitcircleoverlay"),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                };
+
+                state.BindTo(drawableObject.State);
+                state.BindValueChanged(updateState, true);
+
+                accentColour.BindTo(drawableObject.AccentColour);
+                accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
+            }
+
+            private void updateState(ValueChangedEvent<ArmedState> state)
+            {
+                const double legacy_fade_duration = 240;
+
+                switch (state.NewValue)
+                {
+                    case ArmedState.Hit:
+                        this.FadeOut(legacy_fade_duration, Easing.Out);
+                        this.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
+                        break;
+                }
+            }
+        }
     }
 }

osu.Game/Skinning/SkinManager.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Skinning
                     CurrentSkinInfo.Value = SkinInfo.Default;
             };
 
-            CurrentSkinInfo.ValueChanged += skin => CurrentSkin.Value = getSkin(skin.NewValue);
+            CurrentSkinInfo.ValueChanged += skin => CurrentSkin.Value = GetSkin(skin.NewValue);
             CurrentSkin.ValueChanged += skin =>
             {
                 if (skin.NewValue.SkinInfo != CurrentSkinInfo.Value)
@@ -80,7 +80,7 @@ namespace osu.Game.Skinning
         {
             await base.Populate(model, archive, cancellationToken);
 
-            Skin reference = getSkin(model);
+            Skin reference = GetSkin(model);
 
             if (!string.IsNullOrEmpty(reference.Configuration.SkinInfo.Name))
             {
@@ -99,7 +99,7 @@ namespace osu.Game.Skinning
         /// </summary>
         /// <param name="skinInfo">The skin to lookup.</param>
         /// <returns>A <see cref="Skin"/> instance correlating to the provided <see cref="SkinInfo"/>.</returns>
-        private Skin getSkin(SkinInfo skinInfo)
+        public Skin GetSkin(SkinInfo skinInfo)
         {
             if (skinInfo == SkinInfo.Default)
                 return new DefaultSkin();

osu.Game/Tests/Visual/OsuGridTestScene.cs

@@ -5,7 +5,7 @@ using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 
-namespace osu.Game.Tests.Visual.UserInterface
+namespace osu.Game.Tests.Visual
 {
     /// <summary>
     /// An abstract test case which exposes small cells arranged in a grid.

osu.iOS/Info.plist

@@ -14,6 +14,8 @@
 	<string>0.1.0</string>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
+	<key>LSSupportsOpeningDocumentsInPlace</key>
+	<true/>
 	<key>MinimumOSVersion</key>
 	<string>10.0</string>
 	<key>UIDeviceFamily</key>