Mode -> Ruleset.

osu.Game/Rulesets/Objects/BezierApproximator.cs

@@ -0,0 +1,150 @@
+// 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;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Objects
+{
+    public class BezierApproximator
+    {
+        private readonly int count;
+        private readonly List<Vector2> controlPoints;
+        private readonly Vector2[] subdivisionBuffer1;
+        private readonly Vector2[] subdivisionBuffer2;
+
+        private const float tolerance = 0.25f;
+        private const float tolerance_sq = tolerance * tolerance;
+
+        public BezierApproximator(List<Vector2> controlPoints)
+        {
+            this.controlPoints = controlPoints;
+            count = controlPoints.Count;
+
+            subdivisionBuffer1 = new Vector2[count];
+            subdivisionBuffer2 = new Vector2[count * 2 - 1];
+        }
+
+        /// <summary>
+        /// Make sure the 2nd order derivative (approximated using finite elements) is within tolerable bounds.
+        /// NOTE: The 2nd order derivative of a 2d curve represents its curvature, so intuitively this function
+        ///       checks (as the name suggests) whether our approximation is _locally_ "flat". More curvy parts
+        ///       need to have a denser approximation to be more "flat".
+        /// </summary>
+        /// <param name="controlPoints">The control points to check for flatness.</param>
+        /// <returns>Whether the control points are flat enough.</returns>
+        private static bool isFlatEnough(Vector2[] controlPoints)
+        {
+            for (int i = 1; i < controlPoints.Length - 1; i++)
+                if ((controlPoints[i - 1] - 2 * controlPoints[i] + controlPoints[i + 1]).LengthSquared > tolerance_sq * 4)
+                    return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Subdivides n control points representing a bezier curve into 2 sets of n control points, each
+        /// describing a bezier curve equivalent to a half of the original curve. Effectively this splits
+        /// the original curve into 2 curves which result in the original curve when pieced back together.
+        /// </summary>
+        /// <param name="controlPoints">The control points to split.</param>
+        /// <param name="l">Output: The control points corresponding to the left half of the curve.</param>
+        /// <param name="r">Output: The control points corresponding to the right half of the curve.</param>
+        private void subdivide(Vector2[] controlPoints, Vector2[] l, Vector2[] r)
+        {
+            Vector2[] midpoints = subdivisionBuffer1;
+
+            for (int i = 0; i < count; ++i)
+                midpoints[i] = controlPoints[i];
+
+            for (int i = 0; i < count; i++)
+            {
+                l[i] = midpoints[0];
+                r[count - i - 1] = midpoints[count - i - 1];
+
+                for (int j = 0; j < count - i - 1; j++)
+                    midpoints[j] = (midpoints[j] + midpoints[j + 1]) / 2;
+            }
+        }
+
+        /// <summary>
+        /// This uses <a href="https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm">De Casteljau's algorithm</a> to obtain an optimal
+        /// piecewise-linear approximation of the bezier curve with the same amount of points as there are control points.
+        /// </summary>
+        /// <param name="controlPoints">The control points describing the bezier curve to be approximated.</param>
+        /// <param name="output">The points representing the resulting piecewise-linear approximation.</param>
+        private void approximate(Vector2[] controlPoints, List<Vector2> output)
+        {
+            Vector2[] l = subdivisionBuffer2;
+            Vector2[] r = subdivisionBuffer1;
+
+            subdivide(controlPoints, l, r);
+
+            for (int i = 0; i < count - 1; ++i)
+                l[count + i] = r[i + 1];
+
+            output.Add(controlPoints[0]);
+            for (int i = 1; i < count - 1; ++i)
+            {
+                int index = 2 * i;
+                Vector2 p = 0.25f * (l[index - 1] + 2 * l[index] + l[index + 1]);
+                output.Add(p);
+            }
+        }
+
+        /// <summary>
+        /// Creates a piecewise-linear approximation of a bezier curve, by adaptively repeatedly subdividing
+        /// the control points until their approximation error vanishes below a given threshold.
+        /// </summary>
+        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
+        public List<Vector2> CreateBezier()
+        {
+            List<Vector2> output = new List<Vector2>();
+
+            if (count == 0)
+                return output;
+
+            Stack<Vector2[]> toFlatten = new Stack<Vector2[]>();
+            Stack<Vector2[]> freeBuffers = new Stack<Vector2[]>();
+
+            // "toFlatten" contains all the curves which are not yet approximated well enough.
+            // We use a stack to emulate recursion without the risk of running into a stack overflow.
+            // (More specifically, we iteratively and adaptively refine our curve with a
+            // <a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth-first search</a>
+            // over the tree resulting from the subdivisions we make.)
+            toFlatten.Push(controlPoints.ToArray());
+
+            Vector2[] leftChild = subdivisionBuffer2;
+
+            while (toFlatten.Count > 0)
+            {
+                Vector2[] parent = toFlatten.Pop();
+                if (isFlatEnough(parent))
+                {
+                    // If the control points we currently operate on are sufficiently "flat", we use
+                    // an extension to De Casteljau's algorithm to obtain a piecewise-linear approximation
+                    // of the bezier curve represented by our control points, consisting of the same amount
+                    // of points as there are control points.
+                    approximate(parent, output);
+                    freeBuffers.Push(parent);
+                    continue;
+                }
+
+                // If we do not yet have a sufficiently "flat" (in other words, detailed) approximation we keep
+                // subdividing the curve we are currently operating on.
+                Vector2[] rightChild = freeBuffers.Count > 0 ? freeBuffers.Pop() : new Vector2[count];
+                subdivide(parent, leftChild, rightChild);
+
+                // We re-use the buffer of the parent for one of the children, so that we save one allocation per iteration.
+                for (int i = 0; i < count; ++i)
+                    parent[i] = leftChild[i];
+
+                toFlatten.Push(rightChild);
+                toFlatten.Push(parent);
+            }
+
+            output.Add(controlPoints[count - 1]);
+            return output;
+        }
+    }
+}

osu.Game/Rulesets/Objects/CircularArcApproximator.cs

@@ -0,0 +1,99 @@
+// 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;
+using System.Collections.Generic;
+using osu.Framework.MathUtils;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Objects
+{
+    public class CircularArcApproximator
+    {
+        private readonly Vector2 a;
+        private readonly Vector2 b;
+        private readonly Vector2 c;
+
+        private int amountPoints;
+
+        private const float tolerance = 0.1f;
+
+        public CircularArcApproximator(Vector2 a, Vector2 b, Vector2 c)
+        {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+        }
+
+        /// <summary>
+        /// Creates a piecewise-linear approximation of a circular arc curve.
+        /// </summary>
+        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
+        public List<Vector2> CreateArc()
+        {
+            float aSq = (b - c).LengthSquared;
+            float bSq = (a - c).LengthSquared;
+            float cSq = (a - b).LengthSquared;
+
+            // If we have a degenerate triangle where a side-length is almost zero, then give up and fall
+            // back to a more numerically stable method.
+            if (Precision.AlmostEquals(aSq, 0) || Precision.AlmostEquals(bSq, 0) || Precision.AlmostEquals(cSq, 0))
+                return new List<Vector2>();
+
+            float s = aSq * (bSq + cSq - aSq);
+            float t = bSq * (aSq + cSq - bSq);
+            float u = cSq * (aSq + bSq - cSq);
+
+            float sum = s + t + u;
+
+            // If we have a degenerate triangle with an almost-zero size, then give up and fall
+            // back to a more numerically stable method.
+            if (Precision.AlmostEquals(sum, 0))
+                return new List<Vector2>();
+
+            Vector2 centre = (s * a + t * b + u * c) / sum;
+            Vector2 dA = a - centre;
+            Vector2 dC = c - centre;
+
+            float r = dA.Length;
+
+            double thetaStart = Math.Atan2(dA.Y, dA.X);
+            double thetaEnd = Math.Atan2(dC.Y, dC.X);
+
+            while (thetaEnd < thetaStart)
+                thetaEnd += 2 * Math.PI;
+
+            double dir = 1;
+            double thetaRange = thetaEnd - thetaStart;
+
+            // Decide in which direction to draw the circle, depending on which side of
+            // AC B lies.
+            Vector2 orthoAtoC = c - a;
+            orthoAtoC = new Vector2(orthoAtoC.Y, -orthoAtoC.X);
+            if (Vector2.Dot(orthoAtoC, b - a) < 0)
+            {
+                dir = -dir;
+                thetaRange = 2 * Math.PI - thetaRange;
+            }
+
+            // We select the amount of points for the approximation by requiring the discrete curvature
+            // to be smaller than the provided tolerance. The exact angle required to meet the tolerance
+            // is: 2 * Math.Acos(1 - TOLERANCE / r)
+            // The special case is required for extremely short sliders where the radius is smaller than
+            // the tolerance. This is a pathological rather than a realistic case.
+            amountPoints = 2 * r <= tolerance ? 2 : Math.Max(2, (int)Math.Ceiling(thetaRange / (2 * Math.Acos(1 - tolerance / r))));
+
+            List<Vector2> output = new List<Vector2>(amountPoints);
+
+            for (int i = 0; i < amountPoints; ++i)
+            {
+                double fract = (double)i / (amountPoints - 1);
+                double theta = thetaStart + dir * fract * thetaRange;
+                Vector2 o = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta)) * r;
+                output.Add(centre + o);
+            }
+
+            return output;
+        }
+    }
+}

