Merge branch 'master' into autoreplay-refactor-squashed

.vscode/tasks.json

@@ -10,10 +10,16 @@
             "showOutput": "silent",
             "command": "msbuild",
             "args": [
-                // Ask msbuild to generate full paths for file names.
                 "/property:GenerateFullPaths=true",
                 "/property:DebugType=portable"
             ],
+            "windows": {
+                "args": [
+                    "/property:GenerateFullPaths=true",
+                    "/property:DebugType=portable",
+                    "/m" //parallel compiling support. doesn't work well with mono atm
+                ]
+            },
             // Use the standard MS compiler pattern to detect errors, warnings and infos
             "problemMatcher": "$msCompile",
             "isBuildCommand": true
@@ -29,6 +35,14 @@
                 "/property:DebugType=portable",
                 "/target:Clean,Build"
             ],
+            "windows": {
+                "args": [
+                    "/property:GenerateFullPaths=true",
+                    "/property:DebugType=portable",
+                    "/target:Clean,Build",
+                    "/m" //parallel compiling support. doesn't work well with mono atm
+                ]
+            },
             // Use the standard MS compiler pattern to detect errors, warnings and infos
             "problemMatcher": "$msCompile",
             "isBuildCommand": true

README.md

@@ -1,6 +1,4 @@
-# osu! [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)
-
-
+# osu! [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)  [![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu)
 
 [osu! on the web](https://osu.ppy.sh) | [dev chat](https://discord.gg/ppy)
 
@@ -12,14 +10,14 @@ This is still heavily under development and is not intended for end-user use. Th
 
 # Requirements
 
-- A desktop platform which can compile .NET 4.5.
-- Visual Studio or MonoDevelop is recommended.
+- A desktop platform which can compile .NET 4.5 (tested on macOS, linux and windows). We recommend using [Visual Studio Code](https://code.visualstudio.com/) (all platforms) or [Visual Studio Community Edition](https://www.visualstudio.com/) (windows only), both of which are free.
+- Make sure you initialise and keep submodules up-to-date.
 
 # Contributing
 
 We welcome all contributions, but keep in mind that we already have a lot of the UI designed. If you wish to work on something with the intention on having it included in the official distribution, please open an issue for discussion and we will give you what you need from a design perspective to proceed. If you want to make *changes* to the design, we recommend you open an issue with your intentions before spending too much time, to ensure no effort is wasted.
 
-Contributions can be made via pull requests to this repository. We hope to credit and reward larger contributions via a [bounty system](https://goo.gl/nFdoyI). If you're unsure of what you can help with, check out the [list](https://github.com/ppy/osu/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3Abounty) of available issues with bounty.
+Contributions can be made via pull requests to this repository. We hope to credit and reward larger contributions via a [bounty system](https://www.bountysource.com/teams/ppy). If you're unsure of what you can help with, check out the [list of open issues](https://github.com/ppy/osu-framework/issues).
 
 Note that while we already have certain standards in place, nothing is set in stone. If you have an issue with the way code is structured; with any libraries we are using; with any processes involved with contributing, *please* bring it up. I welcome all feedback so we can make contributing to this project as pain-free as possible.
 

osu-framework

@@ -1 +1 @@
-Subproject commit 9204b838504a51ffe7577c103b91270a2687bfb8
+Subproject commit dcbd7a0b6f536f6aadf13a720db40a1d76bf52e2

osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs

@@ -10,7 +10,6 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
@@ -62,15 +61,12 @@ namespace osu.Desktop.VisualTests.Tests
                     add(new DrawableSlider(new Slider
                     {
                         StartTime = framedClock.CurrentTime + 600,
-                        CurveObject = new CurvedHitObject
+                        ControlPoints = new List<Vector2>
                         {
-                            ControlPoints = new List<Vector2>
-                            {
-                                new Vector2(-200, 0),
-                                new Vector2(400, 0),
-                            },
-                            Distance = 400
+                            new Vector2(-200, 0),
+                            new Vector2(400, 0),
                         },
+                        Distance = 400,
                         Position = new Vector2(-200, 0),
                         Velocity = 1,
                         TickDistance = 100,

osu.Desktop.VisualTests/Tests/TestCaseSongProgress.cs

@@ -38,9 +38,9 @@ namespace osu.Desktop.VisualTests.Tests
                 Origin = Anchor.TopLeft,
             });
 
-            AddStep("Toggle Bar", progress.ToggleBar);
+            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
             AddWaitStep(5);
-            AddStep("Toggle Bar", progress.ToggleBar);
+            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
             AddWaitStep(2);
             AddRepeatStep("New Values", displayNewValues, 5);
 

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -19,10 +19,10 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
         protected override IEnumerable<OsuHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
         {
-            IHasCurve curveData = original as IHasCurve;
-            IHasEndTime endTimeData = original as IHasEndTime;
-            IHasPosition positionData = original as IHasPosition;
-            IHasCombo comboData = original as IHasCombo;
+            var curveData = original as IHasCurve;
+            var endTimeData = original as IHasEndTime;
+            var positionData = original as IHasPosition;
+            var comboData = original as IHasCombo;
 
             if (curveData != null)
             {
@@ -30,7 +30,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     StartTime = original.StartTime,
                     Samples = original.Samples,
-                    CurveObject = curveData,
+                    ControlPoints = curveData.ControlPoints,
+                    CurveType = curveData.CurveType,
+                    Distance = curveData.Distance,
+                    RepeatSamples = curveData.RepeatSamples,
+                    RepeatCount = curveData.RepeatCount,
                     Position = positionData?.Position ?? Vector2.Zero,
                     NewCombo = comboData?.NewCombo ?? false
                 };

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

@@ -20,24 +20,33 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         private const float base_scoring_distance = 100;
 
-        public IHasCurve CurveObject { get; set; }
-
-        public SliderCurve Curve => CurveObject.Curve;
+        public readonly SliderCurve Curve = new SliderCurve();
 
         public double EndTime => StartTime + RepeatCount * Curve.Distance / Velocity;
         public double Duration => EndTime - StartTime;
 
         public override Vector2 EndPosition => PositionAt(1);
 
-        public Vector2 PositionAt(double progress) => CurveObject.PositionAt(progress);
-        public double ProgressAt(double progress) => CurveObject.ProgressAt(progress);
-        public int RepeatAt(double progress) => CurveObject.RepeatAt(progress);
+        public List<Vector2> ControlPoints
+        {
+            get { return Curve.ControlPoints; }
+            set { Curve.ControlPoints = value; }
+        }
 
-        public List<Vector2> ControlPoints => CurveObject.ControlPoints;
-        public CurveType CurveType => CurveObject.CurveType;
-        public double Distance => CurveObject.Distance;
+        public CurveType CurveType
+        {
+            get { return Curve.CurveType; }
+            set { Curve.CurveType = value; }
+        }
 
-        public int RepeatCount => CurveObject.RepeatCount;
+        public double Distance
+        {
+            get { return Curve.Distance; }
+            set { Curve.Distance = value; }
+        }
+
+        public List<SampleInfoList> RepeatSamples { get; set; } = new List<SampleInfoList>();
+        public int RepeatCount { get; set; } = 1;
 
         private int stackHeight;
         public override int StackHeight
@@ -63,6 +72,18 @@ namespace osu.Game.Rulesets.Osu.Objects
             TickDistance = scoringDistance / difficulty.SliderTickRate;
         }
 
+        public Vector2 PositionAt(double progress) => Curve.PositionAt(ProgressAt(progress));
+
+        public double ProgressAt(double progress)
+        {
+            double p = progress * RepeatCount % 1;
+            if (RepeatAt(progress) % 2 == 1)
+                p = 1 - p;
+            return p;
+        }
+
+        public int RepeatAt(double progress) => (int)(progress * RepeatCount);
+
         public IEnumerable<SliderTick> Ticks
         {
             get
@@ -96,12 +117,12 @@ namespace osu.Game.Rulesets.Osu.Objects
                             StackHeight = StackHeight,
                             Scale = Scale,
                             ComboColour = ComboColour,
-                            Samples = Samples.Select(s => new SampleInfo
+                            Samples = new SampleInfoList(Samples.Select(s => new SampleInfo
                             {
                                 Bank = s.Bank,
                                 Name = @"slidertick",
                                 Volume = s.Volume
-                            }).ToList()
+                            }))
                         };
                     }
                 }

osu.Game.Rulesets.Osu/OsuDifficultyCalculator.cs

@@ -3,7 +3,6 @@
 
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Beatmaps;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using System;
@@ -28,7 +27,7 @@ namespace osu.Game.Rulesets.Osu
         protected override void PreprocessHitObjects()
         {
             foreach (var h in Objects)
-                (h as IHasCurve)?.Curve?.Calculate();
+                (h as Slider)?.Curve?.Calculate();
         }
 
         protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
@@ -190,4 +189,4 @@ namespace osu.Game.Rulesets.Osu
             Aim,
         };
     }
-}
+}

osu.Game.Rulesets.Osu/OsuKeyConversionInputManager.cs

@@ -2,10 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Input;
-using osu.Game.Configuration;
 using osu.Game.Screens.Play;
 using OpenTK.Input;
 using KeyboardState = osu.Framework.Input.KeyboardState;
@@ -17,13 +14,6 @@ namespace osu.Game.Rulesets.Osu
     {
         private bool leftViaKeyboard;
         private bool rightViaKeyboard;
-        private Bindable<bool> mouseDisabled;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            mouseDisabled = config.GetBindable<bool>(OsuConfig.MouseDisableButtons);
-        }
 
         protected override void TransformState(InputState state)
         {
@@ -40,12 +30,6 @@ namespace osu.Game.Rulesets.Osu
 
             if (mouse != null)
             {
-                if (mouseDisabled.Value)
-                {
-                    mouse.SetPressed(MouseButton.Left, false);
-                    mouse.SetPressed(MouseButton.Right, false);
-                }
-
                 if (leftViaKeyboard)
                     mouse.SetPressed(MouseButton.Left, true);
                 if (rightViaKeyboard)

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

@@ -66,9 +66,10 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             var distanceData = obj as IHasDistance;
             var repeatsData = obj as IHasRepeats;
             var endTimeData = obj as IHasEndTime;
+            var curveData = obj as IHasCurve;
 
             // Old osu! used hit sounding to determine various hit type information
-            List<SampleInfo> samples = obj.Samples;
+            SampleInfoList samples = obj.Samples;
 
             bool strong = samples.Any(s => s.Name == SampleInfo.HIT_FINISH);
 
@@ -102,16 +103,35 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
                 if (tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength)
                 {
+                    List<SampleInfoList> allSamples = curveData != null ? curveData.RepeatSamples : new List<SampleInfoList>(new[] { samples });
+
+                    int i = 0;
                     for (double j = obj.StartTime; j <= obj.StartTime + taikoDuration + tickSpacing / 8; j += tickSpacing)
                     {
-                        // Todo: This should generate different type of hits (including strongs)
-                        // depending on hitobject sound additions (not implemented fully yet)
-                        yield return new CentreHit
+                        SampleInfoList currentSamples = allSamples[i];
+                        bool isRim = currentSamples.Any(s => s.Name == SampleInfo.HIT_CLAP || s.Name == SampleInfo.HIT_WHISTLE);
+                        strong = currentSamples.Any(s => s.Name == SampleInfo.HIT_FINISH);
+
+                        if (isRim)
                         {
-                            StartTime = j,
-                            Samples = obj.Samples,
-                            IsStrong = strong,
-                        };
+                            yield return new RimHit
+                            {
+                                StartTime = j,
+                                Samples = currentSamples,
+                                IsStrong = strong
+                            };
+                        }
+                        else
+                        {
+                            yield return new CentreHit
+                            {
+                                StartTime = j,
+                                Samples = currentSamples,
+                                IsStrong = strong,
+                            };
+                        }
+
+                        i = (i + 1) % allSamples.Count;
                     }
                 }
                 else

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

@@ -82,12 +82,12 @@ namespace osu.Game.Rulesets.Taiko.Objects
                     TickSpacing = tickSpacing,
                     StartTime = t,
                     IsStrong = IsStrong,
-                    Samples = Samples.Select(s => new SampleInfo
+                    Samples = new SampleInfoList(Samples.Select(s => new SampleInfo
                     {
                         Bank = s.Bank,
                         Name = @"slidertick",
                         Volume = s.Volume
-                    }).ToList()
+                    }))
                 });
 
                 first = false;

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

