Merge pull request #8467 from peppy/update-framework

Update framework

fastlane/Fastfile

@@ -97,7 +97,7 @@ platform :ios do
     changelog.gsub!('$BUILD_ID', options[:build])
 
     pilot(
-      wait_processing_interval: 1800,
+      wait_processing_interval: 900,
       changelog: changelog,
       groups: ['osu! supporters', 'public'],
       distribute_external: true,

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.315.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.319.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.327.0" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Catch
             new KeyBinding(InputKey.Shift, CatchAction.Dash),
         };
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new CatchModNightcore();

osu.Game.Rulesets.Catch/Replays/CatchReplayFrame.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             }
         }
 
-        public void ConvertFrom(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             Position = currentFrame.Position.X / CatchPlayfield.BASE_WIDTH;
             Dashing = currentFrame.ButtonState == ReplayButtonState.Left1;
@@ -56,5 +56,14 @@ namespace osu.Game.Rulesets.Catch.Replays
                     Actions.Add(CatchAction.MoveLeft);
             }
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            ReplayButtonState state = ReplayButtonState.None;
+
+            if (Actions.Contains(CatchAction.Dash)) state |= ReplayButtonState.Left1;
+
+            return new LegacyReplayFrame(Time, Position * CatchPlayfield.BASE_WIDTH, null, state);
+        }
     }
 }

osu.Game.Rulesets.Catch/UI/CatchReplayRecorder.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.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatchReplayRecorder : ReplayRecorder<CatchAction>
+    {
+        private readonly CatchPlayfield playfield;
+
+        public CatchReplayRecorder(Replay target, CatchPlayfield playfield)
+            : base(target)
+        {
+            this.playfield = playfield;
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<CatchAction> actions, ReplayFrame previousFrame)
+            => new CatchReplayFrame(Time.Current, playfield.CatcherArea.MovableCatcher.X, actions.Contains(CatchAction.Dash), previousFrame as CatchReplayFrame);
+    }
+}

osu.Game.Rulesets.Catch/UI/Catcher.cs

@@ -141,14 +141,14 @@ namespace osu.Game.Rulesets.Catch.UI
             var ourRadius = fruit.DisplayRadius;
             float theirRadius = 0;
 
-            const float allowance = 6;
+            const float allowance = 10;
 
             while (caughtFruit.Any(f =>
                 f.LifetimeEnd == double.MaxValue &&
                 Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
             {
                 var diff = (ourRadius + theirRadius) / allowance;
-                fruit.X += (RNG.NextSingle() - 0.5f) * 2 * diff;
+                fruit.X += (RNG.NextSingle() - 0.5f) * diff * 2;
                 fruit.Y -= RNG.NextSingle() * diff;
             }
 

osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs

@@ -32,6 +32,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new CatchReplayRecorder(replay, (CatchPlayfield)Playfield);
+
         protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, CreateDrawableRepresentation);
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchPlayfieldAdjustmentContainer();

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             {
             }
 
-            protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            protected override KeyBindingContainer<ManiaAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
                 => new LocalKeyBindingContainer(ruleset, variant, unique);
 
             private class LocalKeyBindingContainer : RulesetKeyBindingContainer

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override ISkin CreateLegacySkinProvider(ISkinSource source) => new ManiaLegacySkinTransformer(source);
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new ManiaModNightcore();
@@ -118,6 +118,59 @@ namespace osu.Game.Rulesets.Mania
                 yield return new ManiaModRandom();
         }
 
+        public override LegacyMods ConvertToLegacyMods(Mod[] mods)
+        {
+            var value = base.ConvertToLegacyMods(mods);
+
+            foreach (var mod in mods)
+            {
+                switch (mod)
+                {
+                    case ManiaModKey1 _:
+                        value |= LegacyMods.Key1;
+                        break;
+
+                    case ManiaModKey2 _:
+                        value |= LegacyMods.Key2;
+                        break;
+
+                    case ManiaModKey3 _:
+                        value |= LegacyMods.Key3;
+                        break;
+
+                    case ManiaModKey4 _:
+                        value |= LegacyMods.Key4;
+                        break;
+
+                    case ManiaModKey5 _:
+                        value |= LegacyMods.Key5;
+                        break;
+
+                    case ManiaModKey6 _:
+                        value |= LegacyMods.Key6;
+                        break;
+
+                    case ManiaModKey7 _:
+                        value |= LegacyMods.Key7;
+                        break;
+
+                    case ManiaModKey8 _:
+                        value |= LegacyMods.Key8;
+                        break;
+
+                    case ManiaModKey9 _:
+                        value |= LegacyMods.Key9;
+                        break;
+
+                    case ManiaModFadeIn _:
+                        value |= LegacyMods.FadeIn;
+                        break;
+                }
+            }
+
+            return value;
+        }
+
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
             switch (type)

osu.Game.Rulesets.Mania/Mods/ManiaModRandom.cs

@@ -3,24 +3,17 @@
 
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModRandom : Mod, IApplicableToBeatmap
+    public class ManiaModRandom : ModRandom, IApplicableToBeatmap
     {
-        public override string Name => "Random";
-        public override string Acronym => "RD";
-        public override ModType Type => ModType.Conversion;
-        public override IconUsage? Icon => OsuIcon.Dice;
         public override string Description => @"Shuffle around the keys!";
-        public override double ScoreMultiplier => 1;
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {

osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -24,15 +25,9 @@ namespace osu.Game.Rulesets.Mania.Replays
             Actions.AddRange(actions);
         }
 
-        public void ConvertFrom(LegacyReplayFrame legacyFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame legacyFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
-            // We don't need to fully convert, just create the converter
-            var converter = new ManiaBeatmapConverter(beatmap, new ManiaRuleset());
-
-            // NB: Via co-op mod, osu-stable can have two stages with floor(col/2) and ceil(col/2) columns. This will need special handling
-            // elsewhere in the game if we do choose to support the old co-op mod anyway. For now, assume that there is only one stage.
-
-            var stage = new StageDefinition { Columns = converter.TargetColumns };
+            var maniaBeatmap = (ManiaBeatmap)beatmap;
 
             var normalAction = ManiaAction.Key1;
             var specialAction = ManiaAction.Special1;
@@ -42,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             while (activeColumns > 0)
             {
-                var isSpecial = stage.IsSpecialColumn(counter);
+                var isSpecial = maniaBeatmap.Stages.First().IsSpecialColumn(counter);
 
                 if ((activeColumns & 1) > 0)
                     Actions.Add(isSpecial ? specialAction : normalAction);
@@ -56,5 +51,40 @@ namespace osu.Game.Rulesets.Mania.Replays
                 activeColumns >>= 1;
             }
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            var maniaBeatmap = (ManiaBeatmap)beatmap;
+
+            int keys = 0;
+
+            var specialColumns = new List<int>();
+
+            for (int i = 0; i < maniaBeatmap.TotalColumns; i++)
+            {
+                if (maniaBeatmap.Stages.First().IsSpecialColumn(i))
+                    specialColumns.Add(i);
+            }
+
+            foreach (var action in Actions)
+            {
+                switch (action)
+                {
+                    case ManiaAction.Special1:
+                        keys |= 1 << specialColumns[0];
+                        break;
+
+                    case ManiaAction.Special2:
+                        keys |= 1 << specialColumns[1];
+                        break;
+
+                    default:
+                        keys |= 1 << (action - ManiaAction.Key1);
+                        break;
+                }
+            }
+
+            return new LegacyReplayFrame(Time, keys, null, ReplayButtonState.None);
+        }
     }
 }

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

@@ -85,5 +85,7 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
+
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new ManiaReplayRecorder(replay);
     }
 }

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

@@ -0,0 +1,23 @@
+// 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.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaReplayRecorder : ReplayRecorder<ManiaAction>
+    {
+        public ManiaReplayRecorder(Replay replay)
+            : base(replay)
+        {
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<ManiaAction> actions, ReplayFrame previousFrame)
+            => new ManiaReplayFrame(Time.Current, actions.ToArray());
+    }
+}

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

@@ -4,48 +4,43 @@
 using System;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 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.Rulesets.Scoring;
 using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneHitCircleArea : ManualInputManagerTestScene
+    public class TestSceneHitCircleArea : OsuManualInputManagerTestScene
     {
         private HitCircle hitCircle;
         private DrawableHitCircle drawableHitCircle;
         private DrawableHitCircle.HitReceptor hitAreaReceptor => drawableHitCircle.HitArea;
 
         [SetUp]
-        public new void SetUp()
+        public void SetUp() => Schedule(() =>
         {
-            base.SetUp();
-
-            Schedule(() =>
+            hitCircle = new HitCircle
             {
-                hitCircle = new HitCircle
-                {
-                    Position = new Vector2(100, 100),
-                    StartTime = Time.Current + 500
-                };
+                Position = new Vector2(100, 100),
+                StartTime = Time.Current + 500
+            };
 
-                hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+            hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-                Child = new SkinProvidingContainer(new DefaultSkin())
+            Child = new SkinProvidingContainer(new DefaultSkin())
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = drawableHitCircle = new DrawableHitCircle(hitCircle)
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Child = drawableHitCircle = new DrawableHitCircle(hitCircle)
-                    {
-                        Size = new Vector2(100)
-                    }
-                };
-            });
-        }
+                    Size = new Vector2(100)
+                }
+            };
+        });
 
         [Test]
         public void TestCircleHitCentre()

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

@@ -23,7 +23,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneOsuDistanceSnapGrid : ManualInputManagerTestScene
+    public class TestSceneOsuDistanceSnapGrid : OsuManualInputManagerTestScene
     {
         private const double beat_length = 100;
         private static readonly Vector2 grid_position = new Vector2(512, 384);

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

@@ -12,7 +12,7 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneResumeOverlay : ManualInputManagerTestScene
+    public class TestSceneResumeOverlay : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

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

@@ -11,6 +11,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Skinning;
+using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 
@@ -196,6 +197,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ApplyResult(r => r.Type = r.Judgement.MaxResult);
         }
 
+        public override void PlaySamples()
+        {
+            // rather than doing it this way, we should probably attach the sample to the tail circle.
+            // this can only be done after we stop using LegacyLastTick.
+            if (TailCircle.Result.Type != HitResult.Miss)
+                base.PlaySamples();
+        }
+
         protected override void UpdateStateTransforms(ArmedState state)
         {
             base.UpdateStateTransforms(state);

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

@@ -126,7 +126,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     .FadeTo(tracking_alpha, 250, Easing.OutQuint);
             }
 
-            this.RotateTo(currentRotation / 2, validAndTracking ? 500 : 1500, Easing.OutExpo);
+            Rotation = (float)Interpolation.Lerp(Rotation, currentRotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/SliderRepeat.cs

@@ -34,8 +34,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public class SliderRepeatJudgement : OsuJudgement
         {
-            public override bool IsBonus => true;
-
             protected override int NumericResultFor(HitResult result) => result == MaxResult ? 30 : 0;
         }
     }

osu.Game.Rulesets.Osu/Objects/SliderTick.cs

@@ -36,8 +36,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public class SliderTickJudgement : OsuJudgement
         {
-            public override bool IsBonus => true;
-
             protected override int NumericResultFor(HitResult result) => result == MaxResult ? 10 : 0;
         }
     }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu
         /// </summary>
         public bool AllowUserCursorMovement { get; set; } = true;
 
-        protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+        protected override KeyBindingContainer<OsuAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
             => new OsuKeyBindingContainer(ruleset, variant, unique);
 
         public OsuInputManager(RulesetInfo ruleset)

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu
             new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
         };
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new OsuModNightcore();

osu.Game.Rulesets.Osu/Replays/OsuReplayFrame.cs

@@ -26,11 +26,23 @@ namespace osu.Game.Rulesets.Osu.Replays
             Actions.AddRange(actions);
         }
 
