Merge branch 'master' into songselect-best-user-score

osu.Android.props

@@ -63,6 +63,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.719.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.723.0" />
   </ItemGroup>
 </Project>

osu.Desktop/Program.cs

@@ -28,6 +28,8 @@ namespace osu.Desktop
                 host.ExceptionThrown += handleException;
 
                 if (!host.IsPrimaryInstance)
+                {
+                    if (args.Length > 0 && args[0].Contains('.')) // easy way to check for a file import in args
                     {
                         var importer = new ArchiveImportIPCChannel(host);
                         // Restore the cwd so relative paths given at the command line work correctly
@@ -39,9 +41,15 @@ namespace osu.Desktop
                             if (!importer.ImportAsync(Path.GetFullPath(file)).Wait(3000))
                                 throw new TimeoutException(@"IPC took too long to send");
                         }
+
+                        return 0;
                     }
-                else
+
-                {
+                    // we want to allow multiple instances to be started when in debug.
+                    if (!DebugUtils.IsDebugBuild)
+                        return 0;
+                }
+
                 switch (args.FirstOrDefault() ?? string.Empty)
                 {
                     default:
@@ -52,7 +60,6 @@ namespace osu.Desktop
                         host.Run(new TournamentGame());
                         break;
                 }
-                }
 
                 return 0;
             }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableCatchHitObject.cs

@@ -3,12 +3,10 @@
 
 using System;
 using osuTK;
-using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -60,16 +58,11 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                 ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss);
         }
 
-        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        protected override bool UseTransformStateManagement => false;
-        {
-            base.SkinChanged(skin, allowFallback);
-
-            if (HitObject is IHasComboInformation combo)
-                AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.ComboColours.Count > 0 ? s.ComboColours[combo.ComboIndex % s.ComboColours.Count] : (Color4?)null) ?? Color4.White;
-        }
 
         protected override void UpdateState(ArmedState state)
         {
+            // TODO: update to use new state management.
             using (BeginAbsoluteSequence(HitObject.StartTime - HitObject.TimePreempt))
                 this.FadeIn(200);
 

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableDroplet.cs

@@ -5,7 +5,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -27,16 +26,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
         private void load()
         {
             AddInternal(pulp = new Pulp { Size = Size });
-        }
 
-        public override Color4 AccentColour
+            AccentColour.BindValueChanged(colour => { pulp.AccentColour = colour.NewValue; }, true);
-        {
-            get => base.AccentColour;
-            set
-            {
-                base.AccentColour = value;
-                pulp.AccentColour = AccentColour;
-            }
         }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
         private void load()
         {
             // todo: this should come from the skin.
-            AccentColour = colourForRepresentation(HitObject.VisualRepresentation);
+            AccentColour.Value = colourForRepresentation(HitObject.VisualRepresentation);
 
             AddRangeInternal(new[]
             {
@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         Hollow = !HitObject.HyperDash,
                         Type = EdgeEffectType.Glow,
                         Radius = 4 * radius_adjust,
-                        Colour = HitObject.HyperDash ? Color4.Red : AccentColour.Darken(1).Opacity(0.6f)
+                        Colour = HitObject.HyperDash ? Color4.Red : AccentColour.Value.Darken(1).Opacity(0.6f)
                     },
                     Size = new Vector2(Height),
                     Anchor = Anchor.Centre,
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         new Box
                         {
                             AlwaysPresent = true,
-                            Colour = AccentColour,
+                            Colour = AccentColour.Value,
                             Alpha = 0,
                             RelativeSizeAxes = Axes.Both
                         }
@@ -115,32 +115,32 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         {
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(small_pulp),
                                 Y = -0.34f,
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4),
                                 Position = positionAt(0, distance_from_centre_4),
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4),
                                 Position = positionAt(90, distance_from_centre_4),
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4),
                                 Position = positionAt(180, distance_from_centre_4),
                             },
                             new Pulp
                             {
                                 Size = new Vector2(large_pulp_4),
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Position = positionAt(270, distance_from_centre_4),
                             },
                         }
@@ -154,32 +154,32 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         {
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(small_pulp),
                                 Y = -0.3f,
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4),
                                 Position = positionAt(45, distance_from_centre_4),
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4),
                                 Position = positionAt(135, distance_from_centre_4),
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4),
                                 Position = positionAt(225, distance_from_centre_4),
                             },
                             new Pulp
                             {
                                 Size = new Vector2(large_pulp_4),
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Position = positionAt(315, distance_from_centre_4),
                             },
                         }
@@ -193,26 +193,26 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         {
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(small_pulp),
                                 Y = -0.33f,
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_3),
                                 Position = positionAt(60, distance_from_centre_3),
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_3),
                                 Position = positionAt(180, distance_from_centre_3),
                             },
                             new Pulp
                             {
                                 Size = new Vector2(large_pulp_3),
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Position = positionAt(300, distance_from_centre_3),
                             },
                         }
