Merge remote-tracking branch 'origin/master' into generic_judgements_2

Conflicts: osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs osu.Game.Modes.Catch/UI/CatchHitRenderer.cs osu.Game.Modes.Mania/UI/ManiaHitRenderer.cs osu.Game.Modes.Mania/osu.Game.Modes.Mania.csproj osu.Game.Modes.Osu/Objects/Drawables/DrawableSlider.cs osu.Game.Modes.Osu/Objects/Drawables/DrawableSpinner.cs osu.Game.Modes.Osu/UI/OsuHitRenderer.cs osu.Game.Modes.Taiko/UI/TaikoHitRenderer.cs osu.Game.Modes.Taiko/osu.Game.Modes.Taiko.csproj osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs osu.Game/Modes/UI/HitRenderer.cs osu.Game/osu.Game.csproj
2025-08-04 07:06:35 +09:00 · 2017-03-15 21:36:43 +09:00
parent 3a8d1d3619 b5edcf864b
commit 42da0f1a72
70 changed files with 845 additions and 371 deletions
--- a/osu.Game/Modes/Objects/BezierApproximator.cs
+++ b/osu.Game/Modes/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.Modes.Objects
+{
+    public class BezierApproximator
+    {
+        private int count;
+        private List<Vector2> controlPoints;
+        private Vector2[] subdivisionBuffer1;
+        private 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;
+        }
+    }
+}
--- a/osu.Game/Modes/Objects/CircularArcApproximator.cs
+++ b/osu.Game/Modes/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.Modes.Objects
+{
+    public class CircularArcApproximator
+    {
+        private Vector2 a;
+        private Vector2 b;
+        private 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;
+        }
+    }
+}
--- a/osu.Game/Modes/Objects/CurvedHitObject.cs
+++ b/osu.Game/Modes/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.Modes.Objects.Types;
+using System.Collections.Generic;
+
+namespace osu.Game.Modes.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);
+    }
+}
--- a/osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs
@ -10,6 +10,7 @@ using osu.Framework.Audio.Sample;
 using osu.Game.Beatmaps.Samples;
 using osu.Game.Modes.Judgements;
 using Container = osu.Framework.Graphics.Containers.Container;