-        public void ConvertFrom(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             Position = currentFrame.Position;
             if (currentFrame.MouseLeft) Actions.Add(OsuAction.LeftButton);
             if (currentFrame.MouseRight) Actions.Add(OsuAction.RightButton);
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            ReplayButtonState state = ReplayButtonState.None;
+
+            if (Actions.Contains(OsuAction.LeftButton))
+                state |= ReplayButtonState.Left1;
+            if (Actions.Contains(OsuAction.RightButton))
+                state |= ReplayButtonState.Right1;
+
+            return new LegacyReplayFrame(Time, Position.X, Position.Y, state);
+        }
     }
 }

osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs

@@ -58,6 +58,8 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new OsuFramedReplayInputHandler(replay);
 
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new OsuReplayRecorder(replay);
+
         public override double GameplayStartTime
         {
             get

osu.Game.Rulesets.Osu/UI/OsuReplayRecorder.cs

@@ -0,0 +1,23 @@
+// 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.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public class OsuReplayRecorder : ReplayRecorder<OsuAction>
+    {
+        public OsuReplayRecorder(Replay replay)
+            : base(replay)
+        {
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<OsuAction> actions, ReplayFrame previousFrame)
+            => new OsuReplayFrame(Time.Current, mousePosition, actions.ToArray());
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModPerfect.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
 
         [TestCase(false)]
         [TestCase(true)]
-        public void TestHit(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new CentreHit { StartTime = 1000 }), shouldMiss);
+        public void TestHit(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Hit { StartTime = 1000, Type = HitType.Centre }), shouldMiss);
 
         [TestCase(false)]
         [TestCase(true)]

osu.Game.Rulesets.Taiko.Tests/TaikoBeatmapConversionTest.cs

@@ -27,8 +27,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
             {
                 StartTime = hitObject.StartTime,
                 EndTime = hitObject.GetEndTime(),
-                IsRim = hitObject is RimHit,
-                IsCentre = hitObject is CentreHit,
+                IsRim = (hitObject as Hit)?.Type == HitType.Rim,
+                IsCentre = (hitObject as Hit)?.Type == HitType.Centre,
                 IsDrumRoll = hitObject is DrumRoll,
                 IsSwell = hitObject is Swell,
                 IsStrong = ((TaikoHitObject)hitObject).IsStrong

osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoPlayfield.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             WorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
             {
-                HitObjects = new List<HitObject> { new CentreHit() },
+                HitObjects = new List<HitObject> { new Hit { Type = HitType.Centre } },
                 BeatmapInfo = new BeatmapInfo
                 {
                     BaseDifficulty = new BeatmapDifficulty(),

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -124,24 +124,13 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                             bool isRim = currentSamples.Any(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE);
                             strong = currentSamples.Any(s => s.Name == HitSampleInfo.HIT_FINISH);
 
-                            if (isRim)
+                            yield return new Hit
                             {
-                                yield return new RimHit
-                                {
-                                    StartTime = j,
-                                    Samples = currentSamples,
-                                    IsStrong = strong
-                                };
-                            }
-                            else
-                            {
-                                yield return new CentreHit
-                                {
-                                    StartTime = j,
-                                    Samples = currentSamples,
-                                    IsStrong = strong
-                                };
-                            }
+                                StartTime = j,
+                                Type = isRim ? HitType.Rim : HitType.Centre,
+                                Samples = currentSamples,
+                                IsStrong = strong
+                            };
 
                             i = (i + 1) % allSamples.Count;
                         }
@@ -180,24 +169,13 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 {
                     bool isRim = samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE);
 
-                    if (isRim)
+                    yield return new Hit
                     {
-                        yield return new RimHit
-                        {
-                            StartTime = obj.StartTime,
-                            Samples = obj.Samples,
-                            IsStrong = strong
-                        };
-                    }
-                    else
-                    {
-                        yield return new CentreHit
-                        {
-                            StartTime = obj.StartTime,
-                            Samples = obj.Samples,
-                            IsStrong = strong
-                        };
-                    }
+                        StartTime = obj.StartTime,
+                        Type = isRim ? HitType.Rim : HitType.Centre,
+                        Samples = obj.Samples,
+                        IsStrong = strong
+                    };
 
                     break;
                 }

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
         public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate)
             : base(hitObject, lastObject, clockRate)
         {
-            HasTypeChange = lastObject is RimHit != hitObject is RimHit;
+            HasTypeChange = (lastObject as Hit)?.Type != (hitObject as Hit)?.Type;
         }
     }
 }

osu.Game.Rulesets.Taiko/Mods/TaikoModRandom.cs

@@ -0,0 +1,27 @@
+// 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.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Mods
+{
+    public class TaikoModRandom : ModRandom, IApplicableToBeatmap
+    {
+        public override string Description => @"Shuffle around the colours!";
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            var taikoBeatmap = (TaikoBeatmap)beatmap;
+
+            foreach (var obj in taikoBeatmap.HitObjects)
+            {
+                if (obj is Hit hit)
+                    hit.Type = RNG.Next(2) == 0 ? HitType.Centre : HitType.Rim;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Objects/CentreHit.cs

@@ -1,9 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-namespace osu.Game.Rulesets.Taiko.Objects
-{
-    public class CentreHit : Hit
-    {
-    }
-}

osu.Game.Rulesets.Taiko/Objects/Hit.cs

@@ -5,5 +5,9 @@ namespace osu.Game.Rulesets.Taiko.Objects
 {
     public class Hit : TaikoHitObject
     {
+        /// <summary>
+        /// The <see cref="HitType"/> that actuates this <see cref="Hit"/>.
+        /// </summary>
+        public HitType Type { get; set; }
     }
 }

osu.Game.Rulesets.Taiko/Objects/HitType.cs

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    /// <summary>
+    /// The type of a <see cref="Hit"/>.
+    /// </summary>
+    public enum HitType
+    {
+        /// <summary>
+        /// A <see cref="Hit"/> that can be hit by the centre portion of the drum.
+        /// </summary>
+        Centre,
+
+        /// <summary>
+        /// A <see cref="Hit"/> that can be hit by the rim portion of the drum.
+        /// </summary>
+        Rim
+    }
+}

osu.Game.Rulesets.Taiko/Objects/RimHit.cs

@@ -1,9 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-namespace osu.Game.Rulesets.Taiko.Objects
-{
-    public class RimHit : Hit
-    {
-    }
-}

osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs

@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Taiko.Replays
                     {
                         TaikoAction[] actions;
 
-                        if (hit is CentreHit)
+                        if (hit.Type == HitType.Centre)
                         {
                             actions = h.IsStrong
                                 ? new[] { TaikoAction.LeftCentre, TaikoAction.RightCentre }

osu.Game.Rulesets.Taiko/Replays/TaikoReplayFrame.cs

@@ -23,12 +23,24 @@ namespace osu.Game.Rulesets.Taiko.Replays
             Actions.AddRange(actions);
         }
 
-        public void ConvertFrom(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             if (currentFrame.MouseRight1) Actions.Add(TaikoAction.LeftRim);
             if (currentFrame.MouseRight2) Actions.Add(TaikoAction.RightRim);
             if (currentFrame.MouseLeft1) Actions.Add(TaikoAction.LeftCentre);
             if (currentFrame.MouseLeft2) Actions.Add(TaikoAction.RightCentre);
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            ReplayButtonState state = ReplayButtonState.None;
+
+            if (Actions.Contains(TaikoAction.LeftRim)) state |= ReplayButtonState.Right1;
+            if (Actions.Contains(TaikoAction.RightRim)) state |= ReplayButtonState.Right2;
+            if (Actions.Contains(TaikoAction.LeftCentre)) state |= ReplayButtonState.Left1;
+            if (Actions.Contains(TaikoAction.RightCentre)) state |= ReplayButtonState.Left2;
+
+            return new LegacyReplayFrame(Time, null, null, state);
+        }
     }
 }

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Taiko
             new KeyBinding(InputKey.K, TaikoAction.RightRim),
         };
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new TaikoModNightcore();
@@ -114,6 +114,7 @@ namespace osu.Game.Rulesets.Taiko
                 case ModType.Conversion:
                     return new Mod[]
                     {
+                        new TaikoModRandom(),
                         new TaikoModDifficultyAdjust(),
                     };
 

osu.Game.Rulesets.Taiko/UI/DrawableTaikoRuleset.cs

@@ -48,11 +48,11 @@ namespace osu.Game.Rulesets.Taiko.UI
         {
             switch (h)
             {
-                case CentreHit centreHit:
-                    return new DrawableCentreHit(centreHit);
-
-                case RimHit rimHit:
-                    return new DrawableRimHit(rimHit);
+                case Hit hit:
+                    if (hit.Type == HitType.Centre)
+                        return new DrawableCentreHit(hit);
+                    else
+                        return new DrawableRimHit(hit);
 
                 case DrumRoll drumRoll:
                     return new DrawableDrumRoll(drumRoll);
@@ -65,5 +65,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         }
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new TaikoFramedReplayInputHandler(replay);
+
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new TaikoReplayRecorder(replay);
     }
 }

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -14,9 +14,9 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
+using osu.Game.Rulesets.Taiko.Objects;
 using osuTK;
 using osuTK.Graphics;
 
@@ -245,7 +245,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                     if (!result.IsHit)
                         break;
 
-                    bool isRim = judgedObject.HitObject is RimHit;
+                    bool isRim = (judgedObject.HitObject as Hit)?.Type == HitType.Rim;
 
                     hitExplosionContainer.Add(new HitExplosion(judgedObject, isRim));
 

osu.Game.Rulesets.Taiko/UI/TaikoReplayRecorder.cs

@@ -0,0 +1,23 @@
+// 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.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    public class TaikoReplayRecorder : ReplayRecorder<TaikoAction>
+    {
+        public TaikoReplayRecorder(Replay replay)
+            : base(replay)
+        {
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<TaikoAction> actions, ReplayFrame previousFrame) =>
+            new TaikoReplayFrame(Time.Current, actions.ToArray());
+    }
+}

osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs

@@ -26,34 +26,34 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 Assert.IsTrue(storyboard.HasDrawable);
-                Assert.AreEqual(4, storyboard.Layers.Count());
+                Assert.AreEqual(5, storyboard.Layers.Count());
 
                 StoryboardLayer background = storyboard.Layers.FirstOrDefault(l => l.Depth == 3);
                 Assert.IsNotNull(background);
                 Assert.AreEqual(16, background.Elements.Count);
-                Assert.IsTrue(background.EnabledWhenFailing);
-                Assert.IsTrue(background.EnabledWhenPassing);
+                Assert.IsTrue(background.VisibleWhenFailing);
+                Assert.IsTrue(background.VisibleWhenPassing);
                 Assert.AreEqual("Background", background.Name);
 
                 StoryboardLayer fail = storyboard.Layers.FirstOrDefault(l => l.Depth == 2);
                 Assert.IsNotNull(fail);
                 Assert.AreEqual(0, fail.Elements.Count);
-                Assert.IsTrue(fail.EnabledWhenFailing);
-                Assert.IsFalse(fail.EnabledWhenPassing);
+                Assert.IsTrue(fail.VisibleWhenFailing);
+                Assert.IsFalse(fail.VisibleWhenPassing);
                 Assert.AreEqual("Fail", fail.Name);
 
                 StoryboardLayer pass = storyboard.Layers.FirstOrDefault(l => l.Depth == 1);
                 Assert.IsNotNull(pass);
                 Assert.AreEqual(0, pass.Elements.Count);
-                Assert.IsFalse(pass.EnabledWhenFailing);
-                Assert.IsTrue(pass.EnabledWhenPassing);
+                Assert.IsFalse(pass.VisibleWhenFailing);
+                Assert.IsTrue(pass.VisibleWhenPassing);
                 Assert.AreEqual("Pass", pass.Name);
 
                 StoryboardLayer foreground = storyboard.Layers.FirstOrDefault(l => l.Depth == 0);
                 Assert.IsNotNull(foreground);
                 Assert.AreEqual(151, foreground.Elements.Count);