@@ -226,26 +226,26 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         {
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(small_pulp),
                                 Y = -0.25f,
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_3),
                                 Position = positionAt(0, distance_from_centre_3),
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_3),
                                 Position = positionAt(120, distance_from_centre_3),
                             },
                             new Pulp
                             {
                                 Size = new Vector2(large_pulp_3),
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Position = positionAt(240, distance_from_centre_3),
                             },
                         }
@@ -259,13 +259,13 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                         {
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(small_pulp),
                                 Y = -0.3f
                             },
                             new Pulp
                             {
-                                AccentColour = AccentColour,
+                                AccentColour = AccentColour.Value,
                                 Size = new Vector2(large_pulp_4 * 0.8f, large_pulp_4 * 2.5f),
                                 Y = 0.05f,
                             },

osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteSelectionBlueprint.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Child = drawableObject = new DrawableHoldNote(holdNote)
                 {
                     Height = 300,
-                    AccentColour = OsuColour.Gray(0.3f)
+                    AccentColour = { Value = OsuColour.Gray(0.3f) }
                 }
             };
         }

osu.Game.Rulesets.Mania.Tests/TestSceneNotes.cs

@@ -70,7 +70,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AutoSizeAxes = Axes.Both,
                 Child = new NoteContainer(direction, $"note {identifier}, scrolling {direction.ToString().ToLowerInvariant()}")
                 {
-                    Child = hitObject = new DrawableNote(note) { AccentColour = Color4.OrangeRed }
+                    Child = hitObject = new DrawableNote(note) { AccentColour = { Value = Color4.OrangeRed } }
                 }
             };
         }
@@ -88,7 +88,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     Child = hitObject = new DrawableHoldNote(note)
                     {
                         RelativeSizeAxes = Axes.Both,
-                        AccentColour = Color4.OrangeRed,
+                        AccentColour = { Value = Color4.OrangeRed },
                     }
                 }
             };

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -6,7 +6,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-using osuTK.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Scoring;
@@ -36,11 +35,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// </summary>
         private bool hasBroken;
 
-        private readonly Container<DrawableHoldNoteTick> tickContainer;
-
         public DrawableHoldNote(HoldNote hitObject)
             : base(hitObject)
         {
+            Container<DrawableHoldNoteTick> tickContainer;
             RelativeSizeAxes = Axes.X;
 
             AddRangeInternal(new Drawable[]
@@ -74,6 +72,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             AddNested(Head);
             AddNested(Tail);
+
+            AccentColour.BindValueChanged(colour =>
+            {
+                bodyPiece.AccentColour = colour.NewValue;
+                Head.AccentColour.Value = colour.NewValue;
+                Tail.AccentColour.Value = colour.NewValue;
+                tickContainer.ForEach(t => t.AccentColour.Value = colour.NewValue);
+            }, true);
         }
 
         protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)
@@ -83,20 +89,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             bodyPiece.Anchor = bodyPiece.Origin = e.NewValue == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
         }
 
-        public override Color4 AccentColour
-        {
-            get => base.AccentColour;
-            set
-            {
-                base.AccentColour = value;
-
-                bodyPiece.AccentColour = value;
-                Head.AccentColour = value;
-                Tail.AccentColour = value;
-                tickContainer.ForEach(t => t.AccentColour = value);
-            }
-        }
-
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (Tail.AllJudged)

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNoteTick.cs

@@ -3,7 +3,6 @@
 
 using System;
 using osuTK;
-using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -23,11 +22,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// </summary>
         public Func<double?> HoldStartTime;
 
-        private readonly Container glowContainer;
-
         public DrawableHoldNoteTick(HoldNoteTick hitObject)
             : base(hitObject)
         {
+            Container glowContainer;
+
             Anchor = Anchor.TopCentre;
             Origin = Anchor.TopCentre;
 
@@ -53,23 +52,17 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     }
                 }
             });
-        }
 
-        public override Color4 AccentColour
+            AccentColour.BindValueChanged(colour =>
             {
-            get => base.AccentColour;
-            set
-            {
-                base.AccentColour = value;
-
                 glowContainer.EdgeEffect = new EdgeEffectParameters
                 {
                     Type = EdgeEffectType.Glow,
                     Radius = 2f,
                     Roundness = 15f,
-                    Colour = value.Opacity(0.3f)
+                    Colour = colour.NewValue.Opacity(0.3f)
                 };
-            }
+            }, true);
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableManiaHitObject.cs

@@ -58,8 +58,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             HitObject = hitObject;
         }
 