osu.Game/Rulesets/Objects/CurvedHitObject.cs

@@ -0,0 +1,49 @@
+// 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/Drawables/ArmedState.cs

@@ -0,0 +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
+
+namespace osu.Game.Rulesets.Objects.Drawables
+{
+    public enum ArmedState
+    {
+        Idle,
+        Hit,
+        Miss
+    }
+}

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

@@ -0,0 +1,184 @@
+// 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;
+using System.Collections.Generic;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Game.Rulesets.Judgements;
+using Container = osu.Framework.Graphics.Containers.Container;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK.Graphics;
+using osu.Game.Audio;
+
+namespace osu.Game.Rulesets.Objects.Drawables
+{
+    public abstract class DrawableHitObject<TJudgement> : Container, IStateful<ArmedState>
+        where TJudgement : Judgement
+    {
+        public override bool HandleInput => Interactive;
+
+        public bool Interactive = true;
+
+        public TJudgement Judgement;
+
+        protected abstract TJudgement CreateJudgement();
+
+        protected abstract void UpdateState(ArmedState state);
+
+        private ArmedState state;
+        public ArmedState State
+        {
+            get { return state; }
+
+            set
+            {
+                if (state == value)
+                    return;
+                state = value;
+
+                if (!IsLoaded)
+                    return;
+
+                UpdateState(state);
+
+                if (State == ArmedState.Hit)
+                    PlaySamples();
+            }
+        }
+
+        protected List<SampleChannel> Samples = new List<SampleChannel>();
+
+        protected void PlaySamples()
+        {
+            Samples.ForEach(s => s?.Play());
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            //we may be setting a custom judgement in test cases or what not.
+            if (Judgement == null)
+                Judgement = CreateJudgement();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            //force application of the state that was set before we loaded.
+            UpdateState(State);
+        }
+    }
+
+    public abstract class DrawableHitObject<TObject, TJudgement> : DrawableHitObject<TJudgement>
+        where TObject : HitObject
+        where TJudgement : Judgement
+    {
+        public event Action<DrawableHitObject<TObject, TJudgement>> OnJudgement;
+
+        public TObject HitObject;
+
+        /// <summary>
+        /// The colour used for various elements of this DrawableHitObject.
+        /// </summary>
+        public Color4 AccentColour { get; protected set; }
+
+        protected DrawableHitObject(TObject hitObject)
+        {
+            HitObject = hitObject;
+        }
+
+        /// <summary>
+        /// Process a hit of this hitobject. Carries out judgement.
+        /// </summary>
+        /// <returns>Whether a hit was processed.</returns>
+        protected bool UpdateJudgement(bool userTriggered)
+        {
+            IPartialJudgement partial = Judgement as IPartialJudgement;
+
+            // Never re-process non-partial hits
+            if (Judgement.Result != HitResult.None && partial == null)
+                return false;
+
+            // Update the judgement state
+            double endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+            Judgement.TimeOffset = Time.Current - endTime;
+
+            // Update the judgement state
+            bool hadResult = Judgement.Result != HitResult.None;
+            CheckJudgement(userTriggered);
+
+            // Don't process judgements with no result
+            if (Judgement.Result == HitResult.None)
+                return false;
+
+            // Don't process judgements that previously had results but the results were unchanged
+            if (hadResult && partial?.Changed != true)
+                return false;
+
+            switch (Judgement.Result)
+            {
+                default:
+                    State = ArmedState.Hit;
+                    break;
+                case HitResult.Miss:
+                    State = ArmedState.Miss;
+                    break;
+            }
+
+            OnJudgement?.Invoke(this);
+
+            if (partial != null)
+                partial.Changed = false;
+
+            return true;
+        }
+
+        protected virtual void CheckJudgement(bool userTriggered)
+        {
+            if (NestedHitObjects != null)
+            {
+                foreach (var d in NestedHitObjects)
+                    d.CheckJudgement(userTriggered);
+            }
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            UpdateJudgement(false);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            foreach (SampleInfo sample in HitObject.Samples)
+            {
+                SampleChannel channel = audio.Sample.Get($@"Gameplay/{sample.Bank}-{sample.Name}");
+
+                if (channel == null)
+                    continue;
+
+                channel.Volume.Value = sample.Volume;
+                Samples.Add(channel);
+            }
+        }
+
+        private List<DrawableHitObject<TObject, TJudgement>> nestedHitObjects;
+
+        protected IEnumerable<DrawableHitObject<TObject, TJudgement>> NestedHitObjects => nestedHitObjects;
+
+        protected void AddNested(DrawableHitObject<TObject, TJudgement> h)
+        {
+            if (nestedHitObjects == null)
+                nestedHitObjects = new List<DrawableHitObject<TObject, TJudgement>>();
+
+            h.OnJudgement += d => OnJudgement?.Invoke(d);
+            nestedHitObjects.Add(h);
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+// 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.ComponentModel;
+
+namespace osu.Game.Rulesets.Objects.Drawables
+{
+    public enum HitResult
+    {
+        /// <summary>
+        /// Indicates that the object has not been judged yet.
+        /// </summary>
+        [Description("")]
+        None,
+        /// <summary>
+        /// Indicates that the object has been judged as a miss.
+        /// </summary>
+        [Description(@"Miss")]
+        Miss,
+        /// <summary>
+        /// Indicates that the object has been judged as a hit.
+        /// </summary>
+        [Description(@"Hit")]
+        Hit,
+    }
+}

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

@@ -0,0 +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 osu.Framework.Graphics;
+
+namespace osu.Game.Rulesets.Objects.Drawables
+{
+    public interface IDrawableHitObjectWithProxiedApproach
+    {
+        Drawable ProxiedLayer { get; }
+    }
+}

osu.Game/Rulesets/Objects/HitObject.cs

@@ -0,0 +1,52 @@
+// 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 osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Objects
+{
+    /// <summary>
+    /// A HitObject describes an object in a Beatmap.
+    /// <para>
+    /// HitObjects may contain more properties for which you should be checking through the IHas* types.
+    /// </para>
+    /// </summary>
+    public class HitObject
+    {
+        /// <summary>
+        /// The time at which the HitObject starts.
+        /// </summary>
+        public double StartTime { get; set; }
+
+        /// <summary>
+        /// The samples to be played when this hit object is hit.
+        /// </summary>
+        public List<SampleInfo> Samples = new List<SampleInfo>();
+
+        /// <summary>
+        /// Applies default values to this HitObject.
+        /// </summary>
+        /// <param name="difficulty">The difficulty settings to use.</param>
+        /// <param name="timing">The timing settings to use.</param>
+        public virtual void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            ControlPoint overridePoint;
+            ControlPoint timingPoint = timing.TimingPointAt(StartTime, out overridePoint);
+
+            foreach (var sample in Samples)
+            {
+                if (sample.Volume == 0)
+                    sample.Volume = (overridePoint ?? timingPoint)?.SampleVolume ?? 0;
+
+                // If the bank is not assigned a name, assign it from the control point
+                if (!string.IsNullOrEmpty(sample.Bank))
+                    continue;
+
+                sample.Bank = (overridePoint ?? timingPoint)?.SampleBank ?? @"normal";
+            }
+        }
+    }
+}

osu.Game/Rulesets/Objects/HitObjectParser.cs

@@ -0,0 +1,10 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Objects
+{
+    public abstract class HitObjectParser
+    {
+        public abstract HitObject Parse(string text);
+    }
+}

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

@@ -0,0 +1,17 @@
+// 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;
+
+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
+    {
+        public float X { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}

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

@@ -0,0 +1,45 @@
+// 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.Legacy.Catch
+{
+    /// <summary>
+    /// A HitObjectParser to parse legacy osu!catch Beatmaps.
+    /// </summary>
+    internal class HitObjectParser : Legacy.HitObjectParser
+    {
+        protected override HitObject CreateHit(Vector2 position, bool newCombo)
+        {
+            return new Hit
+            {
+                X = position.X,
+                NewCombo = newCombo,
+            };
+        }
+
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        {
+            return new Slider
+            {
+                X = position.X,
+                NewCombo = newCombo,
+                ControlPoints = controlPoints,
+                Distance = length,
+                CurveType = curveType,
+                RepeatCount = repeatCount
+            };
+        }
+
+        protected override HitObject CreateSpinner(Vector2 position, double endTime)
+        {
+            return new Spinner
+            {
+                EndTime = endTime
+            };
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+// 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;
+
+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
+    {
+        public float X { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}

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

@@ -0,0 +1,17 @@
+// 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;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Catch
+{
+    /// <summary>
+    /// Legacy osu!catch Spinner-type, used for parsing Beatmaps.
+    /// </summary>
+    internal sealed class Spinner : HitObject, IHasEndTime
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+    }
+}

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

@@ -0,0 +1,215 @@
+// 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;
+using System.Collections.Generic;
+using System.Globalization;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.Audio;
+
+namespace osu.Game.Rulesets.Objects.Legacy
+{
+    /// <summary>
+    /// A HitObjectParser to parse legacy Beatmaps.
+    /// </summary>
+    internal abstract class HitObjectParser : Objects.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;
+
+            int sampleVolume = 0;
+            string normalSampleBank = null;
+            string addSampleBank = null;
+
+            HitObject result;
+
+            if ((type & HitObjectType.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);
+            }
+            else if ((type & HitObjectType.Slider) > 0)
+            {
+                CurveType curveType = CurveType.Catmull;
+                double length = 0;
+                var points = new List<Vector2> { new Vector2(int.Parse(split[0]), int.Parse(split[1])) };
+
+                string[] pointsplit = split[5].Split('|');
+                foreach (string t in pointsplit)
+                {
+                    if (t.Length == 1)
+                    {
+                        switch (t)
+                        {
+                            case @"C":
+                                curveType = CurveType.Catmull;
+                                break;
+                            case @"B":
+                                curveType = CurveType.Bezier;
+                                break;
+                            case @"L":
+                                curveType = CurveType.Linear;
+                                break;
+                            case @"P":
+                                curveType = CurveType.PerfectCurve;
+                                break;
+                        }
+                        continue;
+                    }
+
+                    string[] temp = t.Split(':');
+                    points.Add(new Vector2((int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture), (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)));
+                }
+
+                int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
+
+                if (repeatCount > 9000)
+                    throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
+
+                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);
+            }
+            else if ((type & HitObjectType.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);
+            }
+            else if ((type & HitObjectType.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
+                {
+                    Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
+                    NewCombo = combo
+                };
+            }
+            else
+                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
+                });
+            }
+
+            return result;
+        }
+
+        private void readCustomSampleBanks(string str, ref string normalSampleBank, ref string addSampleBank, ref int sampleVolume)
+        {
+            if (string.IsNullOrEmpty(str))
+                return;
+
+            string[] split = str.Split(':');
+
+            var bank = (OsuLegacyDecoder.LegacySampleBank)Convert.ToInt32(split[0]);
+            var addbank = (OsuLegacyDecoder.LegacySampleBank)Convert.ToInt32(split[1]);
+
+            // Let's not implement this for now, because this doesn't fit nicely into the bank structure
+            //string sampleFile = split2.Length > 4 ? split2[4] : string.Empty;
+
+            string stringBank = bank.ToString().ToLower();
+            if (stringBank == @"none")
+                stringBank = null;
+            string stringAddBank = addbank.ToString().ToLower();
+            if (stringAddBank == @"none")
+                stringAddBank = null;
+
+            normalSampleBank = stringBank;
+            addSampleBank = stringAddBank;
+            sampleVolume = split.Length > 3 ? int.Parse(split[3]) : 0;
+        }
+
+        /// <summary>
+        /// Creates a legacy Hit-type hit object.
+        /// </summary>
+        /// <param name="position">The position of the hit object.</param>
+        /// <param name="newCombo">Whether the hit object creates a new combo.</param>
+        /// <returns>The hit object.</returns>
+        protected abstract HitObject CreateHit(Vector2 position, bool newCombo);
+
+        /// <summary>
+        /// Creats a legacy Slider-type hit object.
+        /// </summary>
+        /// <param name="position">The position of the hit object.</param>
+        /// <param name="newCombo">Whether the hit object creates a new combo.</param>
+        /// <param name="controlPoints">The slider control points.</param>
+        /// <param name="length">The slider length.</param>
+        /// <param name="curveType">The slider curve type.</param>
+        /// <param name="repeatCount">The slider repeat count.</param>
+        /// <returns>The hit object.</returns>
+        protected abstract HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount);
+
+        /// <summary>
+        /// Creates a legacy Spinner-type hit object.
+        /// </summary>
+        /// <param name="position">The position of the hit object.</param>
+        /// <param name="endTime">The spinner end time.</param>
+        /// <returns>The hit object.</returns>
+        protected abstract HitObject CreateSpinner(Vector2 position, double endTime);
+
+        [Flags]
+        private enum LegacySoundType
+        {
+            None = 0,
+            Normal = 1,
+            Whistle = 2,
+            Finish = 4,
+            Clap = 8
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+// 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.Objects.Legacy
+{
+    [Flags]
+    public enum HitObjectType
+    {
+        Circle = 1 << 0,
+        Slider = 1 << 1,
+        NewCombo = 1 << 2,
+        Spinner = 1 << 3,
+        ColourHax = 112,
+        Hold = 1 << 7
+    }
+}

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

@@ -0,0 +1,22 @@
+// 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;
+
+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
+    {
+        public Vector2 Position { get; set; }
+
+        public float X => Position.X;
+
+        public float Y => Position.Y;
+
+        public bool NewCombo { get; set; }
+    }
+}

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

@@ -0,0 +1,17 @@
+// 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;
+
+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
+    {
+        public float X { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}

osu.Game/Rulesets/Objects/Legacy/Mania/HitObjectParser.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 OpenTK;
+using osu.Game.Rulesets.Objects.Types;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Mania
+{
+    /// <summary>
+    /// A HitObjectParser to parse legacy osu!mania Beatmaps.
+    /// </summary>
+    internal class HitObjectParser : Legacy.HitObjectParser
+    {
+        protected override HitObject CreateHit(Vector2 position, bool newCombo)
+        {
+            return new Hit
+            {
+                X = position.X,
+                NewCombo = newCombo,
+            };
+        }
+
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        {
+            return new Slider
+            {
+                X = position.X,
+                NewCombo = newCombo,
+                ControlPoints = controlPoints,
+                Distance = length,
+                CurveType = curveType,
+                RepeatCount = repeatCount
+            };
+        }
+
+        protected override HitObject CreateSpinner(Vector2 position, double endTime)
+        {
+            return new Spinner
+            {
+                X = position.X,
+                EndTime = endTime
+            };
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+// 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;
+
+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
+    {
+        public float X { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}

osu.Game/Rulesets/Objects/Legacy/Mania/Spinner.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 osu.Game.Rulesets.Objects.Types;
+
+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
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+
+        public float X { get; set; }
+    }
+}

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

@@ -0,0 +1,22 @@
+// 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 OpenTK;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Osu
+{
+    /// <summary>
+    /// Legacy osu! Hit-type, used for parsing Beatmaps.
+    /// </summary>
+    internal sealed class Hit : HitObject, IHasPosition, IHasCombo
+    {
+        public Vector2 Position { get; set; }
+
+        public float X => Position.X;
+
+        public float Y => Position.Y;
+
+        public bool NewCombo { get; set; }
+    }
+}

osu.Game/Rulesets/Objects/Legacy/Osu/HitObjectParser.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 OpenTK;
+using osu.Game.Rulesets.Objects.Types;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Osu
+{
+    /// <summary>
+    /// A HitObjectParser to parse legacy osu! Beatmaps.
+    /// </summary>
+    internal class HitObjectParser : Legacy.HitObjectParser
+    {
+        protected override HitObject CreateHit(Vector2 position, bool newCombo)
+        {
+            return new Hit
+            {
+                Position = position,
+                NewCombo = newCombo,
+            };
+        }
+
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        {
+            return new Slider
+            {
+                Position = position,
+                NewCombo = newCombo,
+                ControlPoints = controlPoints,
+                Distance = length,
+                CurveType = curveType,
+                RepeatCount = repeatCount
+            };
+        }
+
+        protected override HitObject CreateSpinner(Vector2 position, double endTime)
+        {
+            return new Spinner
+            {
+                Position = position,
+                EndTime = endTime
+            };
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+// 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 OpenTK;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Osu
+{
+    /// <summary>
+    /// Legacy osu! Slider-type, used for parsing Beatmaps.
+    /// </summary>
+    internal sealed class Slider : CurvedHitObject, IHasPosition, IHasCombo
+    {
+        public Vector2 Position { get; set; }
+
+        public float X => Position.X;
+
+        public float Y => Position.Y;
+
+        public bool NewCombo { get; set; }
+    }
+}

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

@@ -0,0 +1,24 @@
+// 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 OpenTK;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Osu
+{
+    /// <summary>
+    /// Legacy osu! Spinner-type, used for parsing Beatmaps.
+    /// </summary>
+    internal sealed class Spinner : HitObject, IHasEndTime, IHasPosition
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+
+        public Vector2 Position { get; set; }
+
+        public float X => Position.X;
+
+        public float Y => Position.Y;
+    }
+}

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

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

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

@@ -0,0 +1,43 @@
+// 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.Legacy.Taiko
+{
+    /// <summary>
+    /// A HitObjectParser to parse legacy osu!taiko Beatmaps.
+    /// </summary>
+    internal class HitObjectParser : Legacy.HitObjectParser
+    {
+        protected override HitObject CreateHit(Vector2 position, bool newCombo)
+        {
+            return new Hit
+            {
+                NewCombo = newCombo,
+            };
+        }
+
+        protected override HitObject CreateSlider(Vector2 position, bool newCombo, List<Vector2> controlPoints, double length, CurveType curveType, int repeatCount)
+        {
+            return new Slider
+            {
+                NewCombo = newCombo,
+                ControlPoints = controlPoints,
+                Distance = length,
+                CurveType = curveType,
+                RepeatCount = repeatCount
+            };
+        }
+
+        protected override HitObject CreateSpinner(Vector2 position, double endTime)
+        {
+            return new Spinner
+            {
+                EndTime = endTime
+            };
+        }
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+// 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;
+
+namespace osu.Game.Rulesets.Objects.Legacy.Taiko
+{
+    /// <summary>
+    /// Legacy osu!taiko Spinner-type, used for parsing Beatmaps.
+    /// </summary>
+    internal sealed class Spinner : HitObject, IHasEndTime
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+    }
+}

osu.Game/Rulesets/Objects/SliderCurve.cs

@@ -0,0 +1,203 @@
+// 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;
+using System.Linq;
+using osu.Framework.MathUtils;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Objects
+{
+    public class SliderCurve
+    {
+        public double Distance;
+
+        public List<Vector2> ControlPoints;
+
+        public CurveType CurveType = CurveType.PerfectCurve;
+
+        public Vector2 Offset;
+
+        private readonly List<Vector2> calculatedPath = new List<Vector2>();
+        private readonly List<double> cumulativeLength = new List<double>();
+
+        private List<Vector2> calculateSubpath(List<Vector2> subControlPoints)
+        {
+            switch (CurveType)
+            {
+                case CurveType.Linear:
+                    return subControlPoints;
+                case CurveType.PerfectCurve:
+                    //we can only use CircularArc iff we have exactly three control points and no dissection.
+                    if (ControlPoints.Count != 3 || subControlPoints.Count != 3)
+                        break;
+
+                    // Here we have exactly 3 control points. Attempt to fit a circular arc.
+                    List<Vector2> subpath = new CircularArcApproximator(subControlPoints[0], subControlPoints[1], subControlPoints[2]).CreateArc();
+
+                    // If for some reason a circular arc could not be fit to the 3 given points, fall back to a numerically stable bezier approximation.
+                    if (subpath.Count == 0)
+                        break;
+
+                    return subpath;
+            }
+
+            return new BezierApproximator(subControlPoints).CreateBezier();
+        }
+
+        private void calculatePath()
+        {
+            calculatedPath.Clear();
+
+            // Sliders may consist of various subpaths separated by two consecutive vertices
+            // with the same position. The following loop parses these subpaths and computes
+            // their shape independently, consecutively appending them to calculatedPath.
+            List<Vector2> subControlPoints = new List<Vector2>();
+            for (int i = 0; i < ControlPoints.Count; ++i)
+            {
+                subControlPoints.Add(ControlPoints[i]);
+                if (i == ControlPoints.Count - 1 || ControlPoints[i] == ControlPoints[i + 1])
+                {
+                    List<Vector2> subpath = calculateSubpath(subControlPoints);
+                    foreach (Vector2 t in subpath)
+                        if (calculatedPath.Count == 0 || calculatedPath.Last() != t)
+                            calculatedPath.Add(t);
+
+                    subControlPoints.Clear();
+                }
+            }
+        }
+
+        private void calculateCumulativeLengthAndTrimPath()
+        {
+            double l = 0;
+
+            cumulativeLength.Clear();
+            cumulativeLength.Add(l);
+
+            for (int i = 0; i < calculatedPath.Count - 1; ++i)
+            {
+                Vector2 diff = calculatedPath[i + 1] - calculatedPath[i];
+                double d = diff.Length;
+
+                // Shorten slider curves that are too long compared to what's
+                // in the .osu file.
+                if (Distance - l < d)
+                {
+                    calculatedPath[i + 1] = calculatedPath[i] + diff * (float)((Distance - l) / d);
+                    calculatedPath.RemoveRange(i + 2, calculatedPath.Count - 2 - i);
+
+                    l = Distance;
+                    cumulativeLength.Add(l);
+                    break;
+                }
+
+                l += d;
+                cumulativeLength.Add(l);
+            }
+
+            //TODO: Figure out if the following code is needed in some cases. Judging by the map
+            //      "Transform" http://osu.ppy.sh/s/484689 it seems like we should _not_ be doing this.
+            // Lengthen slider curves that are too short compared to what's
+            // in the .osu file.
+            /*if (l < Length && calculatedPath.Count > 1)
+            {
+                Vector2 diff = calculatedPath[calculatedPath.Count - 1] - calculatedPath[calculatedPath.Count - 2];
+                double d = diff.Length;
+
+                if (d <= 0)
+                    return;
+
+                calculatedPath[calculatedPath.Count - 1] += diff * (float)((Length - l) / d);
+                cumulativeLength[calculatedPath.Count - 1] = Length;
+            }*/
+        }
+
+        public void Calculate()
+        {
+            calculatePath();
+            calculateCumulativeLengthAndTrimPath();
+        }
+
+        private int indexOfDistance(double d)
+        {
+            int i = cumulativeLength.BinarySearch(d);
+            if (i < 0) i = ~i;
+
+            return i;
+        }
+
+        private double progressToDistance(double progress)
+        {
+            return MathHelper.Clamp(progress, 0, 1) * Distance;
+        }
+
+        private Vector2 interpolateVertices(int i, double d)
+        {
+            if (calculatedPath.Count == 0)
+                return Vector2.Zero;
+
+            if (i <= 0)
+                return calculatedPath.First();
+            else if (i >= calculatedPath.Count)
+                return calculatedPath.Last();
+
+            Vector2 p0 = calculatedPath[i - 1];
+            Vector2 p1 = calculatedPath[i];
+
+            double d0 = cumulativeLength[i - 1];
+            double d1 = cumulativeLength[i];
+
+            // Avoid division by and almost-zero number in case two points are extremely close to each other.
+            if (Precision.AlmostEquals(d0, d1))
+                return p0;
+
+            double w = (d - d0) / (d1 - d0);
+            return p0 + (p1 - p0) * (float)w;
+        }
+
+        /// <summary>
+        /// Computes the slider curve until a given progress that ranges from 0 (beginning of the slider)
+        /// to 1 (end of the slider) and stores the generated path in the given list.
+        /// </summary>
+        /// <param name="path">The list to be filled with the computed curve.</param>
+        /// <param name="p0">Start progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
+        /// <param name="p1">End progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
+        public void GetPathToProgress(List<Vector2> path, double p0, double p1)
+        {
+            if (calculatedPath.Count == 0 && ControlPoints.Count > 0)
+                Calculate();
+
+            double d0 = progressToDistance(p0);
+            double d1 = progressToDistance(p1);
+
+            path.Clear();
+
+            int i = 0;
+            for (; i < calculatedPath.Count && cumulativeLength[i] < d0; ++i) { }
+
+            path.Add(interpolateVertices(i, d0) + Offset);
+
+            for (; i < calculatedPath.Count && cumulativeLength[i] <= d1; ++i)
+                path.Add(calculatedPath[i] + Offset);
+
+            path.Add(interpolateVertices(i, d1) + Offset);
+        }
+
+        /// <summary>
+        /// Computes the position on the slider at a given progress that ranges from 0 (beginning of the curve)
+        /// to 1 (end of the curve).
+        /// </summary>
+        /// <param name="progress">Ranges from 0 (beginning of the curve) to 1 (end of the curve).</param>
+        /// <returns></returns>
+        public Vector2 PositionAt(double progress)
+        {
+            if (calculatedPath.Count == 0 && ControlPoints.Count > 0)
+                Calculate();
+
+            double d = progressToDistance(progress);
+            return interpolateVertices(indexOfDistance(d), d) + Offset;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    public enum CurveType
+    {
+        Catmull,
+        Bezier,
+        Linear,
+        PerfectCurve
+    }
+}

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

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that is part of a combo.
+    /// </summary>
+    public interface IHasCombo
+    {
+        /// <summary>
+        /// Whether the HitObject starts a new combo.
+        /// </summary>
+        bool NewCombo { get; }
+    }
+}

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

@@ -0,0 +1,52 @@
+// 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;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a curve.
+    /// </summary>
+    public interface IHasCurve : IHasDistance, IHasRepeats
+    {
+        /// <summary>
+        /// The curve.
+        /// </summary>
+        SliderCurve Curve { get; }
+
+        /// <summary>
+        /// The control points that shape the curve.
+        /// </summary>
+        List<Vector2> ControlPoints { get; }
+
+        /// <summary>
+        /// The type of curve.
+        /// </summary>
+        CurveType CurveType { get; }
+
+        /// <summary>
+        /// Computes the position on the curve at a given progress, accounting for repeat logic.
+        /// <para>
+        /// Ranges from [0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.
+        /// </para>
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        Vector2 PositionAt(double progress);
+
+        /// <summary>
+        /// Finds the progress along the curve, accounting for repeat logic.
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        /// <returns>[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</returns>
+        double ProgressAt(double progress);
+
+        /// <summary>
+        /// Determines which repeat of the curve the progress point is on.
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        /// <returns>[0, RepeatCount] where 0 is the first run.</returns>
+        int RepeatAt(double progress);
+    }
+}

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

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a positional length.
+    /// </summary>
+    public interface IHasDistance : IHasEndTime
+    {
+        /// <summary>
+        /// The positional length of the HitObject.
+        /// </summary>
+        double Distance { get; }
+    }
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that ends at a different time than its start time.
+    /// </summary>
+    public interface IHasEndTime
+    {
+        /// <summary>
+        /// The time at which the HitObject ends.
+        /// </summary>
+        double EndTime { get; }
+
+        /// <summary>
+        /// The duration of the HitObject.
+        /// </summary>
+        double Duration { get; }
+    }
+}

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

@@ -0,0 +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
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A special type of HitObject, mostly used for legacy conversion of "holds".
+    /// </summary>
+    public interface IHasHold
+    {
+    }
+}

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

@@ -0,0 +1,18 @@
+// 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;
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a starting position.
+    /// </summary>
+    public interface IHasPosition : IHasXPosition, IHasYPosition
+    {
+        /// <summary>
+        /// The starting position of the HitObject.
+        /// </summary>
+        Vector2 Position { get; }
+    }
+}

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

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that spans some length.
+    /// </summary>
+    public interface IHasRepeats : IHasEndTime
+    {
+        /// <summary>
+        /// The amount of times the HitObject repeats.
+        /// </summary>
+        int RepeatCount { get; }
+    }
+}

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

@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a starting X-position.
+    /// </summary>
+    public interface IHasXPosition
+    {
+        /// <summary>
+        /// The starting X-position of this HitObject.
+        /// </summary>
+        float X { get; }
+    }
+}

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

@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a starting Y-position.
+    /// </summary>
+    public interface IHasYPosition
+    {
+        /// <summary>
+        /// The starting Y-position of this HitObject.
+        /// </summary>
+        float Y { get; }
+    }
+}