-                Assert.IsTrue(foreground.EnabledWhenFailing);
-                Assert.IsTrue(foreground.EnabledWhenPassing);
+                Assert.IsTrue(foreground.VisibleWhenFailing);
+                Assert.IsTrue(foreground.VisibleWhenPassing);
                 Assert.AreEqual("Foreground", foreground.Name);
 
                 int spriteCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardSprite));

osu.Game.Tests/Gameplay/TestSceneReplayRecorder.cs

@@ -0,0 +1,282 @@
+// 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.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Input.StateChanges;
+using osu.Framework.Testing;
+using osu.Framework.Threading;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Replays;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osu.Game.Tests.Visual;
+using osu.Game.Tests.Visual.UserInterface;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Gameplay
+{
+    public class TestSceneReplayRecorder : OsuManualInputManagerTestScene
+    {
+        private TestRulesetInputManager playbackManager;
+        private TestRulesetInputManager recordingManager;
+
+        private Replay replay;
+
+        private TestReplayRecorder recorder;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            replay = new Replay();
+
+            Add(new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        recordingManager = new TestRulesetInputManager(new TestSceneModSettings.TestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        {
+                            Recorder = recorder = new TestReplayRecorder(replay)
+                            {
+                                ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos),
+                            },
+                            Child = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        Colour = Color4.Brown,
+                                        RelativeSizeAxes = Axes.Both,
+                                    },
+                                    new OsuSpriteText
+                                    {
+                                        Text = "Recording",
+                                        Scale = new Vector2(3),
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                    },
+                                    new TestInputConsumer()
+                                }
+                            },
+                        }
+                    },
+                    new Drawable[]
+                    {
+                        playbackManager = new TestRulesetInputManager(new TestSceneModSettings.TestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        {
+                            ReplayInputHandler = new TestFramedReplayInputHandler(replay)
+                            {
+                                GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
+                            },
+                            Child = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        Colour = Color4.DarkBlue,
+                                        RelativeSizeAxes = Axes.Both,
+                                    },
+                                    new OsuSpriteText
+                                    {
+                                        Text = "Playback",
+                                        Scale = new Vector2(3),
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                    },
+                                    new TestInputConsumer()
+                                }
+                            },
+                        }
+                    }
+                }
+            });
+        });
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("move to center", () => InputManager.MoveMouseTo(recordingManager.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("one frame recorded", () => replay.Frames.Count == 1);
+            AddAssert("position matches", () => playbackManager.ChildrenOfType<Box>().First().Position == recordingManager.ChildrenOfType<Box>().First().Position);
+        }
+
+        [Test]
+        public void TestHighFrameRate()
+        {
+            ScheduledDelegate moveFunction = null;
+
+            AddStep("move to center", () => InputManager.MoveMouseTo(recordingManager.ScreenSpaceDrawQuad.Centre));
+            AddStep("much move", () => moveFunction = Scheduler.AddDelayed(() =>
+                InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(-1, 0)), 10, true));
+            AddWaitStep("move", 10);
+            AddStep("stop move", () => moveFunction.Cancel());
+            AddAssert("at least 60 frames recorded", () => replay.Frames.Count > 60);
+        }
+
+        [Test]
+        public void TestLimitedFrameRate()
+        {
+            ScheduledDelegate moveFunction = null;
+
+            AddStep("lower rate", () => recorder.RecordFrameRate = 2);
+            AddStep("move to center", () => InputManager.MoveMouseTo(recordingManager.ScreenSpaceDrawQuad.Centre));
+            AddStep("much move", () => moveFunction = Scheduler.AddDelayed(() =>
+                InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(-1, 0)), 10, true));
+            AddWaitStep("move", 10);
+            AddStep("stop move", () => moveFunction.Cancel());
+            AddAssert("less than 10 frames recorded", () => replay.Frames.Count < 10);
+        }
+
+        [Test]
+        public void TestLimitedFrameRateWithImportantFrames()
+        {
+            ScheduledDelegate moveFunction = null;
+
+            AddStep("lower rate", () => recorder.RecordFrameRate = 2);
+            AddStep("move to center", () => InputManager.MoveMouseTo(recordingManager.ScreenSpaceDrawQuad.Centre));
+            AddStep("much move with press", () => moveFunction = Scheduler.AddDelayed(() =>
+            {
+                InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(-1, 0));
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseButton(MouseButton.Left);
+            }, 10, true));
+            AddWaitStep("move", 10);
+            AddStep("stop move", () => moveFunction.Cancel());
+            AddAssert("at least 60 frames recorded", () => replay.Frames.Count > 60);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            playbackManager?.ReplayInputHandler.SetFrameFromTime(Time.Current - 100);
+        }
+
+        public class TestFramedReplayInputHandler : FramedReplayInputHandler<TestReplayFrame>
+        {
+            public TestFramedReplayInputHandler(Replay replay)
+                : base(replay)
+            {
+            }
+
+            public override List<IInput> GetPendingInputs()
+            {
+                return new List<IInput>
+                {
+                    new MousePositionAbsoluteInput
+                    {
+                        Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero)
+                    },
+                    new ReplayState<TestAction>
+                    {
+                        PressedActions = CurrentFrame?.Actions ?? new List<TestAction>()
+                    }
+                };
+            }
+        }
+
+        public class TestInputConsumer : CompositeDrawable, IKeyBindingHandler<TestAction>
+        {
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parent.ReceivePositionalInputAt(screenSpacePos);
+
+            private readonly Box box;
+
+            public TestInputConsumer()
+            {
+                Size = new Vector2(30);
+
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    box = new Box
+                    {
+                        Colour = Color4.Black,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                };
+            }
+
+            protected override bool OnMouseMove(MouseMoveEvent e)
+            {
+                Position = e.MousePosition;
+                return base.OnMouseMove(e);
+            }
+
+            public bool OnPressed(TestAction action)
+            {
+                box.Colour = Color4.White;
+                return true;
+            }
+
+            public void OnReleased(TestAction action)
+            {
+                box.Colour = Color4.Black;
+            }
+        }
+
+        public class TestRulesetInputManager : RulesetInputManager<TestAction>
+        {
+            public TestRulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                : base(ruleset, variant, unique)
+            {
+            }
+
+            protected override KeyBindingContainer<TestAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                => new TestKeyBindingContainer();
+
+            internal class TestKeyBindingContainer : KeyBindingContainer<TestAction>
+            {
+                public override IEnumerable<KeyBinding> DefaultKeyBindings => new[]
+                {
+                    new KeyBinding(InputKey.MouseLeft, TestAction.Down),
+                };
+            }
+        }
+
+        public class TestReplayFrame : ReplayFrame
+        {
+            public Vector2 Position;
+
+            public List<TestAction> Actions = new List<TestAction>();
+
+            public TestReplayFrame(double time, Vector2 position, params TestAction[] actions)
+                : base(time)
+            {
+                Position = position;
+                Actions.AddRange(actions);
+            }
+        }
+
+        public enum TestAction
+        {
+            Down,
+        }
+
+        internal class TestReplayRecorder : ReplayRecorder<TestAction>
+        {
+            public TestReplayRecorder(Replay target)
+                : base(target)
+            {
+            }
+
+            protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<TestAction> actions, ReplayFrame previousFrame)
+                => new TestReplayFrame(Time.Current, mousePosition, actions.ToArray());
+        }
+    }
+}

osu.Game.Tests/Gameplay/TestSceneReplayRecording.cs

@@ -0,0 +1,221 @@
+// 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.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Input.StateChanges;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Replays;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osu.Game.Tests.Visual;
+using osu.Game.Tests.Visual.UserInterface;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Gameplay
+{
+    public class TestSceneReplayRecording : OsuTestScene
+    {
+        private readonly TestRulesetInputManager playbackManager;
+
+        private readonly TestRulesetInputManager recordingManager;
+
+        public TestSceneReplayRecording()
+        {
+            Replay replay = new Replay();
+
+            Add(new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        recordingManager = new TestRulesetInputManager(new TestSceneModSettings.TestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        {
+                            Recorder = new TestReplayRecorder(replay)
+                            {
+                                ScreenSpaceToGamefield = pos => recordingManager.ToLocalSpace(pos)
+                            },
+                            Child = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        Colour = Color4.Brown,
+                                        RelativeSizeAxes = Axes.Both,
+                                    },
+                                    new OsuSpriteText
+                                    {
+                                        Text = "Recording",
+                                        Scale = new Vector2(3),
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                    },
+                                    new TestConsumer()
+                                }
+                            },
+                        }
+                    },
+                    new Drawable[]
+                    {
+                        playbackManager = new TestRulesetInputManager(new TestSceneModSettings.TestRulesetInfo(), 0, SimultaneousBindingMode.Unique)
+                        {
+                            ReplayInputHandler = new TestFramedReplayInputHandler(replay)
+                            {
+                                GamefieldToScreenSpace = pos => playbackManager.ToScreenSpace(pos),
+                            },
+                            Child = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        Colour = Color4.DarkBlue,
+                                        RelativeSizeAxes = Axes.Both,
+                                    },
+                                    new OsuSpriteText
+                                    {
+                                        Text = "Playback",
+                                        Scale = new Vector2(3),
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                    },
+                                    new TestConsumer()
+                                }
+                            },
+                        }
+                    }
+                }
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            playbackManager.ReplayInputHandler.SetFrameFromTime(Time.Current - 500);
+        }
+    }
+
+    public class TestFramedReplayInputHandler : FramedReplayInputHandler<TestReplayFrame>
+    {
+        public TestFramedReplayInputHandler(Replay replay)
+            : base(replay)
+        {
+        }
+
+        public override List<IInput> GetPendingInputs()
+        {
+            return new List<IInput>
+            {
+                new MousePositionAbsoluteInput
+                {
+                    Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero)
+                },
+                new ReplayState<TestAction>
+                {
+                    PressedActions = CurrentFrame?.Actions ?? new List<TestAction>()
+                }
+            };
+        }
+    }
+
+    public class TestConsumer : CompositeDrawable, IKeyBindingHandler<TestAction>
+    {
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parent.ReceivePositionalInputAt(screenSpacePos);
+
+        private readonly Box box;
+
+        public TestConsumer()
+        {
+            Size = new Vector2(30);
+
+            Origin = Anchor.Centre;
+
+            InternalChildren = new Drawable[]
+            {
+                box = new Box
+                {
+                    Colour = Color4.Black,
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            Position = e.MousePosition;
+            return base.OnMouseMove(e);
+        }
+
+        public bool OnPressed(TestAction action)
+        {
+            box.Colour = Color4.White;
+            return true;
+        }
+
+        public void OnReleased(TestAction action)
+        {
+            box.Colour = Color4.Black;
+        }
+    }
+
+    public class TestRulesetInputManager : RulesetInputManager<TestAction>
+    {
+        public TestRulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            : base(ruleset, variant, unique)
+        {
+        }
+
+        protected override KeyBindingContainer<TestAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            => new TestKeyBindingContainer();
+
+        internal class TestKeyBindingContainer : KeyBindingContainer<TestAction>
+        {
+            public override IEnumerable<KeyBinding> DefaultKeyBindings => new[]
+            {
+                new KeyBinding(InputKey.MouseLeft, TestAction.Down),
+            };
+        }
+    }
+
+    public class TestReplayFrame : ReplayFrame
+    {
+        public Vector2 Position;
+
+        public List<TestAction> Actions = new List<TestAction>();
+
+        public TestReplayFrame(double time, Vector2 position, params TestAction[] actions)
+            : base(time)
+        {
+            Position = position;
+            Actions.AddRange(actions);
+        }
+    }
+
+    public enum TestAction
+    {
+        Down,
+    }
+
+    internal class TestReplayRecorder : ReplayRecorder<TestAction>
+    {
+        public TestReplayRecorder(Replay target)
+            : base(target)
+        {
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<TestAction> actions, ReplayFrame previousFrame) =>
+            new TestReplayFrame(Time.Current, mousePosition, actions.ToArray());
+    }
+}

osu.Game.Tests/Resources/storyboard_no_video.osu

@@ -0,0 +1,31 @@
+osu file format v14
+
+[Events]
+//Background and Video events
+0,0,"BG.jpg",0,0
+Video,0,"video.avi"
+//Break Periods
+//Storyboard Layer 0 (Background)
+//Storyboard Layer 1 (Fail)
+//Storyboard Layer 2 (Pass)
+//Storyboard Layer 3 (Foreground)
+//Storyboard Layer 4 (Overlay)
+//Storyboard Sound Samples
+
+[TimingPoints]
+1674,333.333333333333,4,2,1,70,1,0
+1674,-100,4,2,1,70,0,0
+3340,-100,4,2,1,70,0,0
+3507,-100,4,2,1,70,0,0
+3673,-100,4,2,1,70,0,0
+
+[Colours]
+Combo1 : 240,80,80
+Combo2 : 171,252,203
+Combo3 : 128,128,255
+Combo4 : 249,254,186
+
+[HitObjects]
+148,303,1674,5,6,3:2:0:0:
+378,252,1840,1,0,0:0:0:0:
+389,270,2340,5,2,0:1:0:0:

osu.Game.Tests/Scores/IO/ImportScoreTest.cs

@@ -236,8 +236,6 @@ namespace osu.Game.Tests.Scores.IO
             }
 
             public override IEnumerable<string> Filenames => new[] { "test_file.osr" };