+        protected override bool UseTransformStateManagement => false;
+
         protected override void UpdateState(ArmedState state)
         {
+            // TODO: update to use new state management.
             switch (state)
             {
                 case ArmedState.Miss:

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.cs

@@ -3,7 +3,6 @@
 
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
-using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Input.Bindings;
@@ -30,6 +29,18 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             Masking = true;
 
             AddInternal(headPiece = new NotePiece());
+
+            AccentColour.BindValueChanged(colour =>
+            {
+                headPiece.AccentColour = colour.NewValue;
+
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Colour = colour.NewValue.Lighten(1f).Opacity(0.6f),
+                    Radius = 10,
+                };
+            }, true);
         }
 
         protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)
@@ -39,23 +50,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             headPiece.Anchor = headPiece.Origin = e.NewValue == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
         }
 
-        public override Color4 AccentColour
-        {
-            get => base.AccentColour;
-            set
-            {
-                base.AccentColour = value;
-                headPiece.AccentColour = AccentColour;
-
-                EdgeEffect = new EdgeEffectParameters
-                {
-                    Type = EdgeEffectType.Glow,
-                    Colour = AccentColour.Lighten(1f).Opacity(0.6f),
-                    Radius = 10,
-                };
-            }
-        }
-
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (!userTriggered)

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Mania.UI
         /// <param name="hitObject">The DrawableHitObject to add.</param>
         public override void Add(DrawableHitObject hitObject)
         {
-            hitObject.AccentColour = AccentColour;
+            hitObject.AccentColour.Value = AccentColour;
             hitObject.OnNewResult += OnNewResult;
 
             HitObjectContainer.Add(hitObject);

osu.Game.Rulesets.Mania/UI/HitExplosion.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 EdgeEffect = new EdgeEffectParameters
                 {
                     Type = EdgeEffectType.Glow,
-                    Colour = Interpolation.ValueAt(0.1f, judgedObject.AccentColour, Color4.White, 0, 1),
+                    Colour = Interpolation.ValueAt(0.1f, judgedObject.AccentColour.Value, Color4.White, 0, 1),
                     Radius = 100,
                 },
                 Child = new Box

osu.Game.Rulesets.Osu/Mods/OsuModTouchDevice.cs

@@ -11,6 +11,8 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "TD";
         public override double ScoreMultiplier => 1;
 
+        public override ModType Type => ModType.System;
+
         public override bool Ranked => true;
     }
 }

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

@@ -10,7 +10,6 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using osuTK;
 using osu.Game.Rulesets.Scoring;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -98,19 +97,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             positionBindable.BindTo(HitObject.PositionBindable);
             stackHeightBindable.BindTo(HitObject.StackHeightBindable);
             scaleBindable.BindTo(HitObject.ScaleBindable);
-        }
 
-        public override Color4 AccentColour
+            AccentColour.BindValueChanged(colour =>
             {
-            get => base.AccentColour;
+                explode.Colour = colour.NewValue;
-            set
+                glow.Colour = colour.NewValue;
-            {
+                circle.Colour = colour.NewValue;
-                base.AccentColour = value;
+                ApproachCircle.Colour = colour.NewValue;
-                explode.Colour = AccentColour;
+            }, true);
-                glow.Colour = AccentColour;
-                circle.Colour = AccentColour;
-                ApproachCircle.Colour = AccentColour;
-            }
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
@@ -134,16 +128,16 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ApplyResult(r => r.Type = result);
         }
 
-        protected override void UpdatePreemptState()
+        protected override void UpdateInitialTransforms()
         {
-            base.UpdatePreemptState();
+            base.UpdateInitialTransforms();
 
             ApproachCircle.FadeIn(Math.Min(HitObject.TimeFadeIn * 2, HitObject.TimePreempt));
             ApproachCircle.ScaleTo(1.1f, HitObject.TimePreempt);
             ApproachCircle.Expire(true);
         }
 
-        protected override void UpdateCurrentState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             glow.FadeOut(400);
 

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

@@ -1,15 +1,10 @@
-// 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 System;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Judgements;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Skinning;
-using osuTK.Graphics;
 using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -41,47 +36,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected sealed override double InitialLifetimeOffset => HitObject.TimePreempt;
 