+using osu.Game.Modes.Objects.Types;

 namespace osu.Game.Modes.Objects.Drawables
 {
@ -89,7 +90,9 @@ namespace osu.Game.Modes.Objects.Drawables
            if (Judgement.Result != null)
                return false;

-            Judgement.TimeOffset = Time.Current - HitObject.EndTime;
+            double endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+
+            Judgement.TimeOffset = Time.Current - endTime;

            CheckJudgement(userTriggered);

--- a/osu.Game/Modes/Objects/HitObject.cs
+++ b/osu.Game/Modes/Objects/HitObject.cs
@ -1,30 +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 osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Samples;
-using OpenTK.Graphics;

 namespace osu.Game.Modes.Objects
 {
    /// <summary>
-    /// A hitobject describes a point in a beatmap 
+    /// 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 abstract class HitObject
+    public class HitObject
    {
-        public double StartTime;
-        public virtual double EndTime => StartTime;
+        /// <summary>
+        /// The time at which the HitObject starts.
+        /// </summary>
+        public double StartTime { get; set; }

-        public bool NewCombo { get; set; }
-
-        public Color4 Colour = new Color4(17, 136, 170, 255);
-
-        public double Duration => EndTime - StartTime;
-
-        public HitSampleInfo Sample;
-
-        public int ComboIndex;
-
-        public virtual void SetDefaultsFromBeatmap(Beatmap beatmap) { }
+        /// <summary>
+        /// The sample to be played when this HitObject is hit.
+        /// </summary>
+        public HitSampleInfo Sample { get; set; }
    }
 }
--- a/osu.Game/Modes/Objects/Legacy/LegacyHit.cs
+++ b/osu.Game/Modes/Objects/Legacy/LegacyHit.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 osu.Game.Modes.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Hit-type, used for parsing Beatmaps.
+    /// </summary>
+    public sealed class LegacyHit : HitObject, IHasPosition, IHasCombo
+    {
+        public Vector2 Position { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}
--- a/osu.Game/Modes/Objects/Legacy/LegacyHitObjectType.cs
+++ b/osu.Game/Modes/Objects/Legacy/LegacyHitObjectType.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.Modes.Objects.Legacy
+{
+    [Flags]
+    public enum LegacyHitObjectType
+    {
+        Circle = 1 << 0,
+        Slider = 1 << 1,
+        NewCombo = 1 << 2,
+        Spinner = 1 << 3,
+        ColourHax = 112,
+        Hold = 1 << 7
+    }
+}
--- a/osu.Game/Modes/Objects/Legacy/LegacyHold.cs
+++ b/osu.Game/Modes/Objects/Legacy/LegacyHold.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;
+using osu.Game.Modes.Objects.Types;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Hold-type, used for parsing "specials" in beatmaps.
+    /// </summary>
+    public sealed class LegacyHold : HitObject, IHasPosition, IHasCombo, IHasHold
+    {
+        public Vector2 Position { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}
--- a/osu.Game/Modes/Objects/Legacy/LegacySlider.cs
+++ b/osu.Game/Modes/Objects/Legacy/LegacySlider.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 osu.Game.Modes.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Slider-type, used for parsing Beatmaps.
+    /// </summary>
+    public sealed class LegacySlider : CurvedHitObject, IHasPosition, IHasCombo
+    {
+        public Vector2 Position { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}
--- a/osu.Game/Modes/Objects/Legacy/LegacySpinner.cs
+++ b/osu.Game/Modes/Objects/Legacy/LegacySpinner.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.Modes.Objects.Types;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Spinner-type, used for parsing Beatmaps.
+    /// </summary>
+    internal class LegacySpinner : HitObject, IHasEndTime
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+    }
+}
--- a/osu.Game/Modes/Objects/LegacyHitObjectParser.cs
+++ b/osu.Game/Modes/Objects/LegacyHitObjectParser.cs
@ -0,0 +1,119 @@
+// 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.Beatmaps.Samples;
+using osu.Game.Modes.Objects.Types;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using osu.Game.Modes.Objects.Legacy;
+
+namespace osu.Game.Modes.Objects
+{
+    internal class LegacyHitObjectParser : HitObjectParser
+    {
+        public override HitObject Parse(string text)
+        {
+            string[] split = text.Split(',');
+            var type = (LegacyHitObjectType)int.Parse(split[3]) & ~LegacyHitObjectType.ColourHax;
+            bool combo = type.HasFlag(LegacyHitObjectType.NewCombo);
+            type &= ~LegacyHitObjectType.NewCombo;
+
+            HitObject result;
+
+            if ((type & LegacyHitObjectType.Circle) > 0)
+            {
+                result = new LegacyHit
+                {
+                    Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
+                    NewCombo = combo
+                };
+            }
+            else if ((type & LegacyHitObjectType.Slider) > 0)
+            {
+                CurveType curveType = CurveType.Catmull;
+                double length = 0;
+                List<Vector2> 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(':');
+                    Vector2 v = new Vector2(
+                        (int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture),
+                        (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)
+                    );
+                    points.Add(v);
+                }
+
+                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 = new LegacySlider
+                {
+                    ControlPoints = points,
+                    Distance = length,
+                    CurveType = curveType,
+                    RepeatCount = repeatCount,
+                    Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
+                    NewCombo = combo
+                };
+            }
+            else if ((type & LegacyHitObjectType.Spinner) > 0)
+            {
+                result = new LegacySpinner
+                {
+                    EndTime = Convert.ToDouble(split[5], CultureInfo.InvariantCulture)
+                };
+            }
+            else if ((type & LegacyHitObjectType.Hold) > 0)
+            {
+                // Note: Hold is generated by BMS converts
+                result = new LegacyHold
+                {
+                    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);
+            result.Sample = new HitSampleInfo
+            {
+                Type = (SampleType)int.Parse(split[4]),
+                Set = SampleSet.Soft,
+            };
+
+            // TODO: "addition" field
+
+            return result;
+        }
+    }
+}
--- a/osu.Game/Modes/Objects/NullHitObjectParser.cs
+++ b/osu.Game/Modes/Objects/NullHitObjectParser.cs
@ -1,13 +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
-
-namespace osu.Game.Modes.Objects
-{
-    /// <summary>
-    /// Returns null HitObjects but at least allows us to run.
-    /// </summary>
-    public class NullHitObjectParser : HitObjectParser
-    {
-        public override HitObject Parse(string text) => null;
-    }
-}
--- a/osu.Game/Modes/Objects/SliderCurve.cs
+++ b/osu.Game/Modes/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.Modes.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects
+{
+    public class SliderCurve
+    {
+        public double Distance;
+
+        public List<Vector2> ControlPoints;
+
+        public CurveType CurveType = CurveType.PerfectCurve;
+
+        public Vector2 Offset;
+
+        private List<Vector2> calculatedPath = new List<Vector2>();
+        private 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;
+        }
+    }
+}
--- a/osu.Game/Modes/Objects/Types/CurveType.cs
+++ b/osu.Game/Modes/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.Modes.Objects.Types
+{
+    public enum CurveType
+    {
+        Catmull,
+        Bezier,
+        Linear,
+        PerfectCurve
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasCombo.cs
+++ b/osu.Game/Modes/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.Modes.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; }
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasCurve.cs
+++ b/osu.Game/Modes/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.Modes.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);
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasDistance.cs
+++ b/osu.Game/Modes/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.Modes.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; }
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasEndTime.cs
+++ b/osu.Game/Modes/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.Modes.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; }
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasHold.cs
+++ b/osu.Game/Modes/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.Modes.Objects.Types
+{
+    /// <summary>
+    /// A special type of HitObject, mostly used for legacy conversion of "holds".
+    /// </summary>
+    public interface IHasHold
+    {
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasPosition.cs
+++ b/osu.Game/Modes/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.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a starting position.
+    /// </summary>
+    public interface IHasPosition
+    {
+        /// <summary>
+        /// The starting position of the HitObject.
+        /// </summary>
+        Vector2 Position { get; }
+    }
+}
--- a/osu.Game/Modes/Objects/Types/IHasRepeats.cs
+++ b/osu.Game/Modes/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.Modes.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; }
+    }
+}