-
-            public override Stream GetUnderlyingStream() => new MemoryStream();
         }
     }
 }

osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs

@@ -37,7 +37,7 @@ using osuTK.Graphics;
 namespace osu.Game.Tests.Visual.Background
 {
     [TestFixture]
-    public class TestSceneUserDimBackgrounds : ManualInputManagerTestScene
+    public class TestSceneUserDimBackgrounds : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -278,6 +278,7 @@ namespace osu.Game.Tests.Visual.Background
 
         private void setupUserSettings()
         {
+            AddUntilStep("Song select is current", () => songSelect.IsCurrentScreen());
             AddUntilStep("Song select has selection", () => songSelect.Carousel?.SelectedBeatmap != null);
             AddStep("Set default user settings", () =>
             {

osu.Game.Tests/Visual/Components/TestSceneIdleTracker.cs

@@ -12,7 +12,7 @@ using osuTK.Graphics;
 namespace osu.Game.Tests.Visual.Components
 {
     [TestFixture]
-    public class TestSceneIdleTracker : ManualInputManagerTestScene
+    public class TestSceneIdleTracker : OsuManualInputManagerTestScene
     {
         private IdleTrackingBox box1;
         private IdleTrackingBox box2;

osu.Game.Tests/Visual/Editor/TestSceneBeatDivisorControl.cs

@@ -3,27 +3,83 @@
 
 using System;
 using System.Collections.Generic;
-using osu.Framework.Allocation;
+using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Editor
 {
-    public class TestSceneBeatDivisorControl : OsuTestScene
+    public class TestSceneBeatDivisorControl : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BindableBeatDivisor) };
+        private BeatDivisorControl beatDivisorControl;
+        private BindableBeatDivisor bindableBeatDivisor;
 
-        [BackgroundDependencyLoader]
-        private void load()
+        private SliderBar<int> tickSliderBar;
+        private EquilateralTriangle tickMarkerHead;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
         {
-            Child = new BeatDivisorControl(new BindableBeatDivisor())
+            Child = beatDivisorControl = new BeatDivisorControl(bindableBeatDivisor = new BindableBeatDivisor(16))
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(90, 90)
             };
+
+            tickSliderBar = beatDivisorControl.ChildrenOfType<SliderBar<int>>().Single();
+            tickMarkerHead = tickSliderBar.ChildrenOfType<EquilateralTriangle>().Single();
+        });
+
+        [Test]
+        public void TestBindableBeatDivisor()
+        {
+            AddRepeatStep("move previous", () => bindableBeatDivisor.Previous(), 4);
+            AddAssert("divisor is 4", () => bindableBeatDivisor.Value == 4);
+            AddRepeatStep("move next", () => bindableBeatDivisor.Next(), 3);
+            AddAssert("divisor is 12", () => bindableBeatDivisor.Value == 12);
+        }
+
+        [Test]
+        public void TestMouseInput()
+        {
+            AddStep("hold marker", () =>
+            {
+                InputManager.MoveMouseTo(tickMarkerHead.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+            });
+            AddStep("move to 8 and release", () =>
+            {
+                InputManager.MoveMouseTo(tickSliderBar.ScreenSpaceDrawQuad.Centre);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+            AddAssert("divisor is 8", () => bindableBeatDivisor.Value == 8);
+            AddStep("hold marker", () => InputManager.PressButton(MouseButton.Left));
+            AddStep("move to 16", () => InputManager.MoveMouseTo(getPositionForDivisor(16)));
+            AddStep("move to ~10 and release", () =>
+            {
+                InputManager.MoveMouseTo(getPositionForDivisor(10));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+            AddAssert("divisor clamped to 8", () => bindableBeatDivisor.Value == 8);
+        }
+
+        private Vector2 getPositionForDivisor(int divisor)
+        {
+            var relativePosition = (float)Math.Clamp(divisor, 0, 16) / 16;
+            var sliderDrawQuad = tickSliderBar.ScreenSpaceDrawQuad;
+            return new Vector2(
+                sliderDrawQuad.TopLeft.X + sliderDrawQuad.Width * relativePosition,
+                sliderDrawQuad.Centre.Y
+            );
         }
     }
 }

osu.Game.Tests/Visual/Editor/TestSceneZoomableScrollContainer.cs

@@ -17,7 +17,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Editor
 {
-    public class TestSceneZoomableScrollContainer : ManualInputManagerTestScene
+    public class TestSceneZoomableScrollContainer : OsuManualInputManagerTestScene
     {
         private ZoomableScrollContainer scrollContainer;
         private Drawable innerBox;

osu.Game.Tests/Visual/Gameplay/TestSceneAutoplay.cs

@@ -3,6 +3,7 @@
 
 using System.ComponentModel;
 using System.Linq;
+using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Play;
 
@@ -23,7 +24,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddUntilStep("score above zero", () => Player.ScoreProcessor.TotalScore.Value > 0);
             AddUntilStep("key counter counted keys", () => Player.HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 2));
-            AddStep("seek to break time", () => Player.GameplayClockContainer.Seek(Player.BreakOverlay.Breaks.First().StartTime));
+            AddStep("seek to break time", () => Player.GameplayClockContainer.Seek(Player.ChildrenOfType<BreakTracker>().First().Breaks.First().StartTime));
             AddUntilStep("wait for seek to complete", () =>
                 Player.HUDOverlay.Progress.ReferenceClock.CurrentTime >= Player.BreakOverlay.Breaks.First().StartTime);
             AddAssert("test keys not counting", () => !Player.HUDOverlay.KeyCounter.IsCounting);

osu.Game.Tests/Visual/Gameplay/TestSceneBreakTracker.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Screens.Play;
@@ -12,14 +13,16 @@ using osu.Game.Screens.Play;
 namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
-    public class TestSceneBreakOverlay : OsuTestScene
+    public class TestSceneBreakTracker : OsuTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(BreakOverlay),
         };
 
-        private readonly TestBreakOverlay breakOverlay;
+        private readonly BreakOverlay breakOverlay;
+
+        private readonly TestBreakTracker breakTracker;
 
         private readonly IReadOnlyList<BreakPeriod> testBreaks = new List<BreakPeriod>
         {
@@ -35,9 +38,23 @@ namespace osu.Game.Tests.Visual.Gameplay
             },
         };
 
-        public TestSceneBreakOverlay()
+        public TestSceneBreakTracker()
         {
-            Add(breakOverlay = new TestBreakOverlay(true));
+            AddRange(new Drawable[]
+            {
+                breakTracker = new TestBreakTracker(),
+                breakOverlay = new BreakOverlay(true)
+                {
+                    ProcessCustomClock = false,
+                }
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            breakOverlay.Clock = breakTracker.Clock;
         }
 
         [Test]
@@ -88,7 +105,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             loadBreaksStep("multiple breaks", testBreaks);
 
             seekAndAssertBreak("seek to break start", testBreaks[1].StartTime, true);
-            AddAssert("is skipped to break #2", () => breakOverlay.CurrentBreakIndex == 1);
+            AddAssert("is skipped to break #2", () => breakTracker.CurrentBreakIndex == 1);
 
             seekAndAssertBreak("seek to break middle", testBreaks[1].StartTime + testBreaks[1].Duration / 2, true);
             seekAndAssertBreak("seek to break end", testBreaks[1].EndTime, false);
@@ -110,7 +127,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void addShowBreakStep(double seconds)
         {
-            AddStep($"show '{seconds}s' break", () => breakOverlay.Breaks = new List<BreakPeriod>
+            AddStep($"show '{seconds}s' break", () => breakOverlay.Breaks = breakTracker.Breaks = new List<BreakPeriod>
             {
                 new BreakPeriod
                 {
@@ -122,12 +139,12 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void setClock(bool useManual)
         {
-            AddStep($"set {(useManual ? "manual" : "realtime")} clock", () => breakOverlay.SwitchClock(useManual));
+            AddStep($"set {(useManual ? "manual" : "realtime")} clock", () => breakTracker.SwitchClock(useManual));
         }
 
         private void loadBreaksStep(string breakDescription, IReadOnlyList<BreakPeriod> breaks)
         {
-            AddStep($"load {breakDescription}", () => breakOverlay.Breaks = breaks);
+            AddStep($"load {breakDescription}", () => breakOverlay.Breaks = breakTracker.Breaks = breaks);
             seekAndAssertBreak("seek back to 0", 0, false);
         }
 
@@ -151,17 +168,18 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void seekAndAssertBreak(string seekStepDescription, double time, bool shouldBeBreak)
         {
-            AddStep(seekStepDescription, () => breakOverlay.ManualClockTime = time);
+            AddStep(seekStepDescription, () => breakTracker.ManualClockTime = time);
             AddAssert($"is{(!shouldBeBreak ? " not" : string.Empty)} break time", () =>
             {
-                breakOverlay.ProgressTime();
-                return breakOverlay.IsBreakTime.Value == shouldBeBreak;
+                breakTracker.ProgressTime();
+                return breakTracker.IsBreakTime.Value == shouldBeBreak;
             });
         }
 
-        private class TestBreakOverlay : BreakOverlay
+        private class TestBreakTracker : BreakTracker
         {
-            private readonly FramedClock framedManualClock;
+            public readonly FramedClock FramedManualClock;
+
             private readonly ManualClock manualClock;
             private IFrameBasedClock originalClock;
 
@@ -173,20 +191,19 @@ namespace osu.Game.Tests.Visual.Gameplay
                 set => manualClock.CurrentTime = value;
             }
 
-            public TestBreakOverlay(bool letterboxing)
-                : base(letterboxing)
+            public TestBreakTracker()
             {
-                framedManualClock = new FramedClock(manualClock = new ManualClock());
+                FramedManualClock = new FramedClock(manualClock = new ManualClock());
                 ProcessCustomClock = false;
             }
 
             public void ProgressTime()
             {
-                framedManualClock.ProcessFrame();
+                FramedManualClock.ProcessFrame();
                 Update();
             }
 
-            public void SwitchClock(bool setManual) => Clock = setManual ? framedManualClock : originalClock;
+            public void SwitchClock(bool setManual) => Clock = setManual ? FramedManualClock : originalClock;
 
             protected override void LoadComplete()
             {

osu.Game.Tests/Visual/Gameplay/TestSceneGameplayMenuOverlay.cs

@@ -18,7 +18,7 @@ using osuTK.Input;
 namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("player pause/fail screens")]
-    public class TestSceneGameplayMenuOverlay : ManualInputManagerTestScene
+    public class TestSceneGameplayMenuOverlay : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseOverlay) };
 

osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs

@@ -15,7 +15,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneHUDOverlay : ManualInputManagerTestScene
+    public class TestSceneHUDOverlay : OsuManualInputManagerTestScene
     {
         private HUDOverlay hudOverlay;
 

osu.Game.Tests/Visual/Gameplay/TestSceneHoldForMenuButton.cs

@@ -13,7 +13,7 @@ using osuTK.Input;
 namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("'Hold to Quit' UI element")]
-    public class TestSceneHoldForMenuButton : ManualInputManagerTestScene
+    public class TestSceneHoldForMenuButton : OsuManualInputManagerTestScene
     {
         private bool exitAction;
 

osu.Game.Tests/Visual/Gameplay/TestSceneKeyCounter.cs

@@ -13,7 +13,7 @@ using osuTK.Input;
 namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
-    public class TestSceneKeyCounter : ManualInputManagerTestScene
+    public class TestSceneKeyCounter : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs

@@ -29,7 +29,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestScenePlayerLoader : ManualInputManagerTestScene
+    public class TestScenePlayerLoader : OsuManualInputManagerTestScene
     {
         private TestPlayerLoader loader;
         private TestPlayerLoaderContainer container;

osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs

@@ -14,7 +14,7 @@ using osuTK.Input;
 namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
-    public class TestSceneSkipOverlay : ManualInputManagerTestScene
+    public class TestSceneSkipOverlay : OsuManualInputManagerTestScene
     {
         private SkipOverlay skip;
         private int requestCount;

osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs

@@ -9,8 +9,12 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
 using osu.Game.Overlays;
+using osu.Game.Storyboards;
 using osu.Game.Storyboards.Drawables;
+using osu.Game.Tests.Resources;
 using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -54,7 +58,11 @@ namespace osu.Game.Tests.Visual.Gameplay
                     State = { Value = Visibility.Visible },
                 }
             });
+        }
 
+        [Test]
+        public void TestStoryboard()
+        {
             AddStep("Restart", restart);
             AddToggleStep("Passing", passing =>
             {
@@ -62,6 +70,12 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
         }
 
+        [Test]
+        public void TestStoryboardMissingVideo()
+        {
+            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -94,5 +108,28 @@ namespace osu.Game.Tests.Visual.Gameplay
             storyboardContainer.Add(storyboard);
             decoupledClock.ChangeSource(working.Track);
         }
+
+        private void loadStoryboardNoVideo()
+        {
+            if (storyboard != null)
+                storyboardContainer.Remove(storyboard);
+
+            var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
+            storyboardContainer.Clock = decoupledClock;
+
+            Storyboard sb;
+
+            using (var str = TestResources.OpenResource("storyboard_no_video.osu"))
+            using (var bfr = new LineBufferedReader(str))
+            {
+                var decoder = new LegacyStoryboardDecoder();
+                sb = decoder.Decode(bfr);
+            }
+
+            storyboard = sb.CreateDrawable(Beatmap.Value);
+
+            storyboardContainer.Add(storyboard);
+            decoupledClock.ChangeSource(Beatmap.Value.Track);
+        }
     }
 }

osu.Game.Tests/Visual/Menus/IntroTestScene.cs

@@ -64,6 +64,8 @@ namespace osu.Game.Tests.Visual.Menus
 
                 introStack.Push(CreateScreen());
             });
+
+            AddUntilStep("wait for menu", () => introStack.CurrentScreen is MainMenu);
         }
 
         protected abstract IScreen CreateScreen();

osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs

@@ -20,7 +20,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public class TestSceneDrawableRoomPlaylist : ManualInputManagerTestScene
+    public class TestSceneDrawableRoomPlaylist : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/Navigation/OsuGameTestScene.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Tests.Visual.Navigation
     /// <summary>
     /// A scene which tests full game flow.
     /// </summary>
-    public abstract class OsuGameTestScene : ManualInputManagerTestScene
+    public abstract class OsuGameTestScene : OsuManualInputManagerTestScene
     {
         private GameHost host;
 

osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs

@@ -22,7 +22,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Online
 {
-    public class TestSceneChatOverlay : ManualInputManagerTestScene
+    public class TestSceneChatOverlay : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/Online/TestSceneFriendDisplay.cs

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays.Dashboard.Friends;
+using osu.Framework.Graphics;
+using osu.Game.Users;
+using osu.Game.Overlays;
+using osu.Framework.Allocation;
+using NUnit.Framework;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneFriendDisplay : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(FriendDisplay),
+            typeof(FriendOnlineStreamControl),
+            typeof(UserListToolbar)
+        };
+
+        protected override bool UseOnlineAPI => true;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        private FriendDisplay display;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Child = new BasicScrollContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = display = new FriendDisplay()
+            };
+        });
+
+        [Test]
+        public void TestOffline()
+        {
+            AddStep("Populate", () => display.Users = getUsers());
+        }
+
+        [Test]
+        public void TestOnline()
+        {
+            AddStep("Fetch online", () => display?.Fetch());
+        }
+
+        private List<User> getUsers() => new List<User>
+        {
+            new User
+            {
+                Username = "flyte",
+                Id = 3103765,
+                IsOnline = true,
+                CurrentModeRank = 1111,
+                Country = new Country { FlagName = "JP" },
+                CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
+            },
+            new User
+            {
+                Username = "peppy",
+                Id = 2,
+                IsOnline = false,
+                CurrentModeRank = 2222,
+                Country = new Country { FlagName = "AU" },
+                CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                IsSupporter = true,
+                SupportLevel = 3,
+            },
+            new User
+            {
+                Username = "Evast",
+                Id = 8195163,
+                Country = new Country { FlagName = "BY" },
+                CoverUrl = "https://assets.ppy.sh/user-profile-covers/8195163/4a8e2ad5a02a2642b631438cfa6c6bd7e2f9db289be881cb27df18331f64144c.jpeg",
+                IsOnline = false,
+                LastVisit = DateTimeOffset.Now
+            }
+        };
+    }
+}

osu.Game.Tests/Visual/Online/TestSceneUserPanel.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Tests.Visual.Online
         private readonly Bindable<UserStatus> status = new Bindable<UserStatus>();
 
         private UserGridPanel peppy;
-        private UserListPanel evast;
+        private TestUserListPanel evast;
 
         [Resolved]
         private RulesetStore rulesetStore { get; set; }
@@ -38,6 +38,9 @@ namespace osu.Game.Tests.Visual.Online
         {
             UserGridPanel flyte;
 
+            activity.Value = null;
+            status.Value = null;
+
             Child = new FillFlowContainer
             {
                 Anchor = Anchor.Centre,
@@ -63,7 +66,7 @@ namespace osu.Game.Tests.Visual.Online
                         IsSupporter = true,
                         SupportLevel = 3,
                     }) { Width = 300 },
-                    evast = new UserListPanel(new User
+                    evast = new TestUserListPanel(new User
                     {
                         Username = @"Evast",
                         Id = 8195163,
@@ -96,7 +99,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestUserActivity()
         {
-            AddStep("set online status", () => peppy.Status.Value = evast.Status.Value = new UserStatusOnline());
+            AddStep("set online status", () => status.Value = new UserStatusOnline());
 
             AddStep("idle", () => activity.Value = null);
             AddStep("spectating", () => activity.Value = new UserActivity.Spectating());
@@ -109,6 +112,29 @@ namespace osu.Game.Tests.Visual.Online
             AddStep("modding", () => activity.Value = new UserActivity.Modding());
         }
 
+        [Test]
+        public void TestUserActivityChange()
+        {
+            AddAssert("visit message is visible", () => evast.LastVisitMessage.IsPresent);
+            AddStep("set online status", () => status.Value = new UserStatusOnline());
+            AddAssert("visit message is not visible", () => !evast.LastVisitMessage.IsPresent);
+            AddStep("set choosing activity", () => activity.Value = new UserActivity.ChoosingBeatmap());
+            AddStep("set offline status", () => status.Value = new UserStatusOffline());
+            AddAssert("visit message is visible", () => evast.LastVisitMessage.IsPresent);
+            AddStep("set online status", () => status.Value = new UserStatusOnline());
+            AddAssert("visit message is not visible", () => !evast.LastVisitMessage.IsPresent);
+        }
+
         private UserActivity soloGameStatusForRuleset(int rulesetId) => new UserActivity.SoloGame(null, rulesetStore.GetRuleset(rulesetId));
+
+        private class TestUserListPanel : UserListPanel
+        {
+            public TestUserListPanel(User user)
+                : base(user)
+            {
+            }
+
+            public new TextFlowContainer LastVisitMessage => base.LastVisitMessage;
+        }
     }
 }

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs

@@ -227,6 +227,34 @@ namespace osu.Game.Tests.Visual.SongSelect
             waitForSelection(set_count);
         }
 
+        [Test]
+        public void TestSelectionEnteringFromEmptyRuleset()
+        {
+            var sets = new List<BeatmapSetInfo>();
+
+            AddStep("Create beatmaps for taiko only", () =>
+            {
+                sets.Clear();
+
+                var rulesetBeatmapSet = createTestBeatmapSet(1);
+                var taikoRuleset = rulesets.AvailableRulesets.ElementAt(1);
+                rulesetBeatmapSet.Beatmaps.ForEach(b =>
+                {
+                    b.Ruleset = taikoRuleset;
+                    b.RulesetID = 1;
+                });
+
+                sets.Add(rulesetBeatmapSet);
+            });
+
+            loadBeatmaps(sets, () => new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) });
+
+            AddStep("Set non-empty mode filter", () =>
+                carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(1) }, false));
+
+            AddAssert("Something is selected", () => carousel.SelectedBeatmap != null);
+        }
+
         /// <summary>
         /// Test sorting
         /// </summary>
@@ -399,27 +427,32 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("filter to ruleset 0", () =>
                 carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }, false));
             AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testMixed.Beatmaps[1], false));
-            AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmap == null);
+            AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmap.RulesetID == 0);
 
             AddStep("remove mixed set", () =>
             {
                 carousel.RemoveBeatmapSet(testMixed);
                 testMixed = null;
             });
-            var testSingle = createTestBeatmapSet(set_count + 2);
-            testSingle.Beatmaps.ForEach(b =>
+            BeatmapSetInfo testSingle = null;
+            AddStep("add single ruleset beatmapset", () =>
             {
-                b.Ruleset = rulesets.AvailableRulesets.ElementAt(1);
-                b.RulesetID = b.Ruleset.ID ?? 1;
+                testSingle = createTestBeatmapSet(set_count + 2);
+                testSingle.Beatmaps.ForEach(b =>
+                {
+                    b.Ruleset = rulesets.AvailableRulesets.ElementAt(1);
+                    b.RulesetID = b.Ruleset.ID ?? 1;
+                });
+
+                carousel.UpdateBeatmapSet(testSingle);
             });
-            AddStep("add single ruleset beatmapset", () => carousel.UpdateBeatmapSet(testSingle));
             AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testSingle.Beatmaps[0], false));
             checkNoSelection();
             AddStep("remove single ruleset set", () => carousel.RemoveBeatmapSet(testSingle));
         }
 
         [Test]
-        public void TestCarouselRootIsRandom()
+        public void TestCarouselRemembersSelection()
         {
             List<BeatmapSetInfo> manySets = new List<BeatmapSetInfo>();
 
@@ -429,12 +462,74 @@ namespace osu.Game.Tests.Visual.SongSelect
             loadBeatmaps(manySets);
 
             advanceSelection(direction: 1, diff: false);
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            checkNonmatchingFilter();
-            AddAssert("Selection was random", () => eagerSelectedIDs.Count > 1);
+
+            for (int i = 0; i < 5; i++)
+            {
+                AddStep("Toggle non-matching filter", () =>
+                {
+                    carousel.Filter(new FilterCriteria { SearchText = Guid.NewGuid().ToString() }, false);
+                });
+
+                AddStep("Restore no filter", () =>
+                {
+                    carousel.Filter(new FilterCriteria(), false);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                });
+            }
+
+            // always returns to same selection as long as it's available.
+            AddAssert("Selection was remembered", () => eagerSelectedIDs.Count == 1);
+        }
+
+        [Test]
+        public void TestRandomFallbackOnNonMatchingPrevious()
+        {
+            List<BeatmapSetInfo> manySets = new List<BeatmapSetInfo>();
+
+            AddStep("populate maps", () =>
+            {
+                for (int i = 0; i < 10; i++)
+                {
+                    var set = createTestBeatmapSet(i);
+
+                    foreach (var b in set.Beatmaps)
+                    {
+                        // all taiko except for first
+                        int ruleset = i > 0 ? 1 : 0;
+
+                        b.Ruleset = rulesets.GetRuleset(ruleset);
+                        b.RulesetID = ruleset;
+                    }
+
+                    manySets.Add(set);
+                }
+            });
+
+            loadBeatmaps(manySets);
+
+            for (int i = 0; i < 10; i++)
+            {
+                AddStep("Reset filter", () => carousel.Filter(new FilterCriteria(), false));
+
+                AddStep("select first beatmap", () => carousel.SelectBeatmap(manySets.First().Beatmaps.First()));
+
+                AddStep("Toggle non-matching filter", () =>
+                {
+                    carousel.Filter(new FilterCriteria { SearchText = Guid.NewGuid().ToString() }, false);
+                });
+
+                AddAssert("selection lost", () => carousel.SelectedBeatmap == null);
+
+                AddStep("Restore different ruleset filter", () =>
+                {
+                    carousel.Filter(new FilterCriteria { Ruleset = rulesets.GetRuleset(1) }, false);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                });
+
+                AddAssert("selection changed", () => carousel.SelectedBeatmap != manySets.First().Beatmaps.First());
+            }
+
+            AddAssert("Selection was random", () => eagerSelectedIDs.Count > 2);
         }
 
         [Test]
@@ -484,7 +579,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             checkVisibleItemCount(true, 15);
         }
 
-        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null)
+        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null, Func<FilterCriteria> initialCriteria = null)
         {
             createCarousel();
 
@@ -499,7 +594,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             bool changed = false;
             AddStep($"Load {(beatmapSets.Count > 0 ? beatmapSets.Count.ToString() : "some")} beatmaps", () =>
             {
-                carousel.Filter(new FilterCriteria());
+                carousel.Filter(initialCriteria?.Invoke() ?? new FilterCriteria());
                 carousel.BeatmapSetsChanged = () => changed = true;
                 carousel.BeatmapSets = beatmapSets;
             });
@@ -593,16 +688,6 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("Selection is visible", selectedBeatmapVisible);
         }
 
-        private void checkNonmatchingFilter()
-        {
-            AddStep("Toggle non-matching filter", () =>
-            {
-                carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false);
-                carousel.Filter(new FilterCriteria(), false);
-                eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
-            });
-        }
-
         private BeatmapSetInfo createTestBeatmapSet(int id)
         {
             return new BeatmapSetInfo

osu.Game.Tests/Visual/UserInterface/TestSceneCommentEditor.cs

@@ -15,7 +15,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneCommentEditor : ManualInputManagerTestScene
+    public class TestSceneCommentEditor : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/UserInterface/TestSceneCursors.cs

@@ -17,7 +17,7 @@ using osuTK.Graphics;
 namespace osu.Game.Tests.Visual.UserInterface
 {
     [TestFixture]
-    public class TestSceneCursors : ManualInputManagerTestScene
+    public class TestSceneCursors : OsuManualInputManagerTestScene
     {
         private readonly MenuCursorContainer menuCursorContainer;
         private readonly CustomCursorBox[] cursorBoxes = new CustomCursorBox[6];

osu.Game.Tests/Visual/UserInterface/TestSceneDeleteLocalScore.cs

@@ -27,7 +27,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneDeleteLocalScore : ManualInputManagerTestScene
+    public class TestSceneDeleteLocalScore : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/UserInterface/TestSceneFriendsOnlineStatusControl.cs

@@ -8,7 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Overlays;
-using osu.Game.Overlays.Home.Friends;
+using osu.Game.Overlays.Dashboard.Friends;
 using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -17,20 +17,20 @@ namespace osu.Game.Tests.Visual.UserInterface
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(FriendsOnlineStatusControl),
+            typeof(FriendOnlineStreamControl),
             typeof(FriendsOnlineStatusItem),
             typeof(OverlayStreamControl<>),
             typeof(OverlayStreamItem<>),
-            typeof(FriendsBundle)
+            typeof(FriendStream)
         };
 
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
 
-        private FriendsOnlineStatusControl control;
+        private FriendOnlineStreamControl control;
 
         [SetUp]
-        public void SetUp() => Schedule(() => Child = control = new FriendsOnlineStatusControl
+        public void SetUp() => Schedule(() => Child = control = new FriendOnlineStreamControl
         {
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
@@ -55,9 +55,9 @@ namespace osu.Game.Tests.Visual.UserInterface
                 }
             }));
 
-            AddAssert("3 users", () => control.Items.FirstOrDefault(item => item.Status == FriendsOnlineStatus.All)?.Count == 3);
-            AddAssert("1 online user", () => control.Items.FirstOrDefault(item => item.Status == FriendsOnlineStatus.Online)?.Count == 1);
-            AddAssert("2 offline users", () => control.Items.FirstOrDefault(item => item.Status == FriendsOnlineStatus.Offline)?.Count == 2);
+            AddAssert("3 users", () => control.Items.FirstOrDefault(item => item.Status == OnlineStatus.All)?.Count == 3);
+            AddAssert("1 online user", () => control.Items.FirstOrDefault(item => item.Status == OnlineStatus.Online)?.Count == 1);
+            AddAssert("2 offline users", () => control.Items.FirstOrDefault(item => item.Status == OnlineStatus.Offline)?.Count == 2);
         }
     }
 }

osu.Game.Tests/Visual/UserInterface/TestSceneOsuHoverContainer.cs

@@ -12,7 +12,7 @@ using osuTK.Graphics;
 namespace osu.Game.Tests.Visual.UserInterface
 {
     [TestFixture]
-    public class TestSceneOsuHoverContainer : ManualInputManagerTestScene
+    public class TestSceneOsuHoverContainer : OsuManualInputManagerTestScene
     {
         private OsuHoverTestContainer hoverContainer;
         private Box colourContainer;

osu.Game.Tests/Visual/UserInterface/TestSceneStatefulMenuItem.cs

@@ -12,7 +12,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneStatefulMenuItem : ManualInputManagerTestScene
+    public class TestSceneStatefulMenuItem : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/UserInterface/TestSceneSwitchButton.cs

@@ -9,7 +9,7 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneSwitchButton : ManualInputManagerTestScene
+    public class TestSceneSwitchButton : OsuManualInputManagerTestScene
     {
         private SwitchButton switchButton;
 

osu.Game.Tests/Visual/UserInterface/TestSceneUserListToolbar.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
-using osu.Game.Overlays.Home.Friends;
+using osu.Game.Overlays.Dashboard.Friends;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.UserInterface

osu.Game.Tests/WaveformTestBeatmap.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
@@ -51,8 +50,6 @@ namespace osu.Game.Tests
 
         protected override Texture GetBackground() => null;
 
-        protected override VideoSprite GetVideo() => null;
-
         protected override Waveform GetWaveform() => new Waveform(trackStore.GetStream(firstAudioFile));
 
         protected override Track GetTrack() => trackStore.Get(firstAudioFile);

osu.Game.Tournament.Tests/LadderTestScene.cs

@@ -1,16 +1,147 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
 using osu.Game.Tournament.Models;
+using osu.Game.Users;
 
 namespace osu.Game.Tournament.Tests
 {
     [TestFixture]
     public abstract class LadderTestScene : TournamentTestScene
     {
+        [Cached]
+        protected LadderInfo Ladder { get; private set; } = new LadderInfo();
+
         [Resolved]
-        protected LadderInfo Ladder { get; private set; }
+        private RulesetStore rulesetStore { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            if (Ladder.Ruleset.Value == null)
+                Ladder.Ruleset.Value = rulesetStore.AvailableRulesets.First();
+
+            Ruleset.BindTo(Ladder.Ruleset);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            TournamentMatch match = CreateSampleMatch();
+
+            Ladder.Rounds.Add(match.Round.Value);
+            Ladder.Matches.Add(match);
+            Ladder.Teams.Add(match.Team1.Value);
+            Ladder.Teams.Add(match.Team2.Value);
+
+            Ladder.CurrentMatch.Value = match;
+        }
+
+        public static TournamentMatch CreateSampleMatch() => new TournamentMatch
+        {
+            Team1 =
+            {
+                Value = new TournamentTeam
+                {
+                    FlagName = { Value = "JP" },
+                    FullName = { Value = "Japan" },
+                    LastYearPlacing = { Value = 10 },
+                    Seed = { Value = "Low" },
+                    SeedingResults =
+                    {
+                        new SeedingResult
+                        {
+                            Mod = { Value = "NM" },
+                            Seed = { Value = 10 },
+                            Beatmaps =
+                            {
+                                new SeedingBeatmap
+                                {
+                                    BeatmapInfo = CreateSampleBeatmapInfo(),
+                                    Score = 12345672,
+                                    Seed = { Value = 24 },
+                                },
+                                new SeedingBeatmap
+                                {
+                                    BeatmapInfo = CreateSampleBeatmapInfo(),
+                                    Score = 1234567,
+                                    Seed = { Value = 12 },
+                                },
+                                new SeedingBeatmap
+                                {
+                                    BeatmapInfo = CreateSampleBeatmapInfo(),
+                                    Score = 1234567,
+                                    Seed = { Value = 16 },
+                                }
+                            }
+                        },
+                        new SeedingResult
+                        {
+                            Mod = { Value = "DT" },
+                            Seed = { Value = 5 },
+                            Beatmaps =
+                            {
+                                new SeedingBeatmap
+                                {
+                                    BeatmapInfo = CreateSampleBeatmapInfo(),
+                                    Score = 234567,
+                                    Seed = { Value = 3 },
+                                },
+                                new SeedingBeatmap
+                                {
+                                    BeatmapInfo = CreateSampleBeatmapInfo(),
+                                    Score = 234567,
+                                    Seed = { Value = 6 },
+                                },
+                                new SeedingBeatmap
+                                {
+                                    BeatmapInfo = CreateSampleBeatmapInfo(),
+                                    Score = 234567,
+                                    Seed = { Value = 12 },
+                                }
+                            }
+                        }
+                    },
+                    Players =
+                    {
+                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 12 } } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 16 } } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 20 } } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 24 } } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 30 } } },
+                    }
+                }
+            },
+            Team2 =
+            {
+                Value = new TournamentTeam
+                {
+                    FlagName = { Value = "US" },
+                    FullName = { Value = "United States" },
+                    Players =
+                    {
+                        new User { Username = "Hello" },
+                        new User { Username = "Hello" },
+                        new User { Username = "Hello" },
+                        new User { Username = "Hello" },
+                        new User { Username = "Hello" },
+                    }
+                }
+            },
+            Round =
+            {
+                Value = new TournamentRound { Name = { Value = "Quarterfinals" } }
+            }
+        };
+
+        public static BeatmapInfo CreateSampleBeatmapInfo() =>
+            new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist", ID = RNG.Next(0, 1000000) } };
     }
 }

osu.Game.Tournament.Tests/Screens/TestSceneMapPoolScreen.cs