-        protected sealed override void UpdateState(ArmedState state)
+        protected override void UpdateInitialTransforms() => this.FadeIn(HitObject.TimeFadeIn);
-        {
-            double transformTime = HitObject.StartTime - HitObject.TimePreempt;
-
-            base.ApplyTransformsAt(transformTime, true);
-            base.ClearTransformsAfter(transformTime, true);
-
-            using (BeginAbsoluteSequence(transformTime, true))
-            {
-                UpdatePreemptState();
-
-                var judgementOffset = Math.Min(HitObject.HitWindows.HalfWindowFor(HitResult.Miss), Result?.TimeOffset ?? 0);
-
-                using (BeginDelayedSequence(HitObject.TimePreempt + judgementOffset, true))
-                    UpdateCurrentState(state);
-            }
-        }
-
-        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-        {
-            base.SkinChanged(skin, allowFallback);
-
-            if (HitObject is IHasComboInformation combo)
-                AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.ComboColours.Count > 0 ? s.ComboColours[combo.ComboIndex % s.ComboColours.Count] : (Color4?)null) ?? Color4.White;
-        }
-
-        protected virtual void UpdatePreemptState() => this.FadeIn(HitObject.TimeFadeIn);
-
-        protected virtual void UpdateCurrentState(ArmedState state)
-        {
-        }
-
-        // Todo: At some point we need to move these to DrawableHitObject after ensuring that all other Rulesets apply
-        // transforms in the same way and don't rely on them not being cleared
-        public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null)
-        {
-        }
-
-        public override void ApplyTransformsAt(double time, bool propagateChildren = false)
-        {
-        }
 
         private OsuInputManager osuActionInputManager;
         internal OsuInputManager OsuActionInputManager => osuActionInputManager ?? (osuActionInputManager = GetContainingInputManager() as OsuInputManager);

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

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 ApplyResult(r => r.Type = drawableSlider.Tracking.Value ? HitResult.Great : HitResult.Miss);
         }
 
-        protected override void UpdatePreemptState()
+        protected override void UpdateInitialTransforms()
         {
             animDuration = Math.Min(150, repeatPoint.SpanDuration / 2);
 
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             );
         }
 
-        protected override void UpdateCurrentState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             switch (state)
             {

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

@@ -114,20 +114,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             pathBindable.BindTo(slider.PathBindable);
 
             pathBindable.BindValueChanged(_ => Body.Refresh());
-        }
 
-        public override Color4 AccentColour
+            AccentColour.BindValueChanged(colour =>
             {
-            get => base.AccentColour;
+                Body.AccentColour = colour.NewValue;
-            set
+                Ball.AccentColour = colour.NewValue;
-            {
-                base.AccentColour = value;
-                Body.AccentColour = AccentColour;
-                Ball.AccentColour = AccentColour;
 
                 foreach (var drawableHitObject in NestedHitObjects)
-                    drawableHitObject.AccentColour = AccentColour;
+                    drawableHitObject.AccentColour.Value = colour.NewValue;
-            }
+            }, true);
         }
 
         public readonly Bindable<bool> Tracking = new Bindable<bool>();
@@ -167,9 +162,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.SkinChanged(skin, allowFallback);
 
             Body.BorderSize = skin.GetValue<SkinConfiguration, float?>(s => s.SliderBorderSize) ?? SliderBody.DEFAULT_BORDER_SIZE;
-            Body.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderTrackOverride") ? s.CustomColours["SliderTrackOverride"] : (Color4?)null) ?? AccentColour;
+            Body.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderTrackOverride") ? s.CustomColours["SliderTrackOverride"] : (Color4?)null) ?? AccentColour.Value;
             Body.BorderColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBorder") ? s.CustomColours["SliderBorder"] : (Color4?)null) ?? Color4.White;
-            Ball.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBall") ? s.CustomColours["SliderBall"] : (Color4?)null) ?? AccentColour;
+            Ball.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBall") ? s.CustomColours["SliderBall"] : (Color4?)null) ?? AccentColour.Value;
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
@@ -195,7 +190,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             });
         }
 
-        protected override void UpdateCurrentState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             Ball.FadeIn();
             Ball.ScaleTo(HitObject.Scale);

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

@@ -34,14 +34,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     RelativeSizeAxes = Axes.Both,
                     Origin = Anchor.Centre,
                     CornerRadius = Size.X / 2,
-
                     BorderThickness = 2,
                     BorderColour = Color4.White,
-
                     Child = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = AccentColour,
+                        Colour = AccentColour.Value,
                         Alpha = 0.3f,
                     }
                 }, restrictSize: false)
@@ -54,13 +52,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 ApplyResult(r => r.Type = Tracking ? HitResult.Great : HitResult.Miss);
         }
 
-        protected override void UpdatePreemptState()
+        protected override void UpdateInitialTransforms()
         {
             this.FadeOut().FadeIn(ANIM_DURATION);
             this.ScaleTo(0.5f).ScaleTo(1f, ANIM_DURATION * 4, Easing.OutElasticHalf);
         }
 
-        protected override void UpdateCurrentState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             switch (state)
             {

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

@@ -196,9 +196,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             symbol.RotateTo(Disc.Rotation / 2, 500, Easing.OutQuint);
         }
 
-        protected override void UpdatePreemptState()
+        protected override void UpdateInitialTransforms()
         {
-            base.UpdatePreemptState();
+            base.UpdateInitialTransforms();
 
             circleContainer.ScaleTo(Spinner.Scale * 0.3f);
             circleContainer.ScaleTo(Spinner.Scale, HitObject.TimePreempt / 1.4f, Easing.OutQuint);
@@ -213,7 +213,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 .ScaleTo(1, 500, Easing.OutQuint);
         }
 