@@ -0,0 +1,127 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    internal class TaikoHitObjectDifficulty
+    {
+        /// <summary>
+        /// Factor by how much individual / overall strain decays per second.
+        /// </summary>
+        /// <remarks>
+        /// These values are results of tweaking a lot and taking into account general feedback.
+        /// </remarks>
+        internal const double DECAY_BASE = 0.30;
+
+        private const double type_change_bonus = 0.75;
+        private const double rhythm_change_bonus = 1.0;
+        private const double rhythm_change_base_threshold = 0.2;
+        private const double rhythm_change_base = 2.0;
+
+        internal TaikoHitObject BaseHitObject;
+
+        /// <summary>
+        /// Measures note density in a way
+        /// </summary>
+        internal double Strain = 1;
+
+        private double timeElapsed;
+        private int sameTypeSince = 1;
+
+        private bool isRim => BaseHitObject is RimHit;
+
+        public TaikoHitObjectDifficulty(TaikoHitObject baseHitObject)
+        {
+            BaseHitObject = baseHitObject;
+        }
+
+        internal void CalculateStrains(TaikoHitObjectDifficulty previousHitObject, double timeRate)
+        {
+            // Rather simple, but more specialized things are inherently inaccurate due to the big difference playstyles and opinions make.
+            // See Taiko feedback thread.
+            timeElapsed = (BaseHitObject.StartTime - previousHitObject.BaseHitObject.StartTime) / timeRate;
+            double decay = Math.Pow(DECAY_BASE, timeElapsed / 1000);
+
+            double addition = 1;
+
+            // Only if we are no slider or spinner we get an extra addition
+            if (previousHitObject.BaseHitObject is Hit && BaseHitObject is Hit
+                && BaseHitObject.StartTime - previousHitObject.BaseHitObject.StartTime < 1000) // And we only want to check out hitobjects which aren't so far in the past
+            {
+                addition += typeChangeAddition(previousHitObject);
+                addition += rhythmChangeAddition(previousHitObject);
+            }
+
+            double additionFactor = 1.0;
+            // Scale AdditionFactor linearly from 0.4 to 1 for TimeElapsed from 0 to 50
+            if (timeElapsed < 50.0)
+                additionFactor = 0.4 + 0.6 * timeElapsed / 50.0;
+
+            Strain = previousHitObject.Strain * decay + addition * additionFactor;
+        }
+
+        private TypeSwitch lastTypeSwitchEven = TypeSwitch.None;
+        private double typeChangeAddition(TaikoHitObjectDifficulty previousHitObject)
+        {
+            // If we don't have the same hit type, trigger a type change!
+            if (previousHitObject.isRim != isRim)
+            {
+                lastTypeSwitchEven = previousHitObject.sameTypeSince % 2 == 0 ? TypeSwitch.Even : TypeSwitch.Odd;
+
+                // We only want a bonus if the parity of the type switch changes!
+                switch (previousHitObject.lastTypeSwitchEven)
+                {
+                    case TypeSwitch.Even:
+                        if (lastTypeSwitchEven == TypeSwitch.Odd)
+                            return type_change_bonus;
+                        break;
+                    case TypeSwitch.Odd:
+                        if (lastTypeSwitchEven == TypeSwitch.Even)
+                            return type_change_bonus;
+                        break;
+                }
+            }
+            // No type change? Increment counter and keep track of last type switch
+            else
+            {
+                lastTypeSwitchEven = previousHitObject.lastTypeSwitchEven;
+                sameTypeSince = previousHitObject.sameTypeSince + 1;
+            }
+
+            return 0;
+        }
+
+        private double rhythmChangeAddition(TaikoHitObjectDifficulty previousHitObject)
+        {
+            // We don't want a division by zero if some random mapper decides to put 2 HitObjects at the same time.
+            if (timeElapsed == 0 || previousHitObject.timeElapsed == 0)
+                return 0;
+
+            double timeElapsedRatio = Math.Max(previousHitObject.timeElapsed / timeElapsed, timeElapsed / previousHitObject.timeElapsed);
+
+            if (timeElapsedRatio >= 8)
+                return 0;
+
+            double difference = Math.Log(timeElapsedRatio, rhythm_change_base) % 1.0;
+
+            if (isWithinChangeThreshold(difference))
+                return rhythm_change_bonus;
+
+            return 0;
+        }
+
+        private bool isWithinChangeThreshold(double value)
+        {
+            return value > rhythm_change_base_threshold && value < 1 - rhythm_change_base_threshold;
+        }
+
+        private enum TypeSwitch
+        {
+            None,
+            Even,
+            Odd
+        }
+    }
+}

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

@@ -11,6 +11,8 @@ namespace osu.Game.Rulesets.Taiko.Replays
 {
     public class TaikoAutoReplay : Replay
     {
+        private const double swell_hit_speed = 50;
+
         private readonly Beatmap<TaikoHitObject> beatmap;
 
         public TaikoAutoReplay(Beatmap<TaikoHitObject> beatmap)
@@ -45,12 +47,13 @@ namespace osu.Game.Rulesets.Taiko.Replays
                     int d = 0;
                     int count = 0;
                     int req = swell.RequiredHits;
-                    double hitRate = swell.Duration / req;
+                    double hitRate = Math.Min(swell_hit_speed, swell.Duration / req);
                     for (double j = h.StartTime; j < endTime; j += hitRate)
                     {
                         switch (d)
                         {
                             default:
+                            case 0:
                                 button = ReplayButtonState.Left1;
                                 break;
                             case 1:
@@ -66,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
                         Frames.Add(new ReplayFrame(j, null, null, button));
                         d = (d + 1) % 4;
-                        if (++count > req)
+                        if (++count == req)
                             break;
                     }
                 }

osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs

@@ -6,18 +6,133 @@ using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Objects;
 using System.Collections.Generic;
+using System.Globalization;
+using System;
 
 namespace osu.Game.Rulesets.Taiko
 {
-    public class TaikoDifficultyCalculator : DifficultyCalculator<TaikoHitObject>
+    internal class TaikoDifficultyCalculator : DifficultyCalculator<TaikoHitObject>
     {
-        public TaikoDifficultyCalculator(Beatmap beatmap) : base(beatmap)
+        private const double star_scaling_factor = 0.04125;
+
+        /// <summary>
+        /// In milliseconds. For difficulty calculation we will only look at the highest strain value in each time interval of size STRAIN_STEP.
+        /// This is to eliminate higher influence of stream over aim by simply having more HitObjects with high strain.
+        /// The higher this value, the less strains there will be, indirectly giving long beatmaps an advantage.
+        /// </summary>
+        private const double strain_step = 400;
+
+        /// <summary>
+        /// The weighting of each strain value decays to this number * it's previous value
+        /// </summary>
+        private const double decay_weight = 0.9;
+
+        /// <summary>
+        /// HitObjects are stored as a member variable.
+        /// </summary>
+        private readonly List<TaikoHitObjectDifficulty> difficultyHitObjects = new List<TaikoHitObjectDifficulty>();
+
+        public TaikoDifficultyCalculator(Beatmap beatmap)
+            : base(beatmap)
         {
         }
 
         protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
         {
-            return 0;
+            // Fill our custom DifficultyHitObject class, that carries additional information
+            difficultyHitObjects.Clear();
+
+            foreach (var hitObject in Objects)
+                difficultyHitObjects.Add(new TaikoHitObjectDifficulty(hitObject));
+
+            // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
+            difficultyHitObjects.Sort((a, b) => a.BaseHitObject.StartTime.CompareTo(b.BaseHitObject.StartTime));
+
+            if (!calculateStrainValues()) return 0;
+
+            double starRating = calculateDifficulty() * star_scaling_factor;
+
+            if (categoryDifficulty != null)
+            {
+                categoryDifficulty.Add("Strain", starRating.ToString("0.00", CultureInfo.InvariantCulture));
+                categoryDifficulty.Add("Hit window 300", (35 /*HitObjectManager.HitWindow300*/ / TimeRate).ToString("0.00", CultureInfo.InvariantCulture));
+            }
+
+            return starRating;
+        }
+
+        private bool calculateStrainValues()
+        {
+            // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
+            using (List<TaikoHitObjectDifficulty>.Enumerator hitObjectsEnumerator = difficultyHitObjects.GetEnumerator())
+            {
+                if (!hitObjectsEnumerator.MoveNext()) return false;
+
+                TaikoHitObjectDifficulty current = hitObjectsEnumerator.Current;
+
+                // First hitObject starts at strain 1. 1 is the default for strain values, so we don't need to set it here. See DifficultyHitObject.
+                while (hitObjectsEnumerator.MoveNext())
+                {
+                    var next = hitObjectsEnumerator.Current;
+                    next?.CalculateStrains(current, TimeRate);
+                    current = next;
+                }
+
+                return true;
+            }
+        }
+
+        private double calculateDifficulty()
+        {
+            double actualStrainStep = strain_step * TimeRate;
+
+            // Find the highest strain value within each strain step
+            List<double> highestStrains = new List<double>();
+            double intervalEndTime = actualStrainStep;
+            double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
+
+            TaikoHitObjectDifficulty previousHitObject = null;
+            foreach (var hitObject in difficultyHitObjects)
+            {
+                // While we are beyond the current interval push the currently available maximum to our strain list
+                while (hitObject.BaseHitObject.StartTime > intervalEndTime)
+                {
+                    highestStrains.Add(maximumStrain);
+
+                    // The maximum strain of the next interval is not zero by default! We need to take the last hitObject we encountered, take its strain and apply the decay
+                    // until the beginning of the next interval.
+                    if (previousHitObject == null)
+                    {
+                        maximumStrain = 0;
+                    }
+                    else
+                    {
+                        double decay = Math.Pow(TaikoHitObjectDifficulty.DECAY_BASE, (intervalEndTime - previousHitObject.BaseHitObject.StartTime) / 1000);
+                        maximumStrain = previousHitObject.Strain * decay;
+                    }
+
+                    // Go to the next time interval
+                    intervalEndTime += actualStrainStep;
+                }
+
+                // Obtain maximum strain
+                maximumStrain = Math.Max(hitObject.Strain, maximumStrain);
+
+                previousHitObject = hitObject;
+            }
+
+            // Build the weighted sum over the highest strains for each interval
+            double difficulty = 0;
+            double weight = 1;
+            highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
+
+            foreach (double strain in highestStrains)
+            {
+                difficulty += weight * strain;
+                weight *= decay_weight;
+            }
+
+            return difficulty;
         }
 
         protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter();

osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj

@@ -81,6 +81,7 @@
     <Compile Include="Replays\TaikoFramedReplayInputHandler.cs" />
     <Compile Include="Replays\TaikoAutoReplay.cs" />
     <Compile Include="Objects\TaikoHitObject.cs" />
+    <Compile Include="Objects\TaikoHitObjectDifficulty.cs" />
     <Compile Include="TaikoDifficultyCalculator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Scoring\TaikoScoreProcessor.cs" />

osu.Game/Audio/SampleInfoList.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+
+namespace osu.Game.Audio
+{
+    public class SampleInfoList : List<SampleInfo>
+    {
+        public SampleInfoList()
+        {
+        }
+
+        public SampleInfoList(IEnumerable<SampleInfo> elements)
+        {
+            AddRange(elements);
+        }
+    }
+}

osu.Game/Beatmaps/DifficultyCalculator.cs

@@ -35,6 +35,10 @@ namespace osu.Game.Beatmaps
         protected DifficultyCalculator(Beatmap beatmap)
         {
             Objects = CreateBeatmapConverter().Convert(beatmap).HitObjects;
+
+            foreach (var h in Objects)
+                h.ApplyDefaults(beatmap.TimingInfo, beatmap.BeatmapInfo.Difficulty);
+
             PreprocessHitObjects();
         }
 

osu.Game/Beatmaps/Drawables/DifficultyColouredContainer.cs

@@ -0,0 +1,69 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using OpenTK.Graphics;
+
+namespace osu.Game.Beatmaps.Drawables
+{
+    internal class DifficultyColouredContainer : Container, IHasAccentColour
+    {
+        public Color4 AccentColour { get; set; }
+
+        private readonly BeatmapInfo beatmap;
+        private OsuColour palette;
+
+        public DifficultyColouredContainer(BeatmapInfo beatmap)
+        {
+            this.beatmap = beatmap;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour palette)
+        {
+            this.palette = palette;
+            AccentColour = getColour(beatmap);
+        }
+
+        private enum DifficultyRating
+        {
+            Easy,
+            Normal,
+            Hard,
+            Insane,
+            Expert
+        }
+
+        private DifficultyRating getDifficultyRating(BeatmapInfo beatmap)
+        {
+            var rating = beatmap.StarDifficulty;
+
+            if (rating < 1.5) return DifficultyRating.Easy;
+            if (rating < 2.25) return DifficultyRating.Normal;
+            if (rating < 3.75) return DifficultyRating.Hard;
+            if (rating < 5.25) return DifficultyRating.Insane;
+            return DifficultyRating.Expert;
+        }
+
+        private Color4 getColour(BeatmapInfo beatmap)
+        {
+            switch (getDifficultyRating(beatmap))
+            {
+                case DifficultyRating.Easy:
+                    return palette.Green;
+                default:
+                case DifficultyRating.Normal:
+                    return palette.Yellow;
+                case DifficultyRating.Hard:
+                    return palette.Pink;
+                case DifficultyRating.Insane:
+                    return palette.Purple;
+                case DifficultyRating.Expert:
+                    return palette.Gray0;
+            }
+        }
+    }
+}

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Database;
 using osu.Game.Graphics;
 using OpenTK;
@@ -11,23 +10,20 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Beatmaps.Drawables
 {
-    internal class DifficultyIcon : Container
+
+    internal class DifficultyIcon : DifficultyColouredContainer
     {
         private readonly BeatmapInfo beatmap;
-        private OsuColour palette;
 
-        public DifficultyIcon(BeatmapInfo beatmap)
+        public DifficultyIcon(BeatmapInfo beatmap) : base(beatmap)
         {
             this.beatmap = beatmap;
-            const float size = 20;
-            Size = new Vector2(size);
+            Size = new Vector2(20);
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour palette)
+        private void load()
         {
-            this.palette = palette;
-
             Children = new[]
             {
                 new TextAwesome
@@ -35,7 +31,7 @@ namespace osu.Game.Beatmaps.Drawables
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     TextSize = Size.X,
-                    Colour = getColour(beatmap),
+                    Colour = AccentColour,
                     Icon = FontAwesome.fa_circle
                 },
                 new TextAwesome
@@ -48,43 +44,5 @@ namespace osu.Game.Beatmaps.Drawables
                 }
             };
         }
-
-        private enum DifficultyRating
-        {
-            Easy,
-            Normal,
-            Hard,
-            Insane,
-            Expert
-        }
-
-        private DifficultyRating getDifficultyRating(BeatmapInfo beatmap)
-        {
-            var rating = beatmap.StarDifficulty;
-
-            if (rating < 1.5) return DifficultyRating.Easy;
-            if (rating < 2.25) return DifficultyRating.Normal;
-            if (rating < 3.75) return DifficultyRating.Hard;
-            if (rating < 5.25) return DifficultyRating.Insane;
-            return DifficultyRating.Expert;
-        }
-
-        private Color4 getColour(BeatmapInfo beatmap)
-        {
-            switch (getDifficultyRating(beatmap))
-            {
-                case DifficultyRating.Easy:
-                    return palette.Green;
-                default:
-                case DifficultyRating.Normal:
-                    return palette.Yellow;
-                case DifficultyRating.Hard:
-                    return palette.Pink;
-                case DifficultyRating.Insane:
-                    return palette.Purple;
-                case DifficultyRating.Expert:
-                    return palette.Gray0;
-            }
-        }
     }
-}
+}

osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Beatmaps.Formats
             // TODO: Not sure how far back to go, or differences between versions
         }
 