@@ -1,24 +1,140 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Tournament.Components;
+using osu.Game.Tournament.Models;
 using osu.Game.Tournament.Screens.MapPool;
 
 namespace osu.Game.Tournament.Tests.Screens
 {
     public class TestSceneMapPoolScreen : LadderTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(MapPoolScreen)
-        };
+        private MapPoolScreen screen;
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Add(new MapPoolScreen { Width = 0.7f });
+            Add(screen = new MapPoolScreen { Width = 0.7f });
+        }
+
+        [Test]
+        public void TestFewMaps()
+        {
+            AddStep("load few maps", () =>
+            {
+                Ladder.CurrentMatch.Value.Round.Value.Beatmaps.Clear();
+
+                for (int i = 0; i < 8; i++)
+                    addBeatmap();
+            });
+
+            AddStep("reset match", () =>
+            {
+                Ladder.CurrentMatch.Value = new TournamentMatch();
+                Ladder.CurrentMatch.Value = Ladder.Matches.First();
+            });
+
+            assertTwoWide();
+        }
+
+        [Test]
+        public void TestJustEnoughMaps()
+        {
+            AddStep("load just enough maps", () =>
+            {
+                Ladder.CurrentMatch.Value.Round.Value.Beatmaps.Clear();
+
+                for (int i = 0; i < 18; i++)
+                    addBeatmap();
+            });
+
+            AddStep("reset match", () =>
+            {
+                Ladder.CurrentMatch.Value = new TournamentMatch();
+                Ladder.CurrentMatch.Value = Ladder.Matches.First();
+            });
+
+            assertTwoWide();
+        }
+
+        [Test]
+        public void TestManyMaps()
+        {
+            AddStep("load many maps", () =>
+            {
+                Ladder.CurrentMatch.Value.Round.Value.Beatmaps.Clear();
+
+                for (int i = 0; i < 19; i++)
+                    addBeatmap();
+            });
+
+            AddStep("reset match", () =>
+            {
+                Ladder.CurrentMatch.Value = new TournamentMatch();
+                Ladder.CurrentMatch.Value = Ladder.Matches.First();
+            });
+
+            assertThreeWide();
+        }
+
+        [Test]
+        public void TestJustEnoughMods()
+        {
+            AddStep("load many maps", () =>
+            {
+                Ladder.CurrentMatch.Value.Round.Value.Beatmaps.Clear();
+
+                for (int i = 0; i < 11; i++)
+                    addBeatmap(i > 4 ? $"M{i}" : "NM");
+            });
+
+            AddStep("reset match", () =>
+            {
+                Ladder.CurrentMatch.Value = new TournamentMatch();
+                Ladder.CurrentMatch.Value = Ladder.Matches.First();
+            });
+
+            assertTwoWide();
+        }
+
+        private void assertTwoWide() =>
+            AddAssert("ensure layout width is 2", () => screen.ChildrenOfType<FillFlowContainer<FillFlowContainer<TournamentBeatmapPanel>>>().First().Padding.Left > 0);
+
+        private void assertThreeWide() =>
+            AddAssert("ensure layout width is 3", () => screen.ChildrenOfType<FillFlowContainer<FillFlowContainer<TournamentBeatmapPanel>>>().First().Padding.Left == 0);
+
+        [Test]
+        public void TestManyMods()
+        {
+            AddStep("load many maps", () =>
+            {
+                Ladder.CurrentMatch.Value.Round.Value.Beatmaps.Clear();
+
+                for (int i = 0; i < 12; i++)
+                    addBeatmap(i > 4 ? $"M{i}" : "NM");
+            });
+
+            AddStep("reset match", () =>
+            {
+                Ladder.CurrentMatch.Value = new TournamentMatch();
+                Ladder.CurrentMatch.Value = Ladder.Matches.First();
+            });
+
+            assertThreeWide();
+        }
+
+        private void addBeatmap(string mods = "nm")
+        {
+            Ladder.CurrentMatch.Value.Round.Value.Beatmaps.Add(new RoundBeatmap
+            {
+                BeatmapInfo = CreateSampleBeatmapInfo(),
+                Mods = mods
+            });
         }
     }
 }

osu.Game.Tournament.Tests/Screens/TestSceneSeedingEditorScreen.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Tournament.Tests.Screens
 
         public TestSceneSeedingEditorScreen()
         {
-            var match = TestSceneSeedingScreen.CreateSampleSeededMatch();
+            var match = CreateSampleMatch();
 
             Add(new SeedingEditorScreen(match.Team1.Value)
             {

osu.Game.Tournament.Tests/Screens/TestSceneSeedingScreen.cs

@@ -3,10 +3,8 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Beatmaps;
 using osu.Game.Tournament.Models;
 using osu.Game.Tournament.Screens.TeamIntro;
-using osu.Game.Users;
 
 namespace osu.Game.Tournament.Tests.Screens
 {
@@ -18,110 +16,11 @@ namespace osu.Game.Tournament.Tests.Screens
         [BackgroundDependencyLoader]
         private void load()
         {
-            ladder.CurrentMatch.Value = CreateSampleSeededMatch();
-
             Add(new SeedingScreen
             {
                 FillMode = FillMode.Fit,
                 FillAspectRatio = 16 / 9f
             });
         }
-
-        public static TournamentMatch CreateSampleSeededMatch() => new TournamentMatch
-        {
-            Team1 =
-            {
-                Value = new TournamentTeam
-                {
-                    FlagName = { Value = "JP" },
-                    FullName = { Value = "Japan" },
-                    LastYearPlacing = { Value = 10 },
-                    Seed = { Value = "Low" },
-                    SeedingResults =
-                    {
-                        new SeedingResult
-                        {
-                            Mod = { Value = "NM" },
-                            Seed = { Value = 10 },
-                            Beatmaps =
-                            {
-                                new SeedingBeatmap
-                                {
-                                    BeatmapInfo = new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist" } },
-                                    Score = 12345672,
-                                    Seed = { Value = 24 },
-                                },
-                                new SeedingBeatmap
-                                {
-                                    BeatmapInfo = new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist" } },
-                                    Score = 1234567,
-                                    Seed = { Value = 12 },
-                                },
-                                new SeedingBeatmap
-                                {
-                                    BeatmapInfo = new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist" } },
-                                    Score = 1234567,
-                                    Seed = { Value = 16 },
-                                }
-                            }
-                        },
-                        new SeedingResult
-                        {
-                            Mod = { Value = "DT" },
-                            Seed = { Value = 5 },
-                            Beatmaps =
-                            {
-                                new SeedingBeatmap
-                                {
-                                    BeatmapInfo = new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist" } },
-                                    Score = 234567,
-                                    Seed = { Value = 3 },
-                                },
-                                new SeedingBeatmap
-                                {
-                                    BeatmapInfo = new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist" } },
-                                    Score = 234567,
-                                    Seed = { Value = 6 },
-                                },
-                                new SeedingBeatmap
-                                {
-                                    BeatmapInfo = new BeatmapInfo { Metadata = new BeatmapMetadata { Title = "Test Title", Artist = "Test Artist" } },
-                                    Score = 234567,
-                                    Seed = { Value = 12 },
-                                }
-                            }
-                        }
-                    },
-                    Players =
-                    {
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 12 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 16 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 20 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 24 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 30 } } },
-                    }
-                }
-            },
-            Team2 =
-            {
-                Value = new TournamentTeam
-                {
-                    FlagName = { Value = "US" },
-                    FullName = { Value = "United States" },
-                    Players =
-                    {
-                        new User { Username = "Hello" },
-                        new User { Username = "Hello" },
-                        new User { Username = "Hello" },
-                        new User { Username = "Hello" },
-                        new User { Username = "Hello" },
-                    }
-                }
-            },
-            Round =
-            {
-                Value = new TournamentRound { Name = { Value = "Quarterfinals" } }
-            }
-        };
     }
 }

osu.Game.Tournament/Components/TournamentMatchChatDisplay.cs

@@ -70,6 +70,17 @@ namespace osu.Game.Tournament.Components
 
         protected override ChatLine CreateMessage(Message message) => new MatchMessage(message);
 
+        protected override StandAloneDrawableChannel CreateDrawableChannel(Channel channel) => new MatchChannel(channel);
+
+        public class MatchChannel : StandAloneDrawableChannel
+        {
+            public MatchChannel(Channel channel)
+                : base(channel)
+            {
+                ScrollbarVisible = false;
+            }
+        }
+
         protected class MatchMessage : StandAloneMessage
         {
             public MatchMessage(Message message)

osu.Game.Tournament/Models/LadderInfo.cs

@@ -24,7 +24,13 @@ namespace osu.Game.Tournament.Models
         // only used for serialisation
         public List<TournamentProgression> Progressions = new List<TournamentProgression>();
 
-        [JsonIgnore]
+        [JsonIgnore] // updated manually in TournamentGameBase
         public Bindable<TournamentMatch> CurrentMatch = new Bindable<TournamentMatch>();
+
+        public Bindable<int> ChromaKeyWidth = new BindableInt(1024)
+        {
+            MinValue = 640,
+            MaxValue = 1366,
+        };
     }
 }

osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Platform;
 using osu.Framework.Threading;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays.Settings;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.IPC;
 using osu.Game.Tournament.Models;
@@ -35,6 +36,8 @@ namespace osu.Game.Tournament.Screens.Gameplay
         [Resolved]
         private TournamentMatchChatDisplay chat { get; set; }
 
+        private Box chroma;
+
         [BackgroundDependencyLoader]
         private void load(LadderInfo ladder, MatchIPCInfo ipc, Storage storage)
         {
@@ -60,11 +63,10 @@ namespace osu.Game.Tournament.Screens.Gameplay
                     Origin = Anchor.TopCentre,
                     Children = new Drawable[]
                     {
-                        new Box
+                        chroma = new Box
                         {
                             // chroma key area for stable gameplay
                             Name = "chroma",
-                            RelativeSizeAxes = Axes.X,
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
                             Height = 512,
@@ -93,6 +95,12 @@ namespace osu.Game.Tournament.Screens.Gameplay
                             RelativeSizeAxes = Axes.X,
                             Text = "Toggle chat",
                             Action = () => { State.Value = State.Value == TourneyState.Idle ? TourneyState.Playing : TourneyState.Idle; }
+                        },
+                        new SettingsSlider<int>
+                        {
+                            LabelText = "Chroma Width",
+                            Bindable = LadderInfo.ChromaKeyWidth,
+                            KeyboardStep = 1,
                         }
                     }
                 }
@@ -101,6 +109,8 @@ namespace osu.Game.Tournament.Screens.Gameplay
             State.BindTo(ipc.State);
             State.BindValueChanged(stateChanged, true);
 
+            ladder.ChromaKeyWidth.BindValueChanged(width => chroma.Width = width.NewValue, true);
+
             currentMatch.BindValueChanged(m =>
             {
                 warmup.Value = m.NewValue.Team1Score.Value + m.NewValue.Team2Score.Value == 0;

osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs

@@ -50,11 +50,11 @@ namespace osu.Game.Tournament.Screens.MapPool
                 new MatchHeader(),
                 mapFlows = new FillFlowContainer<FillFlowContainer<TournamentBeatmapPanel>>
                 {
-                    Y = 140,
+                    Y = 160,
                     Spacing = new Vector2(10, 10),
-                    Padding = new MarginPadding(25),
                     Direction = FillDirection.Vertical,
-                    RelativeSizeAxes = Axes.Both,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
                 },
                 new ControlPanel
                 {
@@ -95,6 +95,7 @@ namespace osu.Game.Tournament.Screens.MapPool
                             Text = "Reset",
                             Action = reset
                         },
+                        new ControlPanel.Spacer(),
                     }
                 }
             };
@@ -211,11 +212,15 @@ namespace osu.Game.Tournament.Screens.MapPool
         {
             mapFlows.Clear();
 
+            int totalRows = 0;
+
             if (match.NewValue.Round.Value != null)
             {
                 FillFlowContainer<TournamentBeatmapPanel> currentFlow = null;
                 string currentMod = null;
 
+                int flowCount = 0;
+
                 foreach (var b in match.NewValue.Round.Value.Beatmaps)
                 {
                     if (currentFlow == null || currentMod != b.Mods)
@@ -229,6 +234,15 @@ namespace osu.Game.Tournament.Screens.MapPool
                         });
 
                         currentMod = b.Mods;
+
+                        totalRows++;
+                        flowCount = 0;
+                    }
+
+                    if (++flowCount > 2)
+                    {
+                        totalRows++;
+                        flowCount = 1;
                     }
 
                     currentFlow.Add(new TournamentBeatmapPanel(b.BeatmapInfo, b.Mods)
@@ -239,6 +253,12 @@ namespace osu.Game.Tournament.Screens.MapPool
                     });
                 }
             }
+
+            mapFlows.Padding = new MarginPadding(5)
+            {
+                // remove horizontal padding to increase flow width to 3 panels
+                Horizontal = totalRows > 9 ? 0 : 100
+            };
         }
     }
 }

osu.Game.Tournament/Screens/SetupScreen.cs

@@ -116,7 +116,7 @@ namespace osu.Game.Tournament.Screens
                     {
                         windowSize.Value = new Size((int)(1920 / TournamentSceneManager.STREAM_AREA_WIDTH * TournamentSceneManager.REQUIRED_WIDTH), 1080);
                     }
-                }
+                },
             };
         }
 

osu.Game/Beatmaps/BeatmapManager.cs

@@ -14,7 +14,6 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Framework.Lists;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
@@ -403,7 +402,6 @@ namespace osu.Game.Beatmaps
 
             protected override IBeatmap GetBeatmap() => beatmap;
             protected override Texture GetBackground() => null;
-            protected override VideoSprite GetVideo() => null;
             protected override Track GetTrack() => null;
         }
 

osu.Game/Beatmaps/BeatmapManager_WorkingBeatmap.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Framework.IO.Stores;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps.Formats;
@@ -67,24 +66,6 @@ namespace osu.Game.Beatmaps
                 }
             }
 
-            protected override VideoSprite GetVideo()
-            {
-                if (Metadata?.VideoFile == null)
-                    return null;
-
-                try
-                {
-                    var stream = textureStore.GetStream(getPathForFile(Metadata.VideoFile));
-
-                    return stream == null ? null : new VideoSprite(stream);
-                }
-                catch (Exception e)
-                {
-                    Logger.Error(e, "Video failed to load");
-                    return null;
-                }
-            }
-
             protected override Track GetTrack()
             {
                 try

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -52,7 +52,6 @@ namespace osu.Game.Beatmaps
         public int PreviewTime { get; set; }
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
-        public string VideoFile { get; set; }
 
         public override string ToString() => $"{Artist} - {Title} ({Author})";
 
@@ -82,8 +81,7 @@ namespace osu.Game.Beatmaps
                    && Tags == other.Tags
                    && PreviewTime == other.PreviewTime
                    && AudioFile == other.AudioFile
-                   && BackgroundFile == other.BackgroundFile
-                   && VideoFile == other.VideoFile;
+                   && BackgroundFile == other.BackgroundFile;
         }
     }
 }

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -7,7 +7,6 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
@@ -45,8 +44,6 @@ namespace osu.Game.Beatmaps
 
         protected override Texture GetBackground() => textures?.Get(@"Backgrounds/bg4");
 
-        protected override VideoSprite GetVideo() => null;
-
         protected override Track GetTrack() => GetVirtualTrack();
 
         private class DummyRulesetInfo : RulesetInfo

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -6,11 +6,11 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps.Timing;
-using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.IO;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.IO;
+using osu.Game.Rulesets.Objects.Legacy;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -303,10 +303,6 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.Metadata.BackgroundFile = CleanFilename(split[2]);
                     break;
 
-                case LegacyEventType.Video:
-                    beatmap.BeatmapInfo.Metadata.VideoFile = CleanFilename(split[2]);
-                    break;
-
                 case LegacyEventType.Break:
                     double start = getOffsetTime(Parsing.ParseDouble(split[1]));
 

osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs

@@ -133,9 +133,6 @@ namespace osu.Game.Beatmaps.Formats
             if (!string.IsNullOrEmpty(beatmap.BeatmapInfo.Metadata.BackgroundFile))
                 writer.WriteLine(FormattableString.Invariant($"{(int)LegacyEventType.Background},0,\"{beatmap.BeatmapInfo.Metadata.BackgroundFile}\",0,0"));
 
-            if (!string.IsNullOrEmpty(beatmap.BeatmapInfo.Metadata.VideoFile))
-                writer.WriteLine(FormattableString.Invariant($"{(int)LegacyEventType.Video},0,\"{beatmap.BeatmapInfo.Metadata.VideoFile}\",0,0"));
-
             foreach (var b in beatmap.Breaks)
                 writer.WriteLine(FormattableString.Invariant($"{(int)LegacyEventType.Break},{b.StartTime},{b.EndTime}"));
         }

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -4,13 +4,13 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using osuTK;
-using osuTK.Graphics;
 using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.IO;
 using osu.Game.Storyboards;
-using osu.Game.Beatmaps.Legacy;
-using osu.Framework.Utils;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -87,6 +87,15 @@ namespace osu.Game.Beatmaps.Formats
 
                 switch (type)
                 {
+                    case LegacyEventType.Video:
+                    {
+                        var offset = Parsing.ParseInt(split[1]);
+                        var path = CleanFilename(split[2]);
+
+                        storyboard.GetLayer("Video").Add(new StoryboardVideo(path, offset));
+                        break;
+                    }
+
                     case LegacyEventType.Sprite:
                     {
                         var layer = parseLayer(split[1]);

osu.Game/Beatmaps/IWorkingBeatmap.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -27,11 +26,6 @@ namespace osu.Game.Beatmaps
         /// </summary>
         Texture Background { get; }
 
-        /// <summary>
-        /// Retrieves the video background file for this <see cref="WorkingBeatmap"/>.
-        /// </summary>
-        VideoSprite Video { get; }
-
         /// <summary>
         /// Retrieves the audio track for this <see cref="WorkingBeatmap"/>.
         /// </summary>

osu.Game/Beatmaps/Legacy/LegacyStoryLayer.cs

@@ -8,6 +8,7 @@ namespace osu.Game.Beatmaps.Legacy
         Background = 0,
         Fail = 1,
         Pass = 2,
-        Foreground = 3
+        Foreground = 3,
+        Video = 4
     }
 }

osu.Game/Beatmaps/WorkingBeatmap.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.Audio.Track;
-using osu.Framework.Graphics.Textures;
-using osu.Game.Rulesets.Mods;
 using System;
 using System.Collections.Generic;
-using osu.Game.Storyboards;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Logging;
 using osu.Framework.Statistics;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI;
 using osu.Game.Skinning;
-using osu.Framework.Graphics.Video;
-using osu.Framework.Logging;
+using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps
 {
@@ -234,10 +233,6 @@ namespace osu.Game.Beatmaps
         protected abstract Texture GetBackground();
         private readonly RecyclableLazy<Texture> background;
 
-        public VideoSprite Video => GetVideo();
-
-        protected abstract VideoSprite GetVideo();
-
         public bool TrackLoaded => track.IsResultAvailable;
         public Track Track => track.Value;
         protected abstract Track GetTrack();

osu.Game/Configuration/OsuConfigManager.cs

@@ -70,7 +70,6 @@ namespace osu.Game.Configuration
             Set(OsuSetting.ShowFpsDisplay, false);
 
             Set(OsuSetting.ShowStoryboard, true);
-            Set(OsuSetting.ShowVideoBackground, true);
             Set(OsuSetting.BeatmapSkins, true);
             Set(OsuSetting.BeatmapHitsounds, true);
 
@@ -176,7 +175,6 @@ namespace osu.Game.Configuration
         BlurLevel,
         LightenDuringBreaks,
         ShowStoryboard,
-        ShowVideoBackground,
         KeyOverlay,
         ScoreMeter,
         FloatingComments,

osu.Game/Graphics/Containers/UserDimContainer.cs

@@ -40,7 +40,7 @@ namespace osu.Game.Graphics.Containers
 
         /// <summary>
         /// Whether player is in break time.
-        /// Must be bound to <see cref="BreakOverlay.IsBreakTime"/> to allow for dim adjustments in gameplay.
+        /// Must be bound to <see cref="BreakTracker.IsBreakTime"/> to allow for dim adjustments in gameplay.
         /// </summary>
         public readonly IBindable<bool> IsBreakTime = new Bindable<bool>();
 
@@ -55,8 +55,6 @@ namespace osu.Game.Graphics.Containers
 
         protected Bindable<bool> ShowStoryboard { get; private set; }
 
-        protected Bindable<bool> ShowVideo { get; private set; }
-
         private float breakLightening => LightenDuringBreaks.Value && IsBreakTime.Value ? BREAK_LIGHTEN_AMOUNT : 0;
 
         protected float DimLevel => Math.Max(EnableUserDim.Value && !IgnoreUserSettings.Value ? (float)UserDimLevel.Value - breakLightening : 0, 0);
@@ -79,14 +77,12 @@ namespace osu.Game.Graphics.Containers
             UserDimLevel = config.GetBindable<double>(OsuSetting.DimLevel);
             LightenDuringBreaks = config.GetBindable<bool>(OsuSetting.LightenDuringBreaks);
             ShowStoryboard = config.GetBindable<bool>(OsuSetting.ShowStoryboard);
-            ShowVideo = config.GetBindable<bool>(OsuSetting.ShowVideoBackground);
 
             EnableUserDim.ValueChanged += _ => UpdateVisuals();
             UserDimLevel.ValueChanged += _ => UpdateVisuals();
             LightenDuringBreaks.ValueChanged += _ => UpdateVisuals();
             IsBreakTime.ValueChanged += _ => UpdateVisuals();
             ShowStoryboard.ValueChanged += _ => UpdateVisuals();
-            ShowVideo.ValueChanged += _ => UpdateVisuals();
             StoryboardReplacesBackground.ValueChanged += _ => UpdateVisuals();
             IgnoreUserSettings.ValueChanged += _ => UpdateVisuals();
         }

osu.Game/Graphics/Sprites/OsuSpriteText.cs

@@ -1,9 +1,7 @@
 // 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.Sprites;
-using osu.Framework.Graphics.Transforms;
 
 namespace osu.Game.Graphics.Sprites
 {
@@ -15,23 +13,4 @@ namespace osu.Game.Graphics.Sprites
             Font = OsuFont.Default;
         }
     }
-
-    public static class OsuSpriteTextTransformExtensions
-    {
-        /// <summary>
-        /// Sets <see cref="SpriteText.Text">Text</see> to a new value after a duration.
-        /// </summary>
-        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
-        public static TransformSequence<T> TransformTextTo<T>(this T spriteText, string newText, double duration = 0, Easing easing = Easing.None)
-            where T : OsuSpriteText
-            => spriteText.TransformTo(nameof(OsuSpriteText.Text), newText, duration, easing);
-
-        /// <summary>
-        /// Sets <see cref="SpriteText.Text">Text</see> to a new value after a duration.
-        /// </summary>
-        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
-        public static TransformSequence<T> TransformTextTo<T>(this TransformSequence<T> t, string newText, double duration = 0, Easing easing = Easing.None)
-            where T : OsuSpriteText
-            => t.Append(o => o.TransformTextTo(newText, duration, easing));
-    }
 }

osu.Game/IO/Archives/ArchiveReader.cs

@@ -45,7 +45,5 @@ namespace osu.Game.IO.Archives
                 return buffer;
             }
         }
-
-        public abstract Stream GetUnderlyingStream();
     }
 }

osu.Game/IO/Archives/LegacyByteArrayReader.cs

@@ -0,0 +1,30 @@
+// 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.Collections.Generic;
+using System.IO;
+
+namespace osu.Game.IO.Archives
+{
+    /// <summary>
+    /// Allows reading a single file from the provided stream.
+    /// </summary>
+    public class LegacyByteArrayReader : ArchiveReader
+    {
+        private readonly byte[] content;
+
+        public LegacyByteArrayReader(byte[] content, string filename)
+            : base(filename)
+        {
+            this.content = content;
+        }
+
+        public override Stream GetStream(string name) => new MemoryStream(content);
+
+        public override void Dispose()
+        {
+        }
+
+        public override IEnumerable<string> Filenames => new[] { Name };
+    }
+}

osu.Game/IO/Archives/LegacyDirectoryArchiveReader.cs

@@ -28,7 +28,5 @@ namespace osu.Game.IO.Archives
         }
 
         public override IEnumerable<string> Filenames => Directory.GetFiles(path, "*", SearchOption.AllDirectories).Select(f => f.Replace(path, string.Empty).Trim(Path.DirectorySeparatorChar)).ToArray();
-
-        public override Stream GetUnderlyingStream() => null;
     }
 }