-        protected override void UpdateCurrentState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             var sequence = this.Delay(Spinner.Duration).FadeOut(160);
 

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -138,6 +138,12 @@ namespace osu.Game.Rulesets.Osu
                         new MultiMod(new ModWindUp<OsuHitObject>(), new ModWindDown<OsuHitObject>()),
                     };
 
+                case ModType.System:
+                    return new Mod[]
+                    {
+                        new OsuModTouchDevice(),
+                    };
+
                 default:
                     return new Mod[] { };
             }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs

@@ -94,6 +94,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         protected override void UpdateState(ArmedState state)
         {
+            // TODO: update to use new state management.
             var circlePiece = MainPiece as CirclePiece;
             circlePiece?.FlashBox.FinishTransforms();
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

@@ -121,6 +121,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             }
         }
 
+        protected override bool UseTransformStateManagement => false;
+
         // Normal and clap samples are handled by the drum
         protected override IEnumerable<HitSampleInfo> GetSamples() => HitObject.Samples.Where(s => s.Name != HitSampleInfo.HIT_NORMAL && s.Name != HitSampleInfo.HIT_CLAP);
 

osu.Game/Graphics/OpenGL/Vertices/PositionAndColourVertex.cs

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Runtime.InteropServices;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Graphics.ES30;
+
+namespace osu.Game.Graphics.OpenGL.Vertices
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct PositionAndColourVertex : IEquatable<PositionAndColourVertex>, IVertex
+    {
+        [VertexMember(2, VertexAttribPointerType.Float)]
+        public Vector2 Position;
+
+        [VertexMember(4, VertexAttribPointerType.Float)]
+        public Color4 Colour;
+
+        public bool Equals(PositionAndColourVertex other)
+            => Position.Equals(other.Position)
+               && Colour.Equals(other.Colour);
+    }
+}

osu.Game/Graphics/Sprites/GlowingSpriteText.cs

@@ -0,0 +1,80 @@
+// 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.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Graphics.Sprites
+{
+    public class GlowingSpriteText : Container, IHasText
+    {
+        private readonly OsuSpriteText spriteText, blurredText;
+
+        public string Text
+        {
+            get => spriteText.Text;
+            set => blurredText.Text = spriteText.Text = value;
+        }
+
+        public FontUsage Font
+        {
+            get => spriteText.Font;
+            set => blurredText.Font = spriteText.Font = value.With(fixedWidth: true);
+        }
+
+        public Vector2 TextSize
+        {
+            get => spriteText.Size;
+            set => blurredText.Size = spriteText.Size = value;
+        }
+
+        public ColourInfo TextColour
+        {
+            get => spriteText.Colour;
+            set => spriteText.Colour = value;
+        }
+
+        public ColourInfo GlowColour
+        {
+            get => blurredText.Colour;
+            set => blurredText.Colour = value;
+        }
+
+        public GlowingSpriteText()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            Children = new Drawable[]
+            {
+                new BufferedContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    BlurSigma = new Vector2(4),
+                    CacheDrawnFrameBuffer = true,
+                    RelativeSizeAxes = Axes.Both,
+                    Blending = BlendingMode.Additive,
+                    Size = new Vector2(3f),
+                    Children = new[]
+                    {
+                        blurredText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Shadow = false,
+                        },
+                    },
+                },
+                spriteText = new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Shadow = false,
+                },
+            };
+        }
+    }
+}

osu.Game/Graphics/UserInterface/SearchTextBox.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osuTK;
 using osuTK.Input;
@@ -33,6 +34,17 @@ namespace osu.Game.Graphics.UserInterface
             PlaceholderText = "type to search";
         }
 