-        private HitObjectParser parser;
+        private ConvertHitObjectParser parser;
 
         private LegacySampleBank defaultSampleBank;
         private int defaultSampleVolume = 100;
@@ -90,16 +90,16 @@ namespace osu.Game.Beatmaps.Formats
                     switch (beatmap.BeatmapInfo.RulesetID)
                     {
                         case 0:
-                            parser = new Rulesets.Objects.Legacy.Osu.HitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
                             break;
                         case 1:
-                            parser = new Rulesets.Objects.Legacy.Taiko.HitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Taiko.ConvertHitObjectParser();
                             break;
                         case 2:
-                            parser = new Rulesets.Objects.Legacy.Catch.HitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Catch.ConvertHitObjectParser();
                             break;
                         case 3:
-                            parser = new Rulesets.Objects.Legacy.Mania.HitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Mania.ConvertHitObjectParser();
                             break;
                     }
                     break;

osu.Game/Configuration/OsuConfigManager.cs

@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Configuration;
 using osu.Framework.Platform;
+using osu.Game.Screens.Select;
 
 namespace osu.Game.Configuration
 {
@@ -24,7 +25,7 @@ namespace osu.Game.Configuration
 
             Set(OsuConfig.MenuCursorSize, 1.0, 0.5f, 2);
             Set(OsuConfig.GameplayCursorSize, 1.0, 0.5f, 2);
-            Set(OsuConfig.DimLevel, 30, 0, 100);
+            Set(OsuConfig.DimLevel, 0.3, 0, 1);
 
             Set(OsuConfig.MouseDisableButtons, false);
             Set(OsuConfig.MouseDisableWheel, false);
@@ -34,10 +35,15 @@ namespace osu.Game.Configuration
 
             Set(OsuConfig.MenuParallax, true);
 
+            Set(OsuConfig.MenuVoice, true);
+            Set(OsuConfig.MenuMusic, true);
+
+            Set(OsuConfig.BeatmapDetailTab, BeatmapDetailTab.Details);
+
             Set(OsuConfig.ShowInterface, true);
             Set(OsuConfig.KeyOverlay, false);
-            //todo: implement all settings below this line (remove the Disabled set when doing so).
 
+            //todo: implement all settings below this line (remove the Disabled set when doing so).
             Set(OsuConfig.AudioOffset, 0, -500.0, 500.0);
 
             Set(OsuConfig.MouseSpeed, 1.0).Disabled = true;
@@ -145,8 +151,6 @@ namespace osu.Game.Configuration
             Set(OsuConfig.YahooIntegration, false).Disabled = true;
             Set(OsuConfig.ForceFrameFlush, false).Disabled = true;
             Set(OsuConfig.DetectPerformanceIssues, true).Disabled = true;
-            Set(OsuConfig.MenuMusic, true).Disabled = true;
-            Set(OsuConfig.MenuVoice, true).Disabled = true;
             Set(OsuConfig.RawInput, false).Disabled = true;
             Set(OsuConfig.AbsoluteToOsuWindow, Get<bool>(OsuConfig.RawInput)).Disabled = true;
             Set(OsuConfig.ShowMenuTips, true).Disabled = true;
@@ -176,7 +180,6 @@ namespace osu.Game.Configuration
             Set(OsuConfig.ConfineMouse, Get<bool>(OsuConfig.ConfineMouseToFullscreen) ?
                 ConfineMouseMode.Fullscreen : ConfineMouseMode.Never).Disabled = true;
 
-
             GetOriginalBindable<bool>(OsuConfig.SavePassword).ValueChanged += delegate
             {
                 if (Get<bool>(OsuConfig.SavePassword)) Set(OsuConfig.SaveUsername, true);
@@ -316,6 +319,7 @@ namespace osu.Game.Configuration
         MenuMusic,
         MenuVoice,
         MenuParallax,
+        BeatmapDetailTab,
         RawInput,
         AbsoluteToOsuWindow,
         ConfineMouse,
@@ -340,6 +344,5 @@ namespace osu.Game.Configuration
         Ticker,
         CompatibilityContext,
         CanForceOptimusCompatibility,
-
     }
 }

osu.Game/Database/BeatmapMetrics.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using Newtonsoft.Json;
 
 namespace osu.Game.Database
 {
@@ -18,11 +19,13 @@ namespace osu.Game.Database
         /// <summary>
         /// Points of failure on a relative time scale (usually 0..100).
         /// </summary>
+        [JsonProperty(@"fail")]
         public IEnumerable<int> Fails { get; set; }
 
         /// <summary>
         /// Points of retry on a relative time scale (usually 0..100).
         /// </summary>
+        [JsonProperty(@"exit")]
         public IEnumerable<int> Retries { get; set; }
     }
 }

osu.Game/Graphics/UserInterface/OsuSliderBar.cs

@@ -23,14 +23,14 @@ namespace osu.Game.Graphics.UserInterface
         private readonly Box leftBox;
         private readonly Box rightBox;
 
-        public string TooltipText
+        public virtual string TooltipText
         {
             get
             {
                 var bindableDouble = CurrentNumber as BindableNumber<double>;
                 if (bindableDouble != null)
                 {
-                    if (bindableDouble.MaxValue == 1 && bindableDouble.MinValue == 0)
+                    if (bindableDouble.MaxValue == 1 && (bindableDouble.MinValue == 0 || bindableDouble.MinValue == -1))
                         return bindableDouble.Value.ToString(@"P0");
                     return bindableDouble.Value.ToString(@"n1");
                 }

osu.Game/Online/API/Requests/GetBeatmapDetailsRequest.cs

@@ -0,0 +1,46 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using Newtonsoft.Json;
+using osu.Game.Database;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetBeatmapDetailsRequest : APIRequest<GetBeatmapDeatilsResponse>
+    {
+        private readonly BeatmapInfo beatmap;
+
+        private string lookupString => beatmap.OnlineBeatmapID > 0 ? beatmap.OnlineBeatmapID.ToString() : $@"lookup?checksum={beatmap.Hash}&filename={beatmap.Path}";
+
+        public GetBeatmapDetailsRequest(BeatmapInfo beatmap)
+        {
+            this.beatmap = beatmap;
+        }
+
+        protected override string Target => $@"beatmaps/{lookupString}";
+    }
+
+    public class GetBeatmapDeatilsResponse : BeatmapMetrics
+    {
+        //the online API returns some metrics as a nested object.
+        [JsonProperty(@"failtimes")]
+        private BeatmapMetrics failTimes
+        {
+            set
+            {
+                Fails = value.Fails;
+                Retries = value.Retries;
+            }
+        }
+
+        //and other metrics in the beatmap set.
+        [JsonProperty(@"beatmapset")]
+        private BeatmapMetrics beatmapSet
+        {
+            set
+            {
+                Ratings = value.Ratings;
+            }
+        }
+    }
+}

osu.Game/Overlays/MusicController.cs

@@ -294,7 +294,7 @@ namespace osu.Game.Overlays
                 trackManager.SetExclusive(current.Track);
                 current.Track.Start();
                 beatmapSource.Value = current;
-            }).ContinueWith(task => Schedule(() => task.ThrowIfFaulted()), TaskContinuationOptions.OnlyOnFaulted);
+            }).ContinueWith(task => Schedule(task.ThrowIfFaulted), TaskContinuationOptions.OnlyOnFaulted);
             updateDisplay(current, isNext ? TransformDirection.Next : TransformDirection.Prev);
         }
 

osu.Game/Overlays/Options/OptionSlider.cs

@@ -12,7 +12,11 @@ using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options
 {
-    public class OptionSlider<T> : FillFlowContainer where T : struct
+    public class OptionSlider<T> : OptionSlider<T, OsuSliderBar<T>> where T: struct
+    {
+    }
+
+    public class OptionSlider<T, U> : FillFlowContainer where T : struct where U : SliderBar<T>, new()
     {
         private readonly SliderBar<T> slider;
         private readonly SpriteText text;
@@ -50,7 +54,7 @@ namespace osu.Game.Overlays.Options
                 {
                     Alpha = 0,
                 },
-                slider = new OsuSliderBar<T>
+                slider = new U()
                 {
                     Margin = new MarginPadding { Top = 5, Bottom = 5 },
                     RelativeSizeAxes = Axes.X

osu.Game/Overlays/Options/Sections/Audio/OffsetOptions.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
@@ -18,10 +17,10 @@ namespace osu.Game.Overlays.Options.Sections.Audio
         {
             Children = new Drawable[]
             {
-                new OptionSlider<double>
+                new OptionSlider<double, OffsetSlider>
                 {
                     LabelText = "Audio Offset",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.AudioOffset)
+                    Bindable = config.GetBindable<double>(OsuConfig.AudioOffset)
                 },
                 new OsuButton
                 {
@@ -30,5 +29,10 @@ namespace osu.Game.Overlays.Options.Sections.Audio
                 }
             };
         }
+
+        private class OffsetSlider : OsuSliderBar<double>
+        {
+            public override string TooltipText => Current.Value.ToString(@"0ms");
+        }
     }
 }

osu.Game/Overlays/Options/Sections/Gameplay/GeneralOptions.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
@@ -18,10 +17,10 @@ namespace osu.Game.Overlays.Options.Sections.Gameplay
         {
             Children = new Drawable[]
             {
-                new OptionSlider<int>
+                new OptionSlider<double>
                 {
                     LabelText = "Background dim",
-                    Bindable = (BindableInt)config.GetBindable<int>(OsuConfig.DimLevel)
+                    Bindable = config.GetBindable<double>(OsuConfig.DimLevel)
                 },
                 new OptionEnumDropdown<ProgressBarType>
                 {
@@ -36,7 +35,7 @@ namespace osu.Game.Overlays.Options.Sections.Gameplay
                 new OptionSlider<double>
                 {
                     LabelText = "Score meter size",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.ScoreMeterScale)
+                    Bindable = config.GetBindable<double>(OsuConfig.ScoreMeterScale)
                 },
                 new OsuCheckbox
                 {

osu.Game/Overlays/Options/Sections/Gameplay/SongSelectOptions.cs

@@ -2,9 +2,9 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Gameplay
 {
@@ -17,18 +17,23 @@ namespace osu.Game.Overlays.Options.Sections.Gameplay
         {
             Children = new Drawable[]
             {
-                new OptionSlider<double>
+                new OptionSlider<double, StarSlider>
                 {
                     LabelText = "Display beatmaps from",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.DisplayStarsMinimum)
+                    Bindable = config.GetBindable<double>(OsuConfig.DisplayStarsMinimum)
                 },
-                new OptionSlider<double>
+                new OptionSlider<double, StarSlider>
                 {
                     LabelText = "up to",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.DisplayStarsMaximum)
+                    Bindable = config.GetBindable<double>(OsuConfig.DisplayStarsMaximum)
                 },
             };
         }
+
+        private class StarSlider : OsuSliderBar<double>
+        {
+            public override string TooltipText => Current.Value.ToString(@"0.## stars");
+        }
     }
 }
 

osu.Game/Overlays/Options/Sections/Input/MouseOptions.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
@@ -18,10 +17,10 @@ namespace osu.Game.Overlays.Options.Sections.Input
         {
             Children = new Drawable[]
             {
-                new OptionSlider<double>
+                new OptionSlider<double, SensitivitySlider>
                 {
                     LabelText = "Sensitivity",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.MouseSpeed),
+                    Bindable = config.GetBindable<double>(OsuConfig.MouseSpeed)
                 },
                 new OsuCheckbox
                 {
@@ -55,5 +54,10 @@ namespace osu.Game.Overlays.Options.Sections.Input
                 },
             };
         }
+
+        private class SensitivitySlider : OsuSliderBar<double>
+        {
+            public override string TooltipText => Current.Value.ToString(@"0.##x");
+        }
     }
 }

osu.Game/Overlays/Options/Sections/SkinSection.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
@@ -59,15 +58,15 @@ namespace osu.Game.Overlays.Options.Sections
                     LabelText = "Always use skin cursor",
                     Bindable = config.GetBindable<bool>(OsuConfig.UseSkinCursor)
                 },
-                new OptionSlider<double>
+                new OptionSlider<double, SizeSlider>
                 {
                     LabelText = "Menu cursor size",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.MenuCursorSize)
+                    Bindable = config.GetBindable<double>(OsuConfig.MenuCursorSize)
                 },
-                new OptionSlider<double>
+                new OptionSlider<double, SizeSlider>
                 {
                     LabelText = "Gameplay cursor size",
-                    Bindable = (BindableDouble)config.GetBindable<double>(OsuConfig.GameplayCursorSize)
+                    Bindable = config.GetBindable<double>(OsuConfig.GameplayCursorSize)
                 },
                 new OsuCheckbox
                 {
@@ -76,5 +75,10 @@ namespace osu.Game.Overlays.Options.Sections
                 },
             };
         }
+
+        private class SizeSlider : OsuSliderBar<double>
+        {
+            public override string TooltipText => Current.Value.ToString(@"0.##x");
+        }
     }
 }

osu.Game/Rulesets/Objects/CurvedHitObject.cs

@@ -1,49 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using OpenTK;
-using osu.Game.Rulesets.Objects.Types;
-using System.Collections.Generic;
-
-namespace osu.Game.Rulesets.Objects
-{
-    public class CurvedHitObject : HitObject, IHasCurve
-    {
-        public SliderCurve Curve { get; } = new SliderCurve();
-
-        public int RepeatCount { get; set; } = 1;
-
-        public double EndTime => 0;
-        public double Duration => 0;
-
-        public List<Vector2> ControlPoints
-        {
-            get { return Curve.ControlPoints; }
-            set { Curve.ControlPoints = value; }
-        }
-
-        public CurveType CurveType
-        {
-            get { return Curve.CurveType; }
-            set { Curve.CurveType = value; }
-        }
-
-        public double Distance
-        {
-            get { return Curve.Distance; }
-            set { Curve.Distance = value; }
-        }
-
-        public Vector2 PositionAt(double progress) => Curve.PositionAt(ProgressAt(progress));
-
-        public double ProgressAt(double progress)
-        {
-            var p = progress * RepeatCount % 1;
-            if (RepeatAt(progress) % 2 == 1)
-                p = 1 - p;
-            return p;
-        }
-
-        public int RepeatAt(double progress) => (int)(progress * RepeatCount);
-    }
-}

osu.Game/Rulesets/Objects/HitObject.cs

@@ -4,7 +4,7 @@
 using osu.Game.Audio;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Database;
-using System.Collections.Generic;
+using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Objects
 {
@@ -19,12 +19,16 @@ namespace osu.Game.Rulesets.Objects
         /// <summary>
         /// The time at which the HitObject starts.
         /// </summary>
-        public double StartTime { get; set; }
+        public double StartTime;
 
         /// <summary>
         /// The samples to be played when this hit object is hit.
+        /// <para>
+        /// In the case of <see cref="IHasRepeats"/> types, this is the sample of the curve body
+        /// and can be treated as the default samples for the hit object.
+        /// </para>
         /// </summary>
-        public List<SampleInfo> Samples = new List<SampleInfo>();
+        public SampleInfoList Samples = new SampleInfoList();
 
         /// <summary>
         /// Applies default values to this HitObject.
@@ -36,17 +40,24 @@ namespace osu.Game.Rulesets.Objects
             ControlPoint overridePoint;
             ControlPoint timingPoint = timing.TimingPointAt(StartTime, out overridePoint);
 
-            foreach (var sample in Samples)
-            {
-                if (sample.Volume == 0)
-                    sample.Volume = (overridePoint ?? timingPoint)?.SampleVolume ?? 0;
+            ControlPoint samplePoint = overridePoint ?? timingPoint;
 
-                // If the bank is not assigned a name, assign it from the control point
-                if (!string.IsNullOrEmpty(sample.Bank))
-                    continue;
+            // Initialize first sample
+            Samples.ForEach(s => initializeSampleInfo(s, samplePoint));
 
-                sample.Bank = (overridePoint ?? timingPoint)?.SampleBank ?? @"normal";
-            }
+            // Initialize any repeat samples
+            var repeatData = this as IHasRepeats;
+            repeatData?.RepeatSamples?.ForEach(r => r.ForEach(s => initializeSampleInfo(s, samplePoint)));
+        }
+
+        private void initializeSampleInfo(SampleInfo sample, ControlPoint controlPoint)
+        {
+            if (sample.Volume == 0)
+                sample.Volume = controlPoint?.SampleVolume ?? 0;
+
+            // If the bank is not assigned a name, assign it from the control point
+            if (string.IsNullOrEmpty(sample.Bank))
+                sample.Bank = controlPoint?.SampleBank ?? @"normal";
         }
     }
 }

osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHit.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
     /// <summary>
     /// Legacy osu!catch Hit-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Hit : HitObject, IHasCombo, IHasXPosition
+    internal sealed class ConvertHit : HitObject, IHasCombo, IHasXPosition
     {
         public float X { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Types;
 using System.Collections.Generic;
 
@@ -10,33 +11,34 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
     /// <summary>
     /// A HitObjectParser to parse legacy osu!catch Beatmaps.
     /// </summary>
-    internal class HitObjectParser : Legacy.HitObjectParser
+    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {
-            return new Hit
+            return new ConvertHit
             {
                 X = position.X,
                 NewCombo = newCombo,
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount, List<SampleInfoList> repeatSamples)
         {
-            return new Slider
+            return new ConvertSlider
             {
                 X = position.X,
                 NewCombo = newCombo,
                 ControlPoints = controlPoints,
                 Distance = length,
                 CurveType = curveType,
+                RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };
         }
 
         protected override HitObject CreateSpinner(Vector2 position, double endTime)
         {
-            return new Spinner
+            return new ConvertSpinner
             {
                 EndTime = endTime
             };

osu.Game/Rulesets/Objects/Legacy/Catch/ConvertSlider.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
     /// <summary>
     /// Legacy osu!catch Slider-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Slider : CurvedHitObject, IHasXPosition, IHasCombo
+    internal sealed class ConvertSlider : Legacy.ConvertSlider, IHasXPosition, IHasCombo
     {
         public float X { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Catch/ConvertSpinner.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
     /// <summary>
     /// Legacy osu!catch Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Spinner : HitObject, IHasEndTime
+    internal sealed class ConvertSpinner : HitObject, IHasEndTime
     {
         public double EndTime { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -14,29 +14,28 @@ namespace osu.Game.Rulesets.Objects.Legacy
     /// <summary>
     /// A HitObjectParser to parse legacy Beatmaps.
     /// </summary>
-    internal abstract class HitObjectParser : Objects.HitObjectParser
+    internal abstract class ConvertHitObjectParser : HitObjectParser
     {
         public override HitObject Parse(string text)
         {
             string[] split = text.Split(',');
-            var type = (HitObjectType)int.Parse(split[3]) & ~HitObjectType.ColourHax;
-            bool combo = type.HasFlag(HitObjectType.NewCombo);
-            type &= ~HitObjectType.NewCombo;
+            ConvertHitObjectType type = (ConvertHitObjectType)int.Parse(split[3]) & ~ConvertHitObjectType.ColourHax;
+            bool combo = type.HasFlag(ConvertHitObjectType.NewCombo);
+            type &= ~ConvertHitObjectType.NewCombo;
 
-            int sampleVolume = 0;
-            string normalSampleBank = null;
-            string addSampleBank = null;
+            var soundType = (LegacySoundType)int.Parse(split[4]);
+            var bankInfo = new SampleBankInfo();
 
             HitObject result;
 
-            if ((type & HitObjectType.Circle) > 0)
+            if ((type & ConvertHitObjectType.Circle) > 0)
             {
                 result = CreateHit(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo);
 
                 if (split.Length > 5)
-                    readCustomSampleBanks(split[5], ref normalSampleBank, ref addSampleBank, ref sampleVolume);
+                    readCustomSampleBanks(split[5], bankInfo);
             }
-            else if ((type & HitObjectType.Slider) > 0)
+            else if ((type & ConvertHitObjectType.Slider) > 0)
             {
                 CurveType curveType = CurveType.Catmull;
                 double length = 0;
@@ -77,26 +76,74 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 if (split.Length > 7)
                     length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
 
-                result = CreateSlider(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo, points, length, curveType, repeatCount);
-
                 if (split.Length > 10)
-                    readCustomSampleBanks(split[10], ref normalSampleBank, ref addSampleBank, ref sampleVolume);
+                    readCustomSampleBanks(split[10], bankInfo);
+
+                // One node for each repeat + the start and end nodes
+                // Note that the first length of the slider is considered a repeat, but there are no actual repeats happening
+                int nodes = Math.Max(0, repeatCount - 1) + 2;
+
+                // Populate node sample bank infos with the default hit object sample bank
+                var nodeBankInfos = new List<SampleBankInfo>();
+                for (int i = 0; i < nodes; i++)
+                    nodeBankInfos.Add(bankInfo.Clone());
+
+                // Read any per-node sample banks
+                if (split.Length > 9 && split[9].Length > 0)
+                {
+                    string[] sets = split[9].Split('|');
+                    for (int i = 0; i < nodes; i++)
+                    {
+                        if (i >= sets.Length)
+                            break;
+
+                        SampleBankInfo info = nodeBankInfos[i];
+                        readCustomSampleBanks(sets[i], info);
+                    }
+                }
+
+                // Populate node sound types with the default hit object sound type
+                var nodeSoundTypes = new List<LegacySoundType>();
+                for (int i = 0; i < nodes; i++)
+                    nodeSoundTypes.Add(soundType);
+
+                // Read any per-node sound types
+                if (split.Length > 8 && split[8].Length > 0)
+                {
+                    string[] adds = split[8].Split('|');
+                    for (int i = 0; i < nodes; i++)
+                    {
+                        if (i >= adds.Length)
+                            break;
+
+                        int sound;
+                        int.TryParse(adds[i], out sound);
+                        nodeSoundTypes[i] = (LegacySoundType)sound;
+                    }
+                }
+
+                // Generate the final per-node samples
+                var nodeSamples = new List<SampleInfoList>(nodes);
+                for (int i = 0; i <= repeatCount; i++)
+                    nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i]));
+
+                result = CreateSlider(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo, points, length, curveType, repeatCount, nodeSamples);
             }
-            else if ((type & HitObjectType.Spinner) > 0)
+            else if ((type & ConvertHitObjectType.Spinner) > 0)
             {
                 result = CreateSpinner(new Vector2(512, 384) / 2, Convert.ToDouble(split[5], CultureInfo.InvariantCulture));
 
                 if (split.Length > 6)
-                    readCustomSampleBanks(split[6], ref normalSampleBank, ref addSampleBank, ref sampleVolume);
+                    readCustomSampleBanks(split[6], bankInfo);
             }
-            else if ((type & HitObjectType.Hold) > 0)
+            else if ((type & ConvertHitObjectType.Hold) > 0)
             {
                 // Note: Hold is generated by BMS converts
 
                 // Todo: Apparently end time is determined by samples??
                 // Shouldn't need implementation until mania
 
-                result = new Hold
+                result = new ConvertHold
                 {
                     Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
                     NewCombo = combo
@@ -106,50 +153,12 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 throw new InvalidOperationException($@"Unknown hit object type {type}");
 
             result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
-
-            var soundType = (LegacySoundType)int.Parse(split[4]);
-
-            result.Samples.Add(new SampleInfo
-            {
-                Bank = normalSampleBank,
-                Name = SampleInfo.HIT_NORMAL,
-                Volume = sampleVolume
-            });
-
-            if ((soundType & LegacySoundType.Finish) > 0)
-            {
-                result.Samples.Add(new SampleInfo
-                {
-                    Bank = addSampleBank,
-                    Name = SampleInfo.HIT_FINISH,
-                    Volume = sampleVolume
-                });
-            }
-
-            if ((soundType & LegacySoundType.Whistle) > 0)
-            {
-                result.Samples.Add(new SampleInfo
-                {
-                    Bank = addSampleBank,
-                    Name = SampleInfo.HIT_WHISTLE,
-                    Volume = sampleVolume
-                });
-            }
-
-            if ((soundType & LegacySoundType.Clap) > 0)
-            {
-                result.Samples.Add(new SampleInfo
-                {
-                    Bank = addSampleBank,
-                    Name = SampleInfo.HIT_CLAP,
-                    Volume = sampleVolume
-                });
-            }
+            result.Samples = convertSoundType(soundType, bankInfo);
 
             return result;
         }
 
-        private void readCustomSampleBanks(string str, ref string normalSampleBank, ref string addSampleBank, ref int sampleVolume)
+        private void readCustomSampleBanks(string str, SampleBankInfo bankInfo)
         {
             if (string.IsNullOrEmpty(str))
                 return;
@@ -169,9 +178,11 @@ namespace osu.Game.Rulesets.Objects.Legacy
             if (stringAddBank == @"none")
                 stringAddBank = null;
 
-            normalSampleBank = stringBank;
-            addSampleBank = stringAddBank;
-            sampleVolume = split.Length > 3 ? int.Parse(split[3]) : 0;
+            bankInfo.Normal = stringBank;
+            bankInfo.Add = stringAddBank;
+
+            if (split.Length > 3)
+                bankInfo.Volume = int.Parse(split[3]);
         }
 
         /// <summary>
@@ -191,8 +202,9 @@ namespace osu.Game.Rulesets.Objects.Legacy
         /// <param name="length">The slider length.</param>
         /// <param name="curveType">The slider curve type.</param>
         /// <param name="repeatCount">The slider repeat count.</param>
+        /// <param name="repeatSamples">The samples to be played when the repeat nodes are hit. This includes the head and tail of the slider.</param>
         /// <returns>The hit object.</returns>
-        protected abstract HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount);
+        protected abstract HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount, List<SampleInfoList> repeatSamples);
 
         /// <summary>
         /// Creates a legacy Spinner-type hit object.
@@ -202,6 +214,63 @@ namespace osu.Game.Rulesets.Objects.Legacy
         /// <returns>The hit object.</returns>
         protected abstract HitObject CreateSpinner(Vector2 position, double endTime);
 
+        private SampleInfoList convertSoundType(LegacySoundType type, SampleBankInfo bankInfo)
+        {
+            var soundTypes = new SampleInfoList
+            {
+                new SampleInfo
+                {
+                    Bank = bankInfo.Normal,
+                    Name = SampleInfo.HIT_NORMAL,
+                    Volume = bankInfo.Volume
+                }
+            };
+
+            if ((type & LegacySoundType.Finish) > 0)
+            {
+                soundTypes.Add(new SampleInfo
+                {
+                    Bank = bankInfo.Add,
+                    Name = SampleInfo.HIT_FINISH,
+                    Volume = bankInfo.Volume
+                });
+            }
+
+            if ((type & LegacySoundType.Whistle) > 0)
+            {
+                soundTypes.Add(new SampleInfo
+                {
+                    Bank = bankInfo.Add,
+                    Name = SampleInfo.HIT_WHISTLE,
+                    Volume = bankInfo.Volume
+                });
+            }
+
+            if ((type & LegacySoundType.Clap) > 0)
+            {
+                soundTypes.Add(new SampleInfo
+                {
+                    Bank = bankInfo.Add,
+                    Name = SampleInfo.HIT_CLAP,
+                    Volume = bankInfo.Volume
+                });
+            }
+
+            return soundTypes;
+        }
+
+        private class SampleBankInfo
+        {
+            public string Normal;
+            public string Add;
+            public int Volume;
+
+            public SampleBankInfo Clone()
+            {
+                return (SampleBankInfo)MemberwiseClone();
+            }
+        }
+
         [Flags]
         private enum LegacySoundType
         {

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectType.cs

@@ -6,7 +6,7 @@ using System;
 namespace osu.Game.Rulesets.Objects.Legacy
 {
     [Flags]
-    public enum HitObjectType
+    internal enum ConvertHitObjectType
     {
         Circle = 1 << 0,
         Slider = 1 << 1,

osu.Game/Rulesets/Objects/Legacy/ConvertHold.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
     /// <summary>
     /// Legacy Hold-type, used for parsing "specials" in beatmaps.
     /// </summary>
-    internal sealed class Hold : HitObject, IHasPosition, IHasCombo, IHasHold
+    internal sealed class ConvertHold : HitObject, IHasPosition, IHasCombo, IHasHold
     {
         public Vector2 Position { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Objects.Types;
+using System;
+using System.Collections.Generic;
+using OpenTK;
+using osu.Game.Audio;
+
+namespace osu.Game.Rulesets.Objects.Legacy
+{
+    internal abstract class ConvertSlider : HitObject, IHasCurve
+    {
+        public List<Vector2> ControlPoints { get; set; }
+        public CurveType CurveType { get; set; }
+        public double Distance { get; set; }
+
+        public List<SampleInfoList> RepeatSamples { get; set; }
+        public int RepeatCount { get; set; } = 1;
+
+        public double EndTime { get; set; }
+        public double Duration { get; set; }
+
+        public Vector2 PositionAt(double progress)
+        {
+            throw new NotImplementedException();
+        }
+
+        public double ProgressAt(double progress)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int RepeatAt(double progress)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHit.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
     /// <summary>
     /// Legacy osu!mania Hit-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Hit : HitObject, IHasXPosition, IHasCombo
+    internal sealed class ConvertHit : HitObject, IHasXPosition, IHasCombo
     {
         public float X { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Types;
 using System.Collections.Generic;
 
@@ -10,33 +11,34 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
     /// <summary>
     /// A HitObjectParser to parse legacy osu!mania Beatmaps.
     /// </summary>
-    internal class HitObjectParser : Legacy.HitObjectParser
+    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {
-            return new Hit
+            return new ConvertHit
             {
                 X = position.X,
                 NewCombo = newCombo,
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount, List<SampleInfoList> repeatSamples)
         {
-            return new Slider
+            return new ConvertSlider
             {
                 X = position.X,
                 NewCombo = newCombo,
                 ControlPoints = controlPoints,
                 Distance = length,
                 CurveType = curveType,
+                RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };
         }
 
         protected override HitObject CreateSpinner(Vector2 position, double endTime)
         {
-            return new Spinner
+            return new ConvertSpinner
             {
                 X = position.X,
                 EndTime = endTime

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSlider.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
     /// <summary>
     /// Legacy osu!mania Slider-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Slider : CurvedHitObject, IHasXPosition, IHasCombo
+    internal sealed class ConvertSlider : Legacy.ConvertSlider, IHasXPosition, IHasCombo
     {
         public float X { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSpinner.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
     /// <summary>
     /// Legacy osu!mania Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Spinner : HitObject, IHasEndTime, IHasXPosition
+    internal sealed class ConvertSpinner : HitObject, IHasEndTime, IHasXPosition
     {
         public double EndTime { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHit.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
     /// <summary>
     /// Legacy osu! Hit-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Hit : HitObject, IHasPosition, IHasCombo
+    internal sealed class ConvertHit : HitObject, IHasPosition, IHasCombo
     {
         public Vector2 Position { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Types;
 using System.Collections.Generic;
 
@@ -10,33 +11,34 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
     /// <summary>
     /// A HitObjectParser to parse legacy osu! Beatmaps.
     /// </summary>
-    internal class HitObjectParser : Legacy.HitObjectParser
+    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {
-            return new Hit
+            return new ConvertHit
             {
                 Position = position,
                 NewCombo = newCombo,
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount, List<SampleInfoList> repeatSamples)
         {
-            return new Slider
+            return new ConvertSlider
             {
                 Position = position,
                 NewCombo = newCombo,
                 ControlPoints = controlPoints,
                 Distance = length,
                 CurveType = curveType,
+                RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };
         }
 
         protected override HitObject CreateSpinner(Vector2 position, double endTime)
         {
-            return new Spinner
+            return new ConvertSpinner
             {
                 Position = position,
                 EndTime = endTime

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSlider.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
     /// <summary>
     /// Legacy osu! Slider-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Slider : CurvedHitObject, IHasPosition, IHasCombo
+    internal sealed class ConvertSlider : Legacy.ConvertSlider, IHasPosition, IHasCombo
     {
         public Vector2 Position { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSpinner.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
     /// <summary>
     /// Legacy osu! Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Spinner : HitObject, IHasEndTime, IHasPosition
+    internal sealed class ConvertSpinner : HitObject, IHasEndTime, IHasPosition
     {
         public double EndTime { get; set; }
 

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHit.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
     /// <summary>
     /// Legacy osu!taiko Hit-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Hit : HitObject, IHasCombo
+    internal sealed class ConvertHit : HitObject, IHasCombo
     {
         public bool NewCombo { get; set; }
     }

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Types;
 using System.Collections.Generic;
 
@@ -10,31 +11,32 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
     /// <summary>
     /// A HitObjectParser to parse legacy osu!taiko Beatmaps.
     /// </summary>
-    internal class HitObjectParser : Legacy.HitObjectParser
+    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {
-            return new Hit
+            return new ConvertHit
             {
                 NewCombo = newCombo,
             };
         }
 
-        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount, List<SampleInfoList> repeatSamples)
         {
-            return new Slider
+            return new ConvertSlider
             {
                 NewCombo = newCombo,
                 ControlPoints = controlPoints,
                 Distance = length,
                 CurveType = curveType,
+                RepeatSamples = repeatSamples,
                 RepeatCount = repeatCount
             };
         }
 
         protected override HitObject CreateSpinner(Vector2 position, double endTime)
         {
-            return new Spinner
+            return new ConvertSpinner
             {
                 EndTime = endTime
             };

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSlider.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
     /// <summary>
     /// Legacy osu!taiko Slider-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Slider : CurvedHitObject, IHasCombo
+    internal sealed class ConvertSlider : Legacy.ConvertSlider, IHasCombo
     {
         public bool NewCombo { get; set; }
     }

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSpinner.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
     /// <summary>
     /// Legacy osu!taiko Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class Spinner : HitObject, IHasEndTime
+    internal sealed class ConvertSpinner : HitObject, IHasEndTime
     {
         public double EndTime { get; set; }
 

osu.Game/Rulesets/Objects/Types/IHasCurve.cs

@@ -11,11 +11,6 @@ namespace osu.Game.Rulesets.Objects.Types
     /// </summary>
     public interface IHasCurve : IHasDistance, IHasRepeats
     {
-        /// <summary>
-        /// The curve.
-        /// </summary>
-        SliderCurve Curve { get; }
-
         /// <summary>
         /// The control points that shape the curve.
         /// </summary>

osu.Game/Rulesets/Objects/Types/IHasRepeats.cs

@@ -1,6 +1,9 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Audio;
+using System.Collections.Generic;
+
 namespace osu.Game.Rulesets.Objects.Types
 {
     /// <summary>
@@ -12,5 +15,10 @@ namespace osu.Game.Rulesets.Objects.Types
         /// The amount of times the HitObject repeats.
         /// </summary>
         int RepeatCount { get; }
+
+        /// <summary>
+        /// The samples to be played when each repeat node is hit (0 -> first repeat node, 1 -> second repeat node, etc).
+        /// </summary>
+        List<SampleInfoList> RepeatSamples { get; }
     }
 }

osu.Game/Rulesets/UI/HitRenderer.cs

@@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.UI
         where TObject : HitObject
     {
         /// <summary>
-        /// The Beatmap 
+        /// The Beatmap
         /// </summary>
         public Beatmap<TObject> Beatmap;
 

osu.Game/Screens/Menu/Intro.cs

@@ -5,8 +5,10 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
 using osu.Framework.Screens;
 using osu.Framework.Graphics;
+using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Backgrounds;
 using OpenTK.Graphics;
@@ -56,25 +58,33 @@ namespace osu.Game.Screens.Menu
             };
         }
 
+        private Bindable<bool> menuVoice;
+        private Bindable<bool> menuMusic;
+
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load(AudioManager audio, OsuConfigManager config)
         {
-            welcome = audio.Sample.Get(@"welcome");
-            seeya = audio.Sample.Get(@"seeya");
+            menuVoice = config.GetBindable<bool>(OsuConfig.MenuVoice);
+            menuMusic = config.GetBindable<bool>(OsuConfig.MenuMusic);
 
             bgm = audio.Track.Get(@"circles");
             bgm.Looping = true;
+
+            welcome = audio.Sample.Get(@"welcome");
+            seeya = audio.Sample.Get(@"seeya");
         }
 
         protected override void OnEntering(Screen last)
         {
             base.OnEntering(last);
 
-            welcome.Play();
+            if (menuVoice)
+                welcome.Play();
 
             Scheduler.AddDelayed(delegate
             {
-                bgm.Start();
+                if (menuMusic)
+                    bgm.Start();
 
                 LoadComponentAsync(mainMenu = new MainMenu());
 
@@ -109,15 +119,17 @@ namespace osu.Game.Screens.Menu
             if (!(last is MainMenu))
                 Content.FadeIn(300);
 
+            double fadeOutTime = 2000;
             //we also handle the exit transition.
-            seeya.Play();
+            if (menuVoice)
+                seeya.Play();
+            else
+                fadeOutTime = 500;
 
-            const double fade_out_time = 2000;
-
-            Scheduler.AddDelayed(Exit, fade_out_time);
+            Scheduler.AddDelayed(Exit, fadeOutTime);
 
             //don't want to fade out completely else we will stop running updates and shit will hit the fan.
-            Game.FadeTo(0.01f, fade_out_time);
+            Game.FadeTo(0.01f, fadeOutTime);
 
             base.OnResuming(last);
         }

osu.Game/Screens/Menu/MainMenu.cs

@@ -2,8 +2,14 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.MathUtils;
 using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Charts;
@@ -15,6 +21,7 @@ using osu.Game.Screens.Select;
 using osu.Game.Screens.Tournament;
 using osu.Framework.Input;
 using OpenTK.Input;
+using System.Threading.Tasks;
 
 namespace osu.Game.Screens.Menu
 {
@@ -54,11 +61,27 @@ namespace osu.Game.Screens.Menu
             };
         }
 
+        private Bindable<bool> menuMusic;
+        private TrackManager trackManager;
+        private WorkingBeatmap song;
+
         [BackgroundDependencyLoader]
-        private void load(OsuGame game)
+        private void load(OsuGame game, OsuConfigManager config, BeatmapDatabase beatmaps)
         {
+            menuMusic = config.GetBindable<bool>(OsuConfig.MenuMusic);
             LoadComponentAsync(background);
 
+            if (!menuMusic)
+            {
+                trackManager = game.Audio.Track;
+                int choosableBeatmapsetAmmount = beatmaps.Query<BeatmapSetInfo>().Count();
+                if (choosableBeatmapsetAmmount > 0)
+                {
+                    song = beatmaps.GetWorkingBeatmap(beatmaps.GetWithChildren<BeatmapSetInfo>(RNG.Next(1, choosableBeatmapsetAmmount)).Beatmaps[0]);
+                    Beatmap = song;
+                }
+            }
+
             buttons.OnSettings = game.ToggleOptions;
 
             preloadSongSelect();
@@ -81,6 +104,17 @@ namespace osu.Game.Screens.Menu
         {
             base.OnEntering(last);
             buttons.FadeInFromZero(500);
+            if (last is Intro && song != null)
+            {
+                Task.Run(() =>
+                {
+                    trackManager.SetExclusive(song.Track);
+                    song.Track.Seek(song.Beatmap.Metadata.PreviewTime);
+                    if (song.Beatmap.Metadata.PreviewTime == -1)
+                        song.Track.Seek(song.Track.Length * 0.4f);
+                    song.Track.Start();
+                });
+            }
         }
 
         protected override void OnSuspending(Screen next)

osu.Game/Screens/Play/Player.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Screens.Play
 
         public Action RestartRequested;
 
-        public bool IsPaused => !interpolatedSourceClock.IsRunning;
+        public bool IsPaused => !decoupledClock.IsRunning;
 
         internal override bool AllowRulesetChange => false;
 
@@ -51,9 +51,9 @@ namespace osu.Game.Screens.Play
 
         private bool canPause => ValidForResume && !HasFailed && Time.Current >= lastPauseActionTime + pause_cooldown;
 
-        private IAdjustableClock sourceClock;
-        private OffsetClock offsetClock;
-        private IFrameBasedClock interpolatedSourceClock;
+        private IAdjustableClock adjustableSourceClock;
+        private FramedOffsetClock offsetClock;
+        private DecoupleableInterpolatingFramedClock decoupledClock;
 
         private RulesetInfo ruleset;
 
@@ -62,7 +62,7 @@ namespace osu.Game.Screens.Play
 
         #region User Settings
 
-        private Bindable<int> dimLevel;
+        private Bindable<double> dimLevel;
         private Bindable<bool> mouseWheelDisabled;
         private Bindable<double> userAudioOffset;
 
@@ -70,6 +70,8 @@ namespace osu.Game.Screens.Play
 
         private SkipButton skipButton;
 
+        private Container hitRendererContainer;
+
         private HudOverlay hudOverlay;
         private PauseOverlay pauseOverlay;
         private FailOverlay failOverlay;
@@ -77,7 +79,7 @@ namespace osu.Game.Screens.Play
         [BackgroundDependencyLoader(permitNulls: true)]
         private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuConfigManager config, OsuGame osu)
         {
-            dimLevel = config.GetBindable<int>(OsuConfig.DimLevel);
+            dimLevel = config.GetBindable<double>(OsuConfig.DimLevel);
             mouseWheelDisabled = config.GetBindable<bool>(OsuConfig.MouseDisableWheel);
 
             Ruleset rulesetInstance;
@@ -87,10 +89,7 @@ namespace osu.Game.Screens.Play
                 if (Beatmap == null)
                     Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo, withStoryboard: true);
 
-                if ((Beatmap?.Beatmap?.HitObjects.Count ?? 0) == 0)
-                    throw new Exception("No valid objects were found!");
-
-                if (Beatmap == null)
+                if (Beatmap?.Beatmap == null)
                     throw new Exception("Beatmap was not loaded");
 
                 ruleset = osu?.Ruleset.Value ?? Beatmap.BeatmapInfo.Ruleset;
@@ -108,6 +107,9 @@ namespace osu.Game.Screens.Play
                     rulesetInstance = ruleset.CreateInstance();
                     HitRenderer = rulesetInstance.CreateHitRendererWith(Beatmap);
                 }
+
+                if (!HitRenderer.Objects.Any())
+                    throw new Exception("Beatmap contains no hit objects!");
             }
             catch (Exception e)
             {
@@ -123,23 +125,31 @@ namespace osu.Game.Screens.Play
             if (track != null)
             {
                 audio.Track.SetExclusive(track);
-                sourceClock = track;
+                adjustableSourceClock = track;
             }
 
-            sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
-            offsetClock = new OffsetClock(sourceClock);
+            adjustableSourceClock = (IAdjustableClock)track ?? new StopwatchClock();
+
+            decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+
+            var firstObjectTime = HitRenderer.Objects.First().StartTime;
+            decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(Beatmap.Beatmap.TimingInfo.BeatLengthAt(firstObjectTime) * 4, Beatmap.BeatmapInfo.AudioLeadIn)));
+            decoupledClock.ProcessFrame();
+
+            offsetClock = new FramedOffsetClock(decoupledClock);
 
             userAudioOffset = config.GetBindable<double>(OsuConfig.AudioOffset);
             userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
             userAudioOffset.TriggerChange();
 
-            interpolatedSourceClock = new InterpolatingFramedClock(offsetClock);
-
             Schedule(() =>
             {
-                sourceClock.Reset();
+                adjustableSourceClock.Reset();
+
                 foreach (var mod in Beatmap.Mods.Value.OfType<IApplicableToClock>())
-                    mod.ApplyToClock(sourceClock);
+                    mod.ApplyToClock(adjustableSourceClock);
+
+                decoupledClock.ChangeSource(adjustableSourceClock);
             });
 
             scoreProcessor = HitRenderer.CreateScoreProcessor();
@@ -155,7 +165,9 @@ namespace osu.Game.Screens.Play
             hudOverlay.BindHitRenderer(HitRenderer);
 
             hudOverlay.Progress.Objects = HitRenderer.Objects;
-            hudOverlay.Progress.AudioClock = interpolatedSourceClock;
+            hudOverlay.Progress.AudioClock = decoupledClock;
+            hudOverlay.Progress.AllowSeeking = HitRenderer.HasReplayLoaded;
+            hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
 
             //bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
             HitRenderer.OnAllJudged += onCompletion;
@@ -165,16 +177,20 @@ namespace osu.Game.Screens.Play
 
             Children = new Drawable[]
             {
-                new Container
+                hitRendererContainer = new Container
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Clock = interpolatedSourceClock,
                     Children = new Drawable[]
                     {
-                        HitRenderer,
-                        skipButton = new SkipButton
+                        new Container
                         {
-                            Alpha = 0
+                            RelativeSizeAxes = Axes.Both,
+                            Clock = offsetClock,
+                            Children = new Drawable[]
+                            {
+                                HitRenderer,
+                                skipButton = new SkipButton { Alpha = 0 },
+                            }
                         },
                     }
                 },
@@ -224,7 +240,7 @@ namespace osu.Game.Screens.Play
 
             skipButton.Action = () =>
             {
-                sourceClock.Seek(firstHitObject - skip_required_cutoff - fade_time);
+                decoupledClock.Seek(firstHitObject - skip_required_cutoff - fade_time);
                 skipButton.Action = null;
             };
 
@@ -241,7 +257,7 @@ namespace osu.Game.Screens.Play
             // we want to wait for the source clock to stop so we can be sure all components are in a stable state.
             if (!IsPaused)
             {
-                sourceClock.Stop();
+                decoupledClock.Stop();
 
                 Schedule(() => Pause(force));
                 return;
@@ -268,7 +284,7 @@ namespace osu.Game.Screens.Play
             hudOverlay.KeyCounter.IsCounting = true;
             hudOverlay.Progress.Hide();
             pauseOverlay.Hide();
-            sourceClock.Start();
+            decoupledClock.Start();
         }
 
         public void Restart()
@@ -304,7 +320,7 @@ namespace osu.Game.Screens.Play
 
         private void onFail()
         {
-            sourceClock.Stop();
+            decoupledClock.Stop();
 
             HasFailed = true;
             failOverlay.Retries = RestartCount;
@@ -316,11 +332,11 @@ namespace osu.Game.Screens.Play
             base.OnEntering(last);
 
             (Background as BackgroundScreenBeatmap)?.BlurTo(Vector2.Zero, 1500, EasingTypes.OutQuint);
-            Background?.FadeTo((100f - dimLevel) / 100, 1500, EasingTypes.OutQuint);
+            Background?.FadeTo(1 - (float)dimLevel, 1500, EasingTypes.OutQuint);
 
             Content.Alpha = 0;
 
-            dimLevel.ValueChanged += newDim => Background?.FadeTo((100f - newDim) / 100, 800);
+            dimLevel.ValueChanged += newDim => Background?.FadeTo(1 - (float)newDim, 800);
 
             Content.ScaleTo(0.7f);
 
@@ -332,13 +348,12 @@ namespace osu.Game.Screens.Play
             Delay(750);
             Schedule(() =>
             {
-                sourceClock.Start();
+                decoupledClock.Start();
                 initializeSkipButton();
             });
 
-            //keep in mind this is using the interpolatedSourceClock so won't be run as early as we may expect.
-            HitRenderer.Alpha = 0;
-            HitRenderer.FadeIn(750, EasingTypes.OutQuint);
+            hitRendererContainer.Alpha = 0;
+            hitRendererContainer.FadeIn(750, EasingTypes.OutQuint);
         }
 
         protected override void OnSuspending(Screen next)

osu.Game/Screens/Play/PlayerInputManager.cs

@@ -1,8 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using OpenTK.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Input;
 using osu.Framework.Timing;
+using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 
 namespace osu.Game.Screens.Play
@@ -15,7 +19,10 @@ namespace osu.Game.Screens.Play
         private ReplayInputHandler replayInputHandler;
         public ReplayInputHandler ReplayInputHandler
         {
-            get { return replayInputHandler; }
+            get
+            {
+                return replayInputHandler;
+            }
             set
             {
                 if (replayInputHandler != null) RemoveHandler(replayInputHandler);
@@ -28,6 +35,14 @@ namespace osu.Game.Screens.Play
             }
         }
 
+        private Bindable<bool> mouseDisabled;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            mouseDisabled = config.GetBindable<bool>(OsuConfig.MouseDisableButtons);
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -36,36 +51,83 @@ namespace osu.Game.Screens.Play
             Clock = new FramedClock(clock);
         }
 
+        /// <summary>
+        /// Whether we running up-to-date with our parent clock.
+        /// If not, we will need to keep processing children until we catch up.
+        /// </summary>
+        private bool requireMoreUpdateLoops;
+
+        /// <summary>
+        /// Whether we in a valid state (ie. should we keep processing children frames).
+        /// This should be set to false when the replay is, for instance, waiting for future frames to arrive.
+        /// </summary>
+        private bool validState;
+
+        protected override bool RequiresChildrenUpdate => base.RequiresChildrenUpdate && validState;
+
+        private bool isAttached => replayInputHandler != null && !UseParentState;
+
+        private const int max_catch_up_updates_per_frame = 50;
+
+        public override bool UpdateSubTree()
+        {
+            requireMoreUpdateLoops = true;
+            validState = true;
+
+            int loops = 0;
+
+            while (validState && requireMoreUpdateLoops && loops++ < max_catch_up_updates_per_frame)
+                if (!base.UpdateSubTree())
+                    return false;
+
+            return true;
+        }
+
         protected override void Update()
         {
-            base.Update();
-
             if (parentClock == null) return;
 
             clock.Rate = parentClock.Rate;
             clock.IsRunning = parentClock.IsRunning;
 
-            //if a replayHandler is not attached, we should just pass-through.
-            if (UseParentState || replayInputHandler == null)
+            if (!isAttached)
             {
                 clock.CurrentTime = parentClock.CurrentTime;
-                base.Update();
-                return;
             }
-
-            while (true)
+            else
             {
                 double? newTime = replayInputHandler.SetFrameFromTime(parentClock.CurrentTime);
 
                 if (newTime == null)
-                    //we shouldn't execute for this time value
-                    break;
-
-                if (clock.CurrentTime == parentClock.CurrentTime)
-                    break;
+                {
+                    // we shouldn't execute for this time value. probably waiting on more replay data.
+                    validState = false;
+                    return;
+                }
 
                 clock.CurrentTime = newTime.Value;
-                base.Update();
+            }
+
+            requireMoreUpdateLoops = clock.CurrentTime != parentClock.CurrentTime;
+            base.Update();
+        }
+
+        protected override void TransformState(InputState state)
+        {
+            base.TransformState(state);
+
+            // we don't want to transform the state if a replay is present (for now, at least).
+            if (replayInputHandler != null) return;
+
+            var mouse = state.Mouse as Framework.Input.MouseState;
+
+            if (mouse != null)
+            {
+                if (mouseDisabled.Value)
+                {
+                    mouse.SetPressed(MouseButton.Left, false);
+                    mouse.SetPressed(MouseButton.Right, false);
+                }
             }
         }
     }

osu.Game/Screens/Play/SongProgress.cs

@@ -35,6 +35,8 @@ namespace osu.Game.Screens.Play
 
         private double lastHitTime => ((objects.Last() as IHasEndTime)?.EndTime ?? objects.Last().StartTime) + 1;
 
+        private double firstHitTime => objects.First().StartTime;
+
         private IEnumerable<HitObject> objects;
 
         public IEnumerable<HitObject> Objects
@@ -75,7 +77,7 @@ namespace osu.Game.Screens.Play
                     Origin =  Anchor.BottomLeft,
                     SeekRequested = delegate (float position)
                     {
-                        OnSeek?.Invoke(position);
+                        OnSeek?.Invoke(firstHitTime + position * (lastHitTime - firstHitTime));
                     },
                 },
             };
@@ -86,18 +88,28 @@ namespace osu.Game.Screens.Play
             State = Visibility.Visible;
         }
 
-        private bool barVisible;
+        private bool allowSeeking;
 
-        public void ToggleBar()
+        public bool AllowSeeking
         {
-            barVisible = !barVisible;
-            updateBarVisibility();
+            get
+            {
+                return allowSeeking;
+            }
+
+            set
+            {
+                if (allowSeeking == value) return;
+
+                allowSeeking = value;
+                updateBarVisibility();
+            }
         }
 
         private void updateBarVisibility()
         {
-            bar.FadeTo(barVisible ? 1 : 0, transition_duration, EasingTypes.In);
-            MoveTo(new Vector2(0, barVisible ? 0 : bottom_bar_height), transition_duration, EasingTypes.In);
+            bar.FadeTo(allowSeeking ? 1 : 0, transition_duration, EasingTypes.In);
+            MoveTo(new Vector2(0, allowSeeking ? 0 : bottom_bar_height), transition_duration, EasingTypes.In);
         }
 
         protected override void PopIn()
@@ -118,7 +130,7 @@ namespace osu.Game.Screens.Play
             if (objects == null)
                 return;
 
-            double progress = (AudioClock?.CurrentTime ?? Time.Current) / lastHitTime;
+            double progress = ((AudioClock?.CurrentTime ?? Time.Current) - firstHitTime) / lastHitTime;
 
             bar.UpdatePosition((float)progress);
             graph.Progress = (int)(graph.ColumnCount * progress);

osu.Game/Screens/Select/BeatmapDetailArea.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Screens.Select
             {
                 beatmap = value;
                 Leaderboard.Beatmap = beatmap?.BeatmapInfo;
-                Details.Beatmap = beatmap?.Beatmap.BeatmapInfo;
+                Details.Beatmap = beatmap?.BeatmapInfo;
             }
         }
 
@@ -66,16 +66,16 @@ namespace osu.Game.Screens.Select
             {
                 Details = new BeatmapDetails
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding(5),
+                    RelativeSizeAxes = Axes.X,
+                    Masking = true,
+                    Height = 352,
                     Alpha = 0,
                 },
                 Leaderboard = new Leaderboard
                 {
                     RelativeSizeAxes = Axes.Both,
-
                 }
             });
         }
     }
-}
+}

osu.Game/Screens/Select/BeatmapDetailAreaTabControl.cs

@@ -4,10 +4,12 @@
 using System;
 using OpenTK.Graphics;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 
@@ -21,15 +23,22 @@ namespace osu.Game.Screens.Select
 
         public Action<BeatmapDetailTab, bool> OnFilter; //passed the selected tab and if mods is checked
 
+        private Bindable<BeatmapDetailTab> selectedTab;
+
         private void invokeOnFilter()
         {
             OnFilter?.Invoke(tabs.Current, modsCheckbox.Current);
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colour)
+        private void load(OsuColour colour, OsuConfigManager config)
         {
             modsCheckbox.AccentColour = tabs.AccentColour = colour.YellowLight;
+
+            selectedTab = config.GetBindable<BeatmapDetailTab>(OsuConfig.BeatmapDetailTab);
+
+            tabs.Current.BindTo(selectedTab);
+            tabs.Current.TriggerChange();
         }
 
         public BeatmapDetailAreaTabControl()
@@ -62,8 +71,6 @@ namespace osu.Game.Screens.Select
 
             tabs.Current.ValueChanged += item => invokeOnFilter();
             modsCheckbox.Current.ValueChanged += item => invokeOnFilter();
-
-            tabs.Current.Value = BeatmapDetailTab.Global;
         }
     }
 

osu.Game/Screens/Select/BeatmapDetails.cs

@@ -14,6 +14,9 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using System.Globalization;
 using System.Linq;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Framework.Threading;
 
 namespace osu.Game.Screens.Select
 {
@@ -39,60 +42,108 @@ namespace osu.Game.Screens.Select
         private readonly BarGraph retryGraph;
         private readonly BarGraph failGraph;
 
+        private ScheduledDelegate pendingBeatmapSwitch;
         private BeatmapInfo beatmap;
+
         public BeatmapInfo Beatmap
         {
-            get
-            {
-                return beatmap;
-            }
+            get { return beatmap; }
             set
             {
                 beatmap = value;
-                if (beatmap == null) return;
 
-                description.Text = beatmap.Version;
-                source.Text = beatmap.Metadata.Source;
-                tags.Text = beatmap.Metadata.Tags;
-
-                circleSize.Value = beatmap.Difficulty.CircleSize;
-                drainRate.Value = beatmap.Difficulty.DrainRate;
-                overallDifficulty.Value = beatmap.Difficulty.OverallDifficulty;
-                approachRate.Value = beatmap.Difficulty.ApproachRate;
-                stars.Value = (float)beatmap.StarDifficulty;
-
-                if (beatmap.Metrics?.Ratings.Any() ?? false)
-                {
-                    var ratings = beatmap.Metrics.Ratings.ToList();
-                    ratingsContainer.Show();
-
-                    negativeRatings.Text = ratings.GetRange(0, ratings.Count / 2).Sum().ToString();
-                    positiveRatings.Text = ratings.GetRange(ratings.Count / 2, ratings.Count / 2).Sum().ToString();
-                    ratingsBar.Length = (float)ratings.GetRange(0, ratings.Count / 2).Sum() / ratings.Sum();
-
-                    ratingsGraph.Values = ratings.Select(rating => (float)rating);
-                }
-                else
-                    ratingsContainer.Hide();
-
-                if ((beatmap.Metrics?.Retries.Any() ?? false) && beatmap.Metrics.Fails.Any())
-                {
-                    var retries = beatmap.Metrics.Retries;
-                    var fails = beatmap.Metrics.Fails;
-                    retryFailContainer.Show();
-
-                    float maxValue = fails.Zip(retries, (fail, retry) => fail + retry).Max();
-                    failGraph.MaxValue = maxValue;
-                    retryGraph.MaxValue = maxValue;
-
-                    failGraph.Values = fails.Select(fail => (float)fail);
-                    retryGraph.Values = retries.Zip(fails, (retry, fail) => retry + MathHelper.Clamp(fail, 0, maxValue));
-                }
-                else
-                    retryFailContainer.Hide();
+                pendingBeatmapSwitch?.Cancel();
+                pendingBeatmapSwitch = Schedule(updateStats);
             }
         }
 
+        private void updateStats()
+        {
+            if (beatmap == null) return;
+
+            description.Text = beatmap.Version;
+            source.Text = beatmap.Metadata.Source;
+            tags.Text = beatmap.Metadata.Tags;
+
+            circleSize.Value = beatmap.Difficulty.CircleSize;
+            drainRate.Value = beatmap.Difficulty.DrainRate;
+            overallDifficulty.Value = beatmap.Difficulty.OverallDifficulty;
+            approachRate.Value = beatmap.Difficulty.ApproachRate;
+            stars.Value = (float)beatmap.StarDifficulty;
+
+            var requestedBeatmap = beatmap;
+            if (requestedBeatmap.Metrics == null)
+            {
+                var lookup = new GetBeatmapDetailsRequest(requestedBeatmap);
+                lookup.Success += res =>
+                {
+                    if (beatmap != requestedBeatmap)
+                            //the beatmap has been changed since we started the lookup.
+                            return;
+
+                    requestedBeatmap.Metrics = res;
+                    Schedule(() => updateMetrics(res));
+                };
+                lookup.Failure += e => updateMetrics(null);
+
+                api.Queue(lookup);
+            }
+
+            updateMetrics(requestedBeatmap.Metrics, false);
+        }
+
+        /// <summary>
+        /// Update displayed metrics.
+        /// </summary>
+        /// <param name="metrics">New metrics to overwrite the existing display. Can be null.</param>
+        /// <param name="failOnMissing">Whether to hide the display on null or empty metrics. If false, we will dim as if waiting for further updates.</param>
+        private void updateMetrics(BeatmapMetrics metrics, bool failOnMissing = true)
+        {
+            var hasRatings = metrics?.Ratings.Any() ?? false;
+            var hasRetriesFails = (metrics?.Retries.Any() ?? false) && metrics.Fails.Any();
+
+            if (hasRatings)
+            {
+                var ratings = metrics.Ratings.ToList();
+                ratingsContainer.Show();
+
+                negativeRatings.Text = ratings.GetRange(0, ratings.Count / 2).Sum().ToString();
+                positiveRatings.Text = ratings.GetRange(ratings.Count / 2, ratings.Count / 2).Sum().ToString();
+                ratingsBar.Length = (float)ratings.GetRange(0, ratings.Count / 2).Sum() / ratings.Sum();
+
+                ratingsGraph.Values = ratings.Select(rating => (float)rating);
+
+                ratingsContainer.FadeColour(Color4.White, 500, EasingTypes.Out);
+            }
+            else if (failOnMissing)
+                ratingsGraph.Values = new float[10];
+            else
+                ratingsContainer.FadeColour(Color4.Gray, 500, EasingTypes.Out);
+
+            if (hasRetriesFails)
+            {
+                var retries = metrics.Retries;
+                var fails = metrics.Fails;
+                retryFailContainer.Show();
+
+                float maxValue = fails.Zip(retries, (fail, retry) => fail + retry).Max();
+                failGraph.MaxValue = maxValue;
+                retryGraph.MaxValue = maxValue;
+
+                failGraph.Values = fails.Select(fail => (float)fail);
+                retryGraph.Values = retries.Zip(fails, (retry, fail) => retry + MathHelper.Clamp(fail, 0, maxValue));
+
+                retryFailContainer.FadeColour(Color4.White, 500, EasingTypes.Out);
+            }
+            else if (failOnMissing)
+            {
+                failGraph.Values = new float[100];
+                retryGraph.Values = new float[100];
+            }
+            else
+                retryFailContainer.FadeColour(Color4.Gray, 500, EasingTypes.Out);
+        }
+
         public BeatmapDetails()
         {
             Children = new Drawable[]
@@ -113,7 +164,6 @@ namespace osu.Game.Screens.Select
                     Direction = FillDirection.Vertical,
                     LayoutDuration = 200,
                     LayoutEasing = EasingTypes.OutQuint,
-                    Padding = new MarginPadding(10) { Top = 25 },
                     Children = new []
                     {
                         description = new MetadataSegment("Description"),
@@ -148,8 +198,8 @@ namespace osu.Game.Screens.Select
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
                                     Direction = FillDirection.Vertical,
-                                    Spacing = new Vector2(0,10),
-                                    Padding = new MarginPadding(15) { Top = 25 },
+                                    Spacing = new Vector2(0,5),
+                                    Padding = new MarginPadding(10),
                                     Children = new []
                                     {
                                         circleSize = new DifficultyRow("Circle Size", 7),
@@ -252,7 +302,7 @@ namespace osu.Game.Screens.Select
                                 new Container<BarGraph>
                                 {
                                     RelativeSizeAxes = Axes.X,
-                                    Size = new Vector2(1/0.6f, 50),
+                                    Size = new Vector2(1 / 0.6f, 50),
                                     Children = new[]
                                     {
                                         retryGraph = new BarGraph
@@ -272,9 +322,13 @@ namespace osu.Game.Screens.Select
             };
         }
 
+        private APIAccess api;
+
         [BackgroundDependencyLoader]
-        private void load(OsuColour colour)
+        private void load(OsuColour colour, APIAccess api)
         {
+            this.api = api;
+
             description.AccentColour = colour.GrayB;
             source.AccentColour = colour.GrayB;
             tags.AccentColour = colour.YellowLight;
@@ -308,7 +362,7 @@ namespace osu.Game.Screens.Select
                 {
                     difficultyValue = value;
                     bar.Length = value / maxValue;
-                    valueText.Text = value.ToString(CultureInfo.InvariantCulture);
+                    valueText.Text = value.ToString("N1", CultureInfo.CurrentCulture);
                 }
             }
 
@@ -431,4 +485,4 @@ namespace osu.Game.Screens.Select
             }
         }
     }
-}
+}

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using OpenTK;
 using OpenTK.Graphics;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -148,11 +149,16 @@ namespace osu.Game.Screens.Select
                                 },
                             },
                         },
-                        // Text for beatmap info
+                        new DifficultyColourBar(beatmap.BeatmapInfo)
+                        {
+                            RelativeSizeAxes = Axes.Y,
+                            Width = 20,
+                        },
                         new FillFlowContainer
                         {
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomLeft,
+                            Name = "Top-aligned metadata",
+                            Anchor = Anchor.TopLeft,
+                            Origin = Anchor.TopLeft,
                             Direction = FillDirection.Vertical,
                             Margin = new MarginPadding { Top = 10, Left = 25, Right = 10, Bottom = 20 },
                             AutoSizeAxes = Axes.Both,
@@ -161,16 +167,32 @@ namespace osu.Game.Screens.Select
                                 new OsuSpriteText
                                 {
                                     Font = @"Exo2.0-MediumItalic",
-                                    Text = metadata.Artist + " -- " + metadata.Title,
+                                    Text = beatmapInfo.Version,
+                                    TextSize = 24,
+                                },
+                            }
+                        },
+                        new FillFlowContainer
+                        {
+                            Name = "Bottom-aligned metadata",
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            Direction = FillDirection.Vertical,
+                            Margin = new MarginPadding { Top = 15, Left = 25, Right = 10, Bottom = 20 },
+                            AutoSizeAxes = Axes.Both,
+                            Children = new Drawable[]
+                            {
+                                new OsuSpriteText
+                                {
+                                    Font = @"Exo2.0-MediumItalic",
+                                    Text = !string.IsNullOrEmpty(metadata.Source) ? metadata.Source + " — " + metadata.Title : metadata.Title,
                                     TextSize = 28,
-                                    Shadow = true,
                                 },
                                 new OsuSpriteText
                                 {
                                     Font = @"Exo2.0-MediumItalic",
-                                    Text = beatmapInfo.Version,
+                                    Text = metadata.Artist,
                                     TextSize = 17,
-                                    Shadow = true,
                                 },
                                 new FillFlowContainer
                                 {
@@ -184,20 +206,18 @@ namespace osu.Game.Screens.Select
                                             Font = @"Exo2.0-Medium",
                                             Text = "mapped by ",
                                             TextSize = 15,
-                                            Shadow = true,
-                                        },
+                                         },
                                         new OsuSpriteText
                                         {
                                             Font = @"Exo2.0-Bold",
                                             Text = metadata.Author,
                                             TextSize = 15,
-                                            Shadow = true,
-                                        },
+                                         },
                                     }
                                 },
                                 new FillFlowContainer
                                 {
-                                    Margin = new MarginPadding { Top = 20 },
+                                    Margin = new MarginPadding { Top = 20, Left = 10 },
                                     Spacing = new Vector2(40, 0),
                                     AutoSizeAxes = Axes.Both,
                                     Children = labels
@@ -256,5 +276,37 @@ namespace osu.Game.Screens.Select
                 };
             }
         }
+
+        private class DifficultyColourBar : DifficultyColouredContainer
+        {
+            public DifficultyColourBar(BeatmapInfo beatmap) : base(beatmap)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                const float full_opacity_ratio = 0.7f;
+
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = AccentColour,
+                        Width = full_opacity_ratio,
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        RelativePositionAxes = Axes.Both,
+                        Colour = AccentColour,
+                        Alpha = 0.5f,
+                        X = full_opacity_ratio,
+                        Width = 1 - full_opacity_ratio,
+                    }
+                };
+            }
+        }
     }
 }

osu.Game/Screens/Select/Leaderboards/Leaderboard.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Threading;
 using osu.Game.Database;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Online.API;
@@ -93,13 +94,18 @@ namespace osu.Game.Screens.Select.Leaderboards
 
         private BeatmapInfo beatmap;
 
+        private ScheduledDelegate pendingBeatmapSwitch;
+
         public BeatmapInfo Beatmap
         {
             get { return beatmap; }
             set
             {
                 beatmap = value;
-                Schedule(updateScores);
+                Scores = null;
+
+                pendingBeatmapSwitch?.Cancel();
+                pendingBeatmapSwitch = Schedule(updateScores);
             }
         }
 

osu.Game/osu.Game.csproj

@@ -71,6 +71,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Audio\SampleInfo.cs" />
+    <Compile Include="Audio\SampleInfoList.cs" />
     <Compile Include="Beatmaps\Drawables\BeatmapBackgroundSprite.cs" />
     <Compile Include="Beatmaps\DifficultyCalculator.cs" />
     <Compile Include="Online\API\Requests\PostMessageRequest.cs" />
@@ -109,6 +110,20 @@
     <Compile Include="IO\Serialization\IJsonSerializable.cs" />
     <Compile Include="IPC\ScoreIPCChannel.cs" />
     <Compile Include="Rulesets\BeatmapStatistic.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Catch\ConvertHit.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Catch\ConvertHitObjectParser.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Catch\ConvertSlider.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Catch\ConvertSpinner.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\ConvertSlider.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Mania\ConvertHit.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Mania\ConvertHitObjectParser.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Mania\ConvertSlider.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Mania\ConvertSpinner.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Osu\ConvertHitObjectParser.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Taiko\ConvertHit.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Taiko\ConvertHitObjectParser.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Taiko\ConvertSlider.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Taiko\ConvertSpinner.cs" />
     <Compile Include="Rulesets\Mods\IApplicableToClock.cs" />
     <Compile Include="Rulesets\Mods\ModAutoplay.cs" />
     <Compile Include="Rulesets\Mods\ModCinema.cs" />
@@ -124,19 +139,6 @@
     <Compile Include="Rulesets\Mods\ModRelax.cs" />
     <Compile Include="Rulesets\Mods\ModSuddenDeath.cs" />
     <Compile Include="Rulesets\Mods\MultiMod.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Catch\Hit.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Catch\HitObjectParser.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Catch\Slider.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Catch\Spinner.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Mania\Hit.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Mania\HitObjectParser.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Mania\Slider.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Mania\Spinner.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Osu\HitObjectParser.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Taiko\Hit.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Taiko\HitObjectParser.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Taiko\Slider.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Taiko\Spinner.cs" />
     <Compile Include="Rulesets\Objects\Types\IHasXPosition.cs" />
     <Compile Include="Rulesets\Objects\Types\IHasYPosition.cs" />
     <Compile Include="Rulesets\Replays\Replay.cs" />
@@ -149,12 +151,11 @@
     <Compile Include="Rulesets\Objects\Drawables\HitResult.cs" />
     <Compile Include="Rulesets\Objects\BezierApproximator.cs" />
     <Compile Include="Rulesets\Objects\CircularArcApproximator.cs" />
-    <Compile Include="Rulesets\Objects\CurvedHitObject.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Osu\Hit.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\HitObjectParser.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Hold.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Osu\Slider.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\Osu\Spinner.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Osu\ConvertHit.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\ConvertHitObjectParser.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\ConvertHold.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Osu\ConvertSlider.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\Osu\ConvertSpinner.cs" />
     <Compile Include="Rulesets\Objects\SliderCurve.cs" />
     <Compile Include="Rulesets\Objects\Types\CurveType.cs" />
     <Compile Include="Rulesets\Objects\Drawables\IDrawableHitObjectWithProxiedApproach.cs" />
@@ -167,7 +168,7 @@
     <Compile Include="Rulesets\Objects\Types\IHasRepeats.cs" />
     <Compile Include="Rulesets\Objects\Types\IHasPosition.cs" />
     <Compile Include="Rulesets\Objects\Types\IHasHold.cs" />
-    <Compile Include="Rulesets\Objects\Legacy\HitObjectType.cs" />
+    <Compile Include="Rulesets\Objects\Legacy\ConvertHitObjectType.cs" />
     <Compile Include="Rulesets\Replays\ReplayButtonState.cs" />
     <Compile Include="Rulesets\Replays\ReplayFrame.cs" />
     <Compile Include="Database\RulesetDatabase.cs" />
@@ -179,6 +180,7 @@
     <Compile Include="Rulesets\UI\StandardHudOverlay.cs" />
     <Compile Include="Online\API\IOnlineComponent.cs" />
     <Compile Include="Online\API\Requests\GetScoresRequest.cs" />
+    <Compile Include="Online\API\Requests\GetBeatmapDetailsRequest.cs" />
     <Compile Include="Online\API\Requests\GetUserRequest.cs" />
     <Compile Include="Overlays\DragBar.cs" />
     <Compile Include="Overlays\LoginOverlay.cs" />
@@ -187,6 +189,7 @@
     <Compile Include="Beatmaps\WorkingBeatmap.cs" />
     <Compile Include="Beatmaps\Drawables\BeatmapSetHeader.cs" />
     <Compile Include="Beatmaps\Drawables\DifficultyIcon.cs" />
+    <Compile Include="Beatmaps\Drawables\DifficultyColouredContainer.cs" />
     <Compile Include="Beatmaps\Drawables\Panel.cs" />
     <Compile Include="Rulesets\Objects\Drawables\DrawableHitObject.cs" />
     <Compile Include="Rulesets\Objects\HitObject.cs" />