+        public override bool OnPressed(PlatformAction action)
+        {
+            // Shift+delete is handled via PlatformAction on macOS. this is not so useful in the context of a SearchTextBox
+            // as we do not allow arrow key navigation in the first place (ie. the care should always be at the end of text)
+            // Avoid handling it here to allow other components to potentially consume the shortcut.
+            if (action.ActionType == PlatformActionType.CharNext && action.ActionMethod == PlatformActionMethod.Delete)
+                return false;
+
+            return base.OnPressed(action);
+        }
+
         protected override bool OnKeyDown(KeyDownEvent e)
         {
             if (!e.ControlPressed && !e.ShiftPressed)

osu.Game/Online/Leaderboards/LeaderboardScore.cs

@@ -187,7 +187,13 @@ namespace osu.Game.Online.Leaderboards
                                     Spacing = new Vector2(5f, 0f),
                                     Children = new Drawable[]
                                     {
-                                        scoreLabel = new GlowingSpriteText(score.TotalScore.ToString(@"N0"), OsuFont.Numeric.With(size: 23), Color4.White, OsuColour.FromHex(@"83ccfa")),
+                                        scoreLabel = new GlowingSpriteText
+                                        {
+                                            TextColour = Color4.White,
+                                            GlowColour = OsuColour.FromHex(@"83ccfa"),
+                                            Text = score.TotalScore.ToString(@"N0"),
+                                            Font = OsuFont.Numeric.With(size: 23),
+                                        },
                                         RankContainer = new Container
                                         {
                                             Size = new Vector2(40f, 20f),
@@ -275,49 +281,6 @@ namespace osu.Game.Online.Leaderboards
             base.OnHoverLost(e);
         }
 
-        private class GlowingSpriteText : Container
-        {
-            public GlowingSpriteText(string text, FontUsage font, Color4 textColour, Color4 glowColour)
-            {
-                AutoSizeAxes = Axes.Both;
-
-                Children = new Drawable[]
-                {
-                    new BufferedContainer
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        BlurSigma = new Vector2(4),
-                        CacheDrawnFrameBuffer = true,
-                        RelativeSizeAxes = Axes.Both,
-                        Blending = BlendingMode.Additive,
-                        Size = new Vector2(3f),
-                        Children = new[]
-                        {
-                            new OsuSpriteText
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Font = font.With(fixedWidth: true),
-                                Text = text,
-                                Colour = glowColour,
-                                Shadow = false,
-                            },
-                        },
-                    },
-                    new OsuSpriteText
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Font = font.With(fixedWidth: true),
-                        Text = text,
-                        Colour = textColour,
-                        Shadow = false,
-                    },
-                };
-            }
-        }
-
         private class ScoreComponentLabel : Container, IHasTooltip
         {
             private const float icon_size = 20;
@@ -367,10 +330,14 @@ namespace osu.Game.Online.Leaderboards
                                 },
                             },
                         },
-                        new GlowingSpriteText(statistic.Value, OsuFont.GetFont(size: 17, weight: FontWeight.Bold), Color4.White, OsuColour.FromHex(@"83ccfa"))
+                        new GlowingSpriteText
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
+                            TextColour = Color4.White,
+                            GlowColour = OsuColour.FromHex(@"83ccfa"),
+                            Text = statistic.Value,
+                            Font = OsuFont.GetFont(size: 17, weight: FontWeight.Bold),
                         },
                     },
                 };

osu.Game/OsuGame.cs

@@ -20,6 +20,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
@@ -153,7 +154,7 @@ namespace osu.Game
         {
             this.frameworkConfig = frameworkConfig;
 
-            if (!Host.IsPrimaryInstance)
+            if (!Host.IsPrimaryInstance && !DebugUtils.IsDebugBuild)
             {
                 Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
                 Environment.Exit(0);

osu.Game/Overlays/Chat/ChatLine.cs

@@ -85,6 +85,7 @@ namespace osu.Game.Overlays.Chat
 
             Drawable effectedUsername = username = new OsuSpriteText
             {
+                Shadow = false,
                 Colour = hasBackground ? customUsernameColour : username_colours[message.Sender.Id % username_colours.Length],
                 Font = OsuFont.GetFont(size: TextSize, weight: FontWeight.Bold, italics: true)
             };
@@ -133,6 +134,7 @@ namespace osu.Game.Overlays.Chat
                     {
                         timestamp = new OsuSpriteText
                         {
+                            Shadow = false,
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
                             Font = OsuFont.GetFont(size: TextSize * 0.75f, weight: FontWeight.SemiBold, fixedWidth: true)
@@ -155,6 +157,8 @@ namespace osu.Game.Overlays.Chat
                     {
                         contentFlow = new LinkFlowContainer(t =>
                         {
+                            t.Shadow = false;
+
                             if (Message.IsAction)
                             {
                                 t.Font = OsuFont.GetFont(italics: true);

osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs

@@ -71,16 +71,11 @@ namespace osu.Game.Overlays.Toolbar
         // Scheduled to allow the flow layout to be computed before the line position is updated
         private void moveLineToCurrent() => ScheduleAfterChildren(() =>
         {
-            foreach (var tabItem in TabContainer)
+            if (SelectedTab != null)
             {
-                if (tabItem.Value.Equals(Current.Value))
+                ModeButtonLine.MoveToX(SelectedTab.DrawPosition.X, !hasInitialPosition ? 0 : 200, Easing.OutQuint);
-                {
-                    ModeButtonLine.MoveToX(tabItem.DrawPosition.X, !hasInitialPosition ? 0 : 200, Easing.OutQuint);
-                    break;
-                }
-            }
-
                 hasInitialPosition = true;
+            }
         });
 
         public override bool HandleNonPositionalInput => !Current.Disabled && base.HandleNonPositionalInput;

osu.Game/Rulesets/Mods/ModFlashlight.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.OpenGL.Vertices;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shaders;
@@ -13,6 +14,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Graphics;
+using osu.Game.Graphics.OpenGL.Vertices;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
@@ -153,9 +155,17 @@ namespace osu.Game.Rulesets.Mods
                 private Vector2 flashlightSize;
                 private float flashlightDim;
 
+                private readonly VertexBatch<PositionAndColourVertex> quadBatch = new QuadBatch<PositionAndColourVertex>(1, 1);
+                private readonly Action<TexturedVertex2D> addAction;
+
                 public FlashlightDrawNode(Flashlight source)
                     : base(source)
                 {
+                    addAction = v => quadBatch.Add(new PositionAndColourVertex
+                    {
+                        Position = v.Position,
+                        Colour = v.Colour
+                    });
                 }
 
                 public override void ApplyState()
@@ -179,7 +189,7 @@ namespace osu.Game.Rulesets.Mods
                     shader.GetUniform<Vector2>("flashlightSize").UpdateValue(ref flashlightSize);
                     shader.GetUniform<float>("flashlightDim").UpdateValue(ref flashlightDim);
 
-                    DrawQuad(Texture.WhitePixel, screenSpaceDrawQuad, DrawColourInfo.Colour, vertexAction: vertexAction);
+                    DrawQuad(Texture.WhitePixel, screenSpaceDrawQuad, DrawColourInfo.Colour, vertexAction: addAction);
 
                     shader.Unbind();
                 }

osu.Game/Rulesets/Mods/ModType.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Mods
         DifficultyIncrease,
         Conversion,
         Automation,
-        Fun
+        Fun,
+        System
     }
 }

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -9,7 +9,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics.Primitives;
 using osu.Game.Audio;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -18,14 +17,14 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
-    public abstract class DrawableHitObject : SkinReloadableDrawable, IHasAccentColour
+    public abstract class DrawableHitObject : SkinReloadableDrawable
     {
         public readonly HitObject HitObject;
 
         /// <summary>
         /// The colour used for various elements of this DrawableHitObject.
         /// </summary>
-        public virtual Color4 AccentColour { get; set; } = Color4.Gray;
+        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>(Color4.Gray);
 
         // Todo: Rulesets should be overriding the resources instead, but we need to figure out where/when to apply overrides first
         protected virtual string SampleNamespace => null;
@@ -82,7 +81,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         public override bool IsPresent => base.IsPresent || (State.Value == ArmedState.Idle && Clock?.CurrentTime >= LifetimeStart);
 
-        public readonly Bindable<ArmedState> State = new Bindable<ArmedState>();
+        private readonly Bindable<ArmedState> state = new Bindable<ArmedState>();
+
+        public IBindable<ArmedState> State => state;
 
         protected DrawableHitObject(HitObject hitObject)
         {
@@ -117,33 +118,120 @@ namespace osu.Game.Rulesets.Objects.Drawables
             }
         }
 
-        protected override void ClearInternal(bool disposeChildren = true) => throw new InvalidOperationException($"Should never clear a {nameof(DrawableHitObject)}");
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
-
+            updateState(ArmedState.Idle, true);
-            State.ValueChanged += armed =>
-            {
-                UpdateState(armed.NewValue);
-
-                // apply any custom state overrides
-                ApplyCustomUpdateState?.Invoke(this, armed.NewValue);
-
-                if (armed.NewValue == ArmedState.Hit)
-                    PlaySamples();
-            };
-
-            State.TriggerChange();
         }
 
-        protected abstract void UpdateState(ArmedState state);
+        #region State / Transform Management
 
         /// <summary>
         /// Bind to apply a custom state which can override the default implementation.
         /// </summary>
         public event Action<DrawableHitObject, ArmedState> ApplyCustomUpdateState;
 
+        /// <summary>
+        /// Enables automatic transform management of this hitobject. Implementation of transforms should be done in <see cref="UpdateInitialTransforms"/> and <see cref="UpdateStateTransforms"/> only. Rewinding and removing previous states is done automatically.
+        /// </summary>
+        /// <remarks>
+        /// Going forward, this is the preferred way of implementing <see cref="DrawableHitObject"/>s. Previous functionality
+        /// is offered as a compatibility layer until all rulesets have been migrated across.
+        /// </remarks>
+        protected virtual bool UseTransformStateManagement => true;
+
+        protected override void ClearInternal(bool disposeChildren = true) => throw new InvalidOperationException($"Should never clear a {nameof(DrawableHitObject)}");
+
+        private void updateState(ArmedState newState, bool force = false)
+        {
+            if (State.Value == newState && !force)
+                return;
+
+            // apply any custom state overrides
+            ApplyCustomUpdateState?.Invoke(this, newState);
+
+            if (newState == ArmedState.Hit)
+                PlaySamples();
+
+            if (UseTransformStateManagement)
+            {
+                double transformTime = HitObject.StartTime - InitialLifetimeOffset;
+
+                base.ApplyTransformsAt(transformTime, true);
+                base.ClearTransformsAfter(transformTime, true);
+
+                using (BeginAbsoluteSequence(transformTime, true))
+                {
+                    UpdateInitialTransforms();
+
+                    var judgementOffset = Math.Min(HitObject.HitWindows?.HalfWindowFor(HitResult.Miss) ?? double.MaxValue, Result?.TimeOffset ?? 0);
+
+                    using (BeginDelayedSequence(InitialLifetimeOffset + judgementOffset, true))
+                    {
+                        UpdateStateTransforms(newState);
+                        state.Value = newState;
+                    }
+                }
+            }
+            else
+                state.Value = newState;
+
+            UpdateState(newState);
+        }
+
+        /// <summary>
+        /// Apply (generally fade-in) transforms leading into the <see cref="HitObject"/> start time.
+        /// The local drawable hierarchy is recursively delayed to <see cref="LifetimeStart"/> for convenience.
+        /// </summary>
+        /// <remarks>
+        /// This is called once before every <see cref="UpdateStateTransforms"/>. This is to ensure a good state in the case
+        /// the <see cref="JudgementResult.TimeOffset"/> was negative and potentially altered the pre-hit transforms.
+        /// </remarks>
+        protected virtual void UpdateInitialTransforms()
+        {
+        }
+
+        /// <summary>
+        /// Apply transforms based on the current <see cref="ArmedState"/>. Previous states are automatically cleared.
+        /// </summary>
+        /// <param name="state">The new armed state.</param>
+        protected virtual void UpdateStateTransforms(ArmedState state)
+        {
+        }
+
+        public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null)
+        {
+            // When we are using automatic state management, parent calls to this should be blocked for safety.
+            if (!UseTransformStateManagement)
+                base.ClearTransformsAfter(time, propagateChildren, targetMember);
+        }
+
+        public override void ApplyTransformsAt(double time, bool propagateChildren = false)
+        {
+            // When we are using automatic state management, parent calls to this should be blocked for safety.
+            if (!UseTransformStateManagement)
+                base.ApplyTransformsAt(time, propagateChildren);
+        }
+
+        /// <summary>
+        /// Legacy method to handle state changes.
+        /// Should generally not be used when <see cref="UseTransformStateManagement"/> is true; use <see cref="UpdateStateTransforms"/> instead.
+        /// </summary>
+        /// <param name="state">The new armed state.</param>
+        protected virtual void UpdateState(ArmedState state)
+        {
+        }
+
+        #endregion
+
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        {
+            base.SkinChanged(skin, allowFallback);
+
+            if (HitObject is IHasComboInformation combo)
+                AccentColour.Value = skin.GetValue<SkinConfiguration, Color4?>(s => s.ComboColours.Count > 0 ? s.ComboColours[combo.ComboIndex % s.ComboColours.Count] : (Color4?)null) ?? Color4.White;
+        }
+
         /// <summary>
         /// Plays all the hit sounds for this <see cref="DrawableHitObject"/>.
         /// This is invoked automatically when this <see cref="DrawableHitObject"/> is hit.
@@ -164,7 +252,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
                     Result.TimeOffset = 0;
                     Result.Type = HitResult.None;
-                    State.Value = ArmedState.Idle;
+
+                    updateState(ArmedState.Idle);
                 }
             }
         }
@@ -196,6 +285,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </summary>
         /// <remarks>
         /// This is only used as an optimisation to delay the initial update of this <see cref="DrawableHitObject"/> and may be tuned more aggressively if required.
+        /// It is indirectly used to decide the automatic transform offset provided to <see cref="UpdateInitialTransforms"/>.
         /// A more accurate <see cref="LifetimeStart"/> should be set inside <see cref="UpdateState"/> for an <see cref="ArmedState.Idle"/> state.
         /// </remarks>
         protected virtual double InitialLifetimeOffset => 10000;
@@ -244,11 +334,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
                     break;
 
                 case HitResult.Miss:
-                    State.Value = ArmedState.Miss;
+                    updateState(ArmedState.Miss);
                     break;
 
                 default:
-                    State.Value = ArmedState.Hit;
+                    updateState(ArmedState.Hit);
                     break;
             }
 

osu.Game/Screens/Play/BreakOverlay.cs

@@ -19,11 +19,11 @@ namespace osu.Game.Screens.Play
         private const float remaining_time_container_max_size = 0.3f;
         private const int vertical_margin = 25;
 
-        private List<BreakPeriod> breaks;
-
         private readonly Container fadeContainer;
 
-        public List<BreakPeriod> Breaks
+        private IReadOnlyList<BreakPeriod> breaks;
+
+        public IReadOnlyList<BreakPeriod> Breaks
         {
             get => breaks;
             set

osu.Game/osu.Game.csproj

@@ -15,7 +15,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.4" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.719.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.723.0" />
     <PackageReference Include="SharpCompress" Version="0.23.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />

osu.iOS.props

@@ -105,8 +105,8 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.719.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.723.0" />
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.719.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.723.